Skip to content

The open-source AI voice studio. Clone, dictate, create.

Implement audio channel management features

Jamie Pine30ea627ae852
diff --git a/app/src/App.tsx b/app/src/App.tsx
index d76f7655..202c8ac4 100644
--- a/app/src/App.tsx
+++ b/app/src/App.tsx
@@ -3,15 +3,14 @@ import voiceboxLogo from '@/assets/voicebox-logo.png';
import { AudioPlayer } from '@/components/AudioPlayer/AudioPlayer';
import { GenerationForm } from '@/components/Generation/GenerationForm';
import { HistoryTable } from '@/components/History/HistoryTable';
-import { ConnectionForm } from '@/components/ServerSettings/ConnectionForm';
-import { ModelManagement } from '@/components/ServerSettings/ModelManagement';
-import { ServerStatus } from '@/components/ServerSettings/ServerStatus';
-import { UpdateStatus } from '@/components/ServerSettings/UpdateStatus';
import ShinyText from '@/components/ShinyText';
import { Sidebar } from '@/components/Sidebar';
import { TitleBarDragRegion } from '@/components/TitleBarDragRegion';
import { Toaster } from '@/components/ui/toaster';
import { ProfileList } from '@/components/VoiceProfiles/ProfileList';
+import { VoicesTab } from '@/components/VoicesTab/VoicesTab';
+import { AudioTab } from '@/components/AudioTab/AudioTab';
+import { ServerTab } from '@/components/ServerTab/ServerTab';
import { useModelDownloadToast } from '@/lib/hooks/useModelDownloadToast';
import { MODEL_DISPLAY_NAMES, useRestoreActiveTasks } from '@/lib/hooks/useRestoreActiveTasks';
import {
@@ -174,27 +173,7 @@ function App() {
<main className="flex-1 ml-20 overflow-hidden flex flex-col">
<div className="container mx-auto px-8 max-w-[1800px] h-full overflow-hidden flex flex-col">
- {activeTab === 'settings' ? (
- <div className="space-y-4 overflow-y-auto flex flex-col">
- <div className="grid gap-4 md:grid-cols-2">
- <ConnectionForm />
- <ServerStatus />
- </div>
- {isTauri() && <UpdateStatus />}
- <ModelManagement />
- <div className="py-8 text-center text-sm text-muted-foreground">
- Created by{' '}
- <a
- href="https://github.com/jamiepine"
- target="_blank"
- rel="noopener noreferrer"
- className="text-accent hover:underline"
- >
- Jamie Pine
- </a>
- </div>
- </div>
- ) : (
+ {activeTab === 'main' && (
// Main view: Profiles top left, Generator bottom left, History right
<div className="grid grid-cols-1 lg:grid-cols-2 gap-6 h-full min-h-0 overflow-hidden">
{/* Left Column */}
@@ -216,12 +195,15 @@ function App() {
</div>
</div>
)}
+ {activeTab === 'voices' && <VoicesTab />}
+ {activeTab === 'audio' && <AudioTab />}
+ {activeTab === 'server' && <ServerTab />}
</div>
</main>
</div>
- {/* Audio Player - always visible except on settings */}
- {activeTab !== 'settings' && <AudioPlayer />}
+ {/* Audio Player - always visible except on server tab */}
+ {activeTab !== 'server' && <AudioPlayer />}
{/* Show download toasts for any active downloads (from anywhere) */}
{activeDownloads.map((download) => {
diff --git a/app/src/components/AudioPlayer/AudioPlayer.tsx b/app/src/components/AudioPlayer/AudioPlayer.tsx
index 1e125e13..b8af49d6 100644
--- a/app/src/components/AudioPlayer/AudioPlayer.tsx
+++ b/app/src/components/AudioPlayer/AudioPlayer.tsx
@@ -1,15 +1,20 @@
import { Pause, Play, Repeat, Volume2, VolumeX } from 'lucide-react';
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useRef, useState, useMemo } from 'react';
import WaveSurfer from 'wavesurfer.js';
import { Button } from '@/components/ui/button';
import { Slider } from '@/components/ui/slider';
import { formatAudioDuration } from '@/lib/utils/audio';
import { usePlayerStore } from '@/stores/playerStore';
+import { useQuery } from '@tanstack/react-query';
+import { apiClient } from '@/lib/api/client';
+import { isTauri } from '@/lib/tauri';
+import { invoke } from '@tauri-apps/api/core';
export function AudioPlayer() {
const {
audioUrl,
audioId,
+ profileId,
title,
isPlaying,
currentTime,
@@ -25,6 +30,36 @@ export function AudioPlayer() {
clearRestartFlag,
} = usePlayerStore();
+ // Check if profile has assigned channels (for native audio routing)
+ const { data: profileChannels } = useQuery({
+ queryKey: ['profile-channels', profileId],
+ queryFn: () => {
+ if (!profileId) return { channel_ids: [] };
+ return apiClient.getProfileChannels(profileId);
+ },
+ enabled: !!profileId && isTauri(),
+ });
+
+ const { data: channels } = useQuery({
+ queryKey: ['channels'],
+ queryFn: () => apiClient.listChannels(),
+ enabled: !!profileChannels && profileChannels.channel_ids.length > 0,
+ });
+
+ // Determine if we should use native playback
+ const useNativePlayback = useMemo(() => {
+ if (!isTauri() || !profileChannels || !channels) return false;
+
+ const assignedChannels = channels.filter((ch) =>
+ profileChannels.channel_ids.includes(ch.id),
+ );
+
+ // Use native playback if any assigned channel has non-default devices
+ return assignedChannels.some(
+ (ch) => ch.device_ids.length > 0 && !ch.is_default,
+ );
+ }, [profileChannels, channels, isTauri()]);
+
const waveformRef = useRef<HTMLDivElement>(null);
const wavesurferRef = useRef<WaveSurfer | null>(null);
const loadingRef = useRef(false);
@@ -395,7 +430,44 @@ export function AudioPlayer() {
// Handle loop - WaveSurfer handles this via the 'finish' event
- const handlePlayPause = () => {
+ const handlePlayPause = async () => {
+ // If using native playback, handle differently
+ if (useNativePlayback && audioUrl && profileChannels && channels) {
+ if (isPlaying) {
+ // For native playback, we'd need to track and stop streams
+ // For now, just toggle the state
+ setIsPlaying(false);
+ return;
+ }
+
+ try {
+ // Collect all device IDs from assigned channels
+ const assignedChannels = channels.filter((ch) =>
+ profileChannels.channel_ids.includes(ch.id),
+ );
+ const deviceIds = assignedChannels.flatMap((ch) => ch.device_ids);
+
+ if (deviceIds.length > 0) {
+ // Fetch audio data
+ const response = await fetch(audioUrl);
+ const audioData = new Uint8Array(await response.arrayBuffer());
+
+ // Play via native audio
+ await invoke('play_audio_to_devices', {
+ audio_data: Array.from(audioData),
+ device_ids: deviceIds,
+ });
+
+ setIsPlaying(true);
+ return;
+ }
+ } catch (error) {
+ console.error('Native playback failed, falling back to WaveSurfer:', error);
+ // Fall through to WaveSurfer playback
+ }
+ }
+
+ // Standard WaveSurfer playback
if (!wavesurferRef.current) {
console.error('WaveSurfer not initialized');
return;
diff --git a/app/src/components/AudioTab/AudioTab.tsx b/app/src/components/AudioTab/AudioTab.tsx
new file mode 100644
index 00000000..04e07978
--- /dev/null
+++ b/app/src/components/AudioTab/AudioTab.tsx
@@ -0,0 +1,537 @@
+import { Edit, Plus, Trash2, Speaker } from 'lucide-react';
+import { useState } from 'react';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from '@/components/ui/dialog';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import {
+ Select,
+ SelectContent,
+ SelectItem,
+ SelectTrigger,
+ SelectValue,
+} from '@/components/ui/select';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { apiClient } from '@/lib/api/client';
+import { isTauri } from '@/lib/tauri';
+import { invoke } from '@tauri-apps/api/core';
+
+interface AudioDevice {
+ id: string;
+ name: string;
+ is_default: boolean;
+}
+
+export function AudioTab() {
+ const [createDialogOpen, setCreateDialogOpen] = useState(false);
+ const [editingChannel, setEditingChannel] = useState<string | null>(null);
+ const queryClient = useQueryClient();
+
+ const { data: channels, isLoading: channelsLoading } = useQuery({
+ queryKey: ['channels'],
+ queryFn: () => apiClient.listChannels(),
+ });
+
+ const { data: devices, isLoading: devicesLoading } = useQuery({
+ queryKey: ['audio-devices'],
+ queryFn: async () => {
+ if (!isTauri()) {
+ return [];
+ }
+ try {
+ const result = await invoke<AudioDevice[]>('list_audio_output_devices');
+ return result;
+ } catch (error) {
+ console.error('Failed to list audio devices:', error);
+ return [];
+ }
+ },
+ enabled: isTauri(),
+ });
+
+ const { data: profiles } = useQuery({
+ queryKey: ['profiles'],
+ queryFn: () => apiClient.listProfiles(),
+ });
+
+ const createChannel = useMutation({
+ mutationFn: (data: { name: string; device_ids: string[] }) =>
+ apiClient.createChannel(data),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['channels'] });
+ setCreateDialogOpen(false);
+ },
+ });
+
+ const updateChannel = useMutation({
+ mutationFn: ({
+ channelId,
+ data,
+ }: {
+ channelId: string;
+ data: { name?: string; device_ids?: string[] };
+ }) => apiClient.updateChannel(channelId, data),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['channels'] });
+ queryClient.invalidateQueries({ queryKey: ['profile-channels'] });
+ setEditingChannel(null);
+ },
+ });
+
+ const deleteChannel = useMutation({
+ mutationFn: (channelId: string) => apiClient.deleteChannel(channelId),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['channels'] });
+ queryClient.invalidateQueries({ queryKey: ['profile-channels'] });
+ },
+ });
+
+ const { data: channelVoices } = useQuery({
+ queryKey: ['channel-voices', editingChannel],
+ queryFn: async () => {
+ if (!editingChannel) return { profile_ids: [] };
+ return apiClient.getChannelVoices(editingChannel);
+ },
+ enabled: !!editingChannel,
+ });
+
+ const setChannelVoices = useMutation({
+ mutationFn: ({ channelId, profileIds }: { channelId: string; profileIds: string[] }) =>
+ apiClient.setChannelVoices(channelId, profileIds),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['channel-voices'] });
+ queryClient.invalidateQueries({ queryKey: ['profile-channels'] });
+ },
+ });
+
+ if (channelsLoading || devicesLoading) {
+ return (
+ <div className="flex items-center justify-center h-full">
+ <div className="text-muted-foreground">Loading...</div>
+ </div>
+ );
+ }
+
+ return (
+ <div className="h-full flex flex-col">
+ <div className="flex items-center justify-between mb-6">
+ <h1 className="text-2xl font-bold">Audio Channels</h1>
+ <Button onClick={() => setCreateDialogOpen(true)}>
+ <Plus className="h-4 w-4 mr-2" />
+ New Channel
+ </Button>
+ </div>
+
+ <div className="flex-1 overflow-auto space-y-4">
+ {channels?.map((channel) => (
+ <Card key={channel.id}>
+ <CardHeader>
+ <div className="flex items-center justify-between">
+ <CardTitle className="flex items-center gap-2">
+ <Speaker className="h-5 w-5" />
+ {channel.name}
+ {channel.is_default && (
+ <span className="text-xs text-muted-foreground">(Default)</span>
+ )}
+ </CardTitle>
+ {!channel.is_default && (
+ <div className="flex gap-2">
+ <Button
+ variant="ghost"
+ size="sm"
+ onClick={() => setEditingChannel(channel.id)}
+ >
+ <Edit className="h-4 w-4" />
+ </Button>
+ <Button
+ variant="ghost"
+ size="sm"
+ onClick={() => {
+ if (confirm('Delete this channel?')) {
+ deleteChannel.mutate(channel.id);
+ }
+ }}
+ >
+ <Trash2 className="h-4 w-4" />
+ </Button>
+ </div>
+ )}
+ </div>
+ </CardHeader>
+ <CardContent>
+ <div className="space-y-2">
+ <div>
+ <Label className="text-sm font-medium">Output Devices:</Label>
+ <div className="mt-1 text-sm text-muted-foreground">
+ {channel.device_ids.length > 0 ? (
+ <ul className="list-disc list-inside">
+ {channel.device_ids.map((deviceId) => {
+ const device = devices?.find((d) => d.id === deviceId);
+ return (
+ <li key={deviceId}>{device?.name || deviceId || 'Default Speakers'}</li>
+ );
+ })}
+ </ul>
+ ) : (
+ <span>Default Speakers</span>
+ )}
+ </div>
+ </div>
+ <div>
+ <Label className="text-sm font-medium">Assigned Voices:</Label>
+ <ChannelVoicesList channelId={channel.id} />
+ </div>
+ </div>
+ </CardContent>
+ </Card>
+ ))}
+ </div>
+
+ <div className="mt-8 pt-6 border-t">
+ <h2 className="text-lg font-semibold mb-4">Available Devices</h2>
+ <div className="space-y-2">
+ {devices && devices.length > 0 ? (
+ devices.map((device) => (
+ <div key={device.id} className="text-sm">
+ <span className="font-medium">{device.name}</span>
+ {device.is_default && (
+ <span className="text-muted-foreground ml-2">(default)</span>
+ )}
+ </div>
+ ))
+ ) : (
+ <div className="text-sm text-muted-foreground">
+ {isTauri()
+ ? 'No audio devices found'
+ : 'Audio device selection requires Tauri'}
+ </div>
+ )}
+ </div>
+ </div>
+
+ {/* Create Channel Dialog */}
+ <CreateChannelDialog
+ open={createDialogOpen}
+ onOpenChange={setCreateDialogOpen}
+ devices={devices || []}
+ onCreate={(name, deviceIds) => {
+ createChannel.mutate({ name, device_ids: deviceIds });
+ }}
+ />
+
+ {/* Edit Channel Dialog */}
+ {editingChannel && (
+ <EditChannelDialog
+ open={!!editingChannel}
+ onOpenChange={(open) => !open && setEditingChannel(null)}
+ channel={channels?.find((c) => c.id === editingChannel)!}
+ devices={devices || []}
+ profiles={profiles || []}
+ channelVoices={channelVoices?.profile_ids || []}
+ onUpdate={(name, deviceIds) => {
+ updateChannel.mutate({
+ channelId: editingChannel,
+ data: { name, device_ids: deviceIds },
+ });
+ }}
+ onSetVoices={(profileIds) => {
+ setChannelVoices.mutate({
+ channelId: editingChannel,
+ profileIds,
+ });
+ }}
+ />
+ )}
+ </div>
+ );
+}
+
+function ChannelVoicesList({ channelId }: { channelId: string }) {
+ const { data: voices } = useQuery({
+ queryKey: ['channel-voices', channelId],
+ queryFn: () => apiClient.getChannelVoices(channelId),
+ });
+
+ const { data: profiles } = useQuery({
+ queryKey: ['profiles'],
+ queryFn: () => apiClient.listProfiles(),
+ });
+
+ const voiceNames =
+ voices?.profile_ids
+ .map((id) => profiles?.find((p) => p.id === id)?.name)
+ .filter(Boolean) || [];
+
+ return (
+ <div className="mt-1 text-sm text-muted-foreground">
+ {voiceNames.length > 0 ? (
+ <span>{voiceNames.join(', ')}</span>
+ ) : (
+ <span>No voices assigned</span>
+ )}
+ </div>
+ );
+}
+
+interface CreateChannelDialogProps {
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ devices: AudioDevice[];
+ onCreate: (name: string, deviceIds: string[]) => void;
+}
+
+function CreateChannelDialog({
+ open,
+ onOpenChange,
+ devices,
+ onCreate,
+}: CreateChannelDialogProps) {
+ const [name, setName] = useState('');
+ const [selectedDevices, setSelectedDevices] = useState<string[]>([]);
+
+ const handleSubmit = () => {
+ if (name.trim()) {
+ onCreate(name.trim(), selectedDevices);
+ setName('');
+ setSelectedDevices([]);
+ }
+ };
+
+ return (
+ <Dialog open={open} onOpenChange={onOpenChange}>
+ <DialogContent>
+ <DialogHeader>
+ <DialogTitle>Create Audio Channel</DialogTitle>
+ <DialogDescription>
+ Create a new audio channel (bus) to route voices to specific output devices.
+ </DialogDescription>
+ </DialogHeader>
+ <div className="space-y-4">
+ <div>
+ <Label htmlFor="channel-name">Channel Name</Label>
+ <Input
+ id="channel-name"
+ value={name}
+ onChange={(e) => setName(e.target.value)}
+ placeholder="e.g., Virtual Cable, Broadcast"
+ />
+ </div>
+ <div>
+ <Label>Output Devices</Label>
+ <Select
+ value={selectedDevices[0] || ''}
+ onValueChange={(value) => {
+ if (value && !selectedDevices.includes(value)) {
+ setSelectedDevices([...selectedDevices, value]);
+ }
+ }}
+ >
+ <SelectTrigger>
+ <SelectValue placeholder="Select device" />
+ </SelectTrigger>
+ <SelectContent>
+ {devices.map((device) => (
+ <SelectItem key={device.id} value={device.id}>
+ {device.name} {device.is_default && '(default)'}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ {selectedDevices.length > 0 && (
+ <div className="mt-2 space-y-1">
+ {selectedDevices.map((deviceId) => {
+ const device = devices.find((d) => d.id === deviceId);
+ return (
+ <div
+ key={deviceId}
+ className="flex items-center justify-between text-sm bg-muted p-2 rounded"
+ >
+ <span>{device?.name || deviceId}</span>
+ <Button
+ variant="ghost"
+ size="sm"
+ onClick={() => setSelectedDevices(selectedDevices.filter((id) => id !== deviceId))}
+ >
+ <Trash2 className="h-3 w-3" />
+ </Button>
+ </div>
+ );
+ })}
+ </div>
+ )}
+ </div>
+ </div>
+ <DialogFooter>
+ <Button variant="outline" onClick={() => onOpenChange(false)}>
+ Cancel
+ </Button>
+ <Button onClick={handleSubmit} disabled={!name.trim()}>
+ Create
+ </Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+ );
+}
+
+interface EditChannelDialogProps {
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ channel: {
+ id: string;
+ name: string;
+ device_ids: string[];
+ };
+ devices: AudioDevice[];
+ profiles: Array<{ id: string; name: string }>;
+ channelVoices: string[];
+ onUpdate: (name: string, deviceIds: string[]) => void;
+ onSetVoices: (profileIds: string[]) => void;
+}
+
+function EditChannelDialog({
+ open,
+ onOpenChange,
+ channel,
+ devices,
+ profiles,
+ channelVoices,
+ onUpdate,
+ onSetVoices,
+}: EditChannelDialogProps) {
+ const [name, setName] = useState(channel.name);
+ const [selectedDevices, setSelectedDevices] = useState<string[]>(channel.device_ids);
+ const [selectedVoices, setSelectedVoices] = useState<string[]>(channelVoices);
+
+ const handleSubmit = () => {
+ if (name.trim()) {
+ onUpdate(name.trim(), selectedDevices);
+ onSetVoices(selectedVoices);
+ }
+ };
+
+ return (
+ <Dialog open={open} onOpenChange={onOpenChange}>
+ <DialogContent className="max-w-2xl">
+ <DialogHeader>
+ <DialogTitle>Edit Channel</DialogTitle>
+ <DialogDescription>Update channel settings and voice assignments.</DialogDescription>
+ </DialogHeader>
+ <div className="space-y-4">
+ <div>
+ <Label htmlFor="edit-channel-name">Channel Name</Label>
+ <Input
+ id="edit-channel-name"
+ value={name}
+ onChange={(e) => setName(e.target.value)}
+ />
+ </div>
+ <div>
+ <Label>Output Devices</Label>
+ <Select
+ value=""
+ onValueChange={(value) => {
+ if (value && !selectedDevices.includes(value)) {
+ setSelectedDevices([...selectedDevices, value]);
+ }
+ }}
+ >
+ <SelectTrigger>
+ <SelectValue placeholder="Add device" />
+ </SelectTrigger>
+ <SelectContent>
+ {devices.map((device) => (
+ <SelectItem key={device.id} value={device.id}>
+ {device.name} {device.is_default && '(default)'}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ {selectedDevices.length > 0 && (
+ <div className="mt-2 space-y-1">
+ {selectedDevices.map((deviceId) => {
+ const device = devices.find((d) => d.id === deviceId);
+ return (
+ <div
+ key={deviceId}
+ className="flex items-center justify-between text-sm bg-muted p-2 rounded"
+ >
+ <span>{device?.name || deviceId}</span>
+ <Button
+ variant="ghost"
+ size="sm"
+ onClick={() => setSelectedDevices(selectedDevices.filter((id) => id !== deviceId))}
+ >
+ <Trash2 className="h-3 w-3" />
+ </Button>
+ </div>
+ );
+ })}
+ </div>
+ )}
+ </div>
+ <div>
+ <Label>Assigned Voices</Label>
+ <Select
+ value=""
+ onValueChange={(value) => {
+ if (value && !selectedVoices.includes(value)) {
+ setSelectedVoices([...selectedVoices, value]);
+ }
+ }}
+ >
+ <SelectTrigger>
+ <SelectValue placeholder="Add voice" />
+ </SelectTrigger>
+ <SelectContent>
+ {profiles.map((profile) => (
+ <SelectItem key={profile.id} value={profile.id}>
+ {profile.name}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ {selectedVoices.length > 0 && (
+ <div className="mt-2 space-y-1">
+ {selectedVoices.map((profileId) => {
+ const profile = profiles.find((p) => p.id === profileId);
+ return (
+ <div
+ key={profileId}
+ className="flex items-center justify-between text-sm bg-muted p-2 rounded"
+ >
+ <span>{profile?.name || profileId}</span>
+ <Button
+ variant="ghost"
+ size="sm"
+ onClick={() => setSelectedVoices(selectedVoices.filter((id) => id !== profileId))}
+ >
+ <Trash2 className="h-3 w-3" />
+ </Button>
+ </div>
+ );
+ })}
+ </div>
+ )}
+ </div>
+ </div>
+ <DialogFooter>
+ <Button variant="outline" onClick={() => onOpenChange(false)}>
+ Cancel
+ </Button>
+ <Button onClick={handleSubmit} disabled={!name.trim()}>
+ Save
+ </Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/app/src/components/Generation/GenerationForm.tsx b/app/src/components/Generation/GenerationForm.tsx
index d11d36d0..2d13bf9e 100644
--- a/app/src/components/Generation/GenerationForm.tsx
+++ b/app/src/components/Generation/GenerationForm.tsx
@@ -120,7 +120,7 @@ export function GenerationForm() {
// Autoplay the generated audio
const audioUrl = apiClient.getAudioUrl(result.id);
- setAudio(audioUrl, result.id, data.text.substring(0, 50));
+ setAudio(audioUrl, result.id, selectedProfileId, data.text.substring(0, 50));
form.reset();
} catch (error) {
diff --git a/app/src/components/History/HistoryTable.tsx b/app/src/components/History/HistoryTable.tsx
index ed2ae6b4..79faa64d 100644
--- a/app/src/components/History/HistoryTable.tsx
+++ b/app/src/components/History/HistoryTable.tsx
@@ -69,14 +69,14 @@ export function HistoryTable() {
return () => scrollEl.removeEventListener('scroll', handleScroll);
}, []);
- const handlePlay = (audioId: string, text: string) => {
+ const handlePlay = (audioId: string, text: string, profileId: string) => {
// If clicking the same audio, restart it from the beginning
if (currentAudioId === audioId) {
restartCurrentAudio();
} else {
// Otherwise, load the new audio
const audioUrl = apiClient.getAudioUrl(audioId);
- setAudio(audioUrl, audioId, text.substring(0, 50));
+ setAudio(audioUrl, audioId, profileId, text.substring(0, 50));
}
};
@@ -195,7 +195,7 @@ export function HistoryTable() {
if (target.closest('textarea') || window.getSelection()?.toString()) {
return;
}
- handlePlay(gen.id, gen.text);
+ handlePlay(gen.id, gen.text, gen.profile_id);
}}
>
{/* Waveform icon */}
@@ -242,7 +242,7 @@ export function HistoryTable() {
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end">
- <DropdownMenuItem onClick={() => handlePlay(gen.id, gen.text)}>
+ <DropdownMenuItem onClick={() => handlePlay(gen.id, gen.text, gen.profile_id)}>
<Play className="mr-2 h-4 w-4" />
Play
</DropdownMenuItem>
diff --git a/app/src/components/ServerTab/ServerTab.tsx b/app/src/components/ServerTab/ServerTab.tsx
new file mode 100644
index 00000000..78e556ae
--- /dev/null
+++ b/app/src/components/ServerTab/ServerTab.tsx
@@ -0,0 +1,29 @@
+import { ConnectionForm } from '@/components/ServerSettings/ConnectionForm';
+import { ModelManagement } from '@/components/ServerSettings/ModelManagement';
+import { ServerStatus } from '@/components/ServerSettings/ServerStatus';
+import { UpdateStatus } from '@/components/ServerSettings/UpdateStatus';
+import { isTauri } from '@/lib/tauri';
+
+export function ServerTab() {
+ return (
+ <div className="space-y-4 overflow-y-auto flex flex-col">
+ <div className="grid gap-4 md:grid-cols-2">
+ <ConnectionForm />
+ <ServerStatus />
+ </div>
+ {isTauri() && <UpdateStatus />}
+ <ModelManagement />
+ <div className="py-8 text-center text-sm text-muted-foreground">
+ Created by{' '}
+ <a
+ href="https://github.com/jamiepine"
+ target="_blank"
+ rel="noopener noreferrer"
+ className="text-accent hover:underline"
+ >
+ Jamie Pine
+ </a>
+ </div>
+ </div>
+ );
+}
diff --git a/app/src/components/Sidebar.tsx b/app/src/components/Sidebar.tsx
index 3b75e65c..2bb4496b 100644
--- a/app/src/components/Sidebar.tsx
+++ b/app/src/components/Sidebar.tsx
@@ -1,4 +1,4 @@
-import { Loader2, Settings, Volume2 } from 'lucide-react';
+import { Loader2, Settings, Volume2, Mic, Speaker, Server } from 'lucide-react';
import voiceboxLogo from '@/assets/voicebox-logo.png';
import { cn } from '@/lib/utils/cn';
import { useGenerationStore } from '@/stores/generationStore';
@@ -11,8 +11,10 @@ interface SidebarProps {
}
const tabs = [
- { id: 'main', icon: Volume2, label: 'Main' },
- { id: 'settings', icon: Settings, label: 'Settings' },
+ { id: 'main', icon: Volume2, label: 'Generate' },
+ { id: 'voices', icon: Mic, label: 'Voices' },
+ { id: 'audio', icon: Speaker, label: 'Audio' },
+ { id: 'server', icon: Server, label: 'Server' },
];
export function Sidebar({ activeTab, onTabChange, isMacOS }: SidebarProps) {
diff --git a/app/src/components/VoicesTab/VoicesTab.tsx b/app/src/components/VoicesTab/VoicesTab.tsx
new file mode 100644
index 00000000..5a585c80
--- /dev/null
+++ b/app/src/components/VoicesTab/VoicesTab.tsx
@@ -0,0 +1,216 @@
+import { Edit, MoreHorizontal, Plus, Trash2 } from 'lucide-react';
+import { useMemo } from 'react';
+import { Button } from '@/components/ui/button';
+import {
+ DropdownMenu,
+ DropdownMenuContent,
+ DropdownMenuItem,
+ DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu';
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from '@/components/ui/table';
+import { useProfiles, useProfileSamples, useDeleteProfile } from '@/lib/hooks/useProfiles';
+import { useHistory } from '@/lib/hooks/useHistory';
+import { useUIStore } from '@/stores/uiStore';
+import { apiClient } from '@/lib/api/client';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+
+export function VoicesTab() {
+ const { data: profiles, isLoading } = useProfiles();
+ const { data: historyData } = useHistory({ limit: 1000 });
+ const queryClient = useQueryClient();
+ const setDialogOpen = useUIStore((state) => state.setProfileDialogOpen);
+ const setEditingProfileId = useUIStore((state) => state.setEditingProfileId);
+ const deleteProfile = useDeleteProfile();
+
+ // Get generation counts per profile
+ const generationCounts = useMemo(() => {
+ const counts: Record<string, number> = {};
+ if (historyData?.items) {
+ historyData.items.forEach((item) => {
+ counts[item.profile_id] = (counts[item.profile_id] || 0) + 1;
+ });
+ }
+ return counts;
+ }, [historyData]);
+
+ // Get channel assignments for each profile
+ const { data: channelAssignments } = useQuery({
+ queryKey: ['profile-channels'],
+ queryFn: async () => {
+ if (!profiles) return {};
+ const assignments: Record<string, string[]> = {};
+ for (const profile of profiles) {
+ try {
+ const result = await apiClient.getProfileChannels(profile.id);
+ assignments[profile.id] = result.channel_ids;
+ } catch {
+ assignments[profile.id] = [];
+ }
+ }
+ return assignments;
+ },
+ enabled: !!profiles,
+ });
+
+ // Get all channels
+ const { data: channels } = useQuery({
+ queryKey: ['channels'],
+ queryFn: () => apiClient.listChannels(),
+ });
+
+ const handleEdit = (profileId: string) => {
+ setEditingProfileId(profileId);
+ setDialogOpen(true);
+ };
+
+ const handleDelete = (profileId: string) => {
+ if (confirm('Are you sure you want to delete this profile?')) {
+ deleteProfile.mutate(profileId);
+ }
+ };
+
+ const handleChannelChange = async (profileId: string, channelIds: string[]) => {
+ try {
+ await apiClient.setProfileChannels(profileId, channelIds);
+ queryClient.invalidateQueries({ queryKey: ['profile-channels'] });
+ } catch (error) {
+ console.error('Failed to update channels:', error);
+ }
+ };
+
+ if (isLoading) {
+ return (
+ <div className="flex items-center justify-center h-full">
+ <div className="text-muted-foreground">Loading voices...</div>
+ </div>
+ );
+ }
+
+ return (
+ <div className="h-full flex flex-col">
+ <div className="flex items-center justify-between mb-6">
+ <h1 className="text-2xl font-bold">Voices</h1>
+ <Button onClick={() => setDialogOpen(true)}>
+ <Plus className="h-4 w-4 mr-2" />
+ New Voice
+ </Button>
+ </div>
+
+ <div className="flex-1 overflow-auto">
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead>Name</TableHead>
+ <TableHead>Language</TableHead>
+ <TableHead>Generations</TableHead>
+ <TableHead>Samples</TableHead>
+ <TableHead>Channels</TableHead>
+ <TableHead className="w-[50px]"></TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {profiles?.map((profile) => (
+ <VoiceRow
+ key={profile.id}
+ profile={profile}
+ generationCount={generationCounts[profile.id] || 0}
+ channelIds={channelAssignments?.[profile.id] || []}
+ channels={channels || []}
+ onChannelChange={(channelIds) => handleChannelChange(profile.id, channelIds)}
+ onEdit={() => handleEdit(profile.id)}
+ onDelete={() => handleDelete(profile.id)}
+ />
+ ))}
+ </TableBody>
+ </Table>
+ </div>
+ </div>
+ );
+}
+
+interface VoiceRowProps {
+ profile: {
+ id: string;
+ name: string;
+ description: string | null;
+ language: string;
+ };
+ generationCount: number;
+ channelIds: string[];
+ channels: Array<{ id: string; name: string; is_default: boolean }>;
+ onChannelChange: (channelIds: string[]) => void;
+ onEdit: () => void;
+ onDelete: () => void;
+}
+
+function VoiceRow({
+ profile,
+ generationCount,
+ channelIds,
+ channels,
+ onChannelChange,
+ onEdit,
+ onDelete,
+}: VoiceRowProps) {
+ const { data: samples } = useProfileSamples(profile.id);
+
+ return (
+ <TableRow>
+ <TableCell>
+ <div>
+ <div className="font-medium">{profile.name}</div>
+ {profile.description && (
+ <div className="text-sm text-muted-foreground">{profile.description}</div>
+ )}
+ </div>
+ </TableCell>
+ <TableCell>{profile.language}</TableCell>
+ <TableCell>{generationCount}</TableCell>
+ <TableCell>{samples?.length || 0}</TableCell>
+ <TableCell>
+ <select
+ multiple
+ value={channelIds}
+ onChange={(e) => {
+ const selected = Array.from(e.target.selectedOptions, (opt) => opt.value);
+ onChannelChange(selected);
+ }}
+ className="w-full min-w-[200px] border rounded px-2 py-1 text-sm"
+ size={Math.min(channels.length + 1, 5)}
+ >
+ {channels.map((ch) => (
+ <option key={ch.id} value={ch.id}>
+ {ch.name} {ch.is_default && '(Default)'}
+ </option>
+ ))}
+ </select>
+ </TableCell>
+ <TableCell>
+ <DropdownMenu>
+ <DropdownMenuTrigger asChild>
+ <Button variant="ghost" size="icon">
+ <MoreHorizontal className="h-4 w-4" />
+ </Button>
+ </DropdownMenuTrigger>
+ <DropdownMenuContent>
+ <DropdownMenuItem onClick={onEdit}>
+ <Edit className="h-4 w-4 mr-2" />
+ Edit
+ </DropdownMenuItem>
+ <DropdownMenuItem onClick={onDelete} className="text-destructive">
+ <Trash2 className="h-4 w-4 mr-2" />
+ Delete
+ </DropdownMenuItem>
+ </DropdownMenuContent>
+ </DropdownMenu>
+ </TableCell>
+ </TableRow>
+ );
+}
diff --git a/app/src/lib/api/client.ts b/app/src/lib/api/client.ts
index 506f573c..bc654932 100644
--- a/app/src/lib/api/client.ts
+++ b/app/src/lib/api/client.ts
@@ -279,6 +279,88 @@ class ApiClient {
async getActiveTasks(): Promise<ActiveTasksResponse> {
return this.request<ActiveTasksResponse>('/tasks/active');
}
+
+ // Audio Channels
+ async listChannels(): Promise<
+ Array<{
+ id: string;
+ name: string;
+ is_default: boolean;
+ device_ids: string[];
+ created_at: string;
+ }>
+ > {
+ return this.request('/channels');
+ }
+
+ async createChannel(data: {
+ name: string;
+ device_ids: string[];
+ }): Promise<{
+ id: string;
+ name: string;
+ is_default: boolean;
+ device_ids: string[];
+ created_at: string;
+ }> {
+ return this.request('/channels', {
+ method: 'POST',
+ body: JSON.stringify(data),
+ });
+ }
+
+ async updateChannel(
+ channelId: string,
+ data: {
+ name?: string;
+ device_ids?: string[];
+ },
+ ): Promise<{
+ id: string;
+ name: string;
+ is_default: boolean;
+ device_ids: string[];
+ created_at: string;
+ }> {
+ return this.request(`/channels/${channelId}`, {
+ method: 'PUT',
+ body: JSON.stringify(data),
+ });
+ }
+
+ async deleteChannel(channelId: string): Promise<{ message: string }> {
+ return this.request(`/channels/${channelId}`, {
+ method: 'DELETE',
+ });
+ }
+
+ async getChannelVoices(channelId: string): Promise<{ profile_ids: string[] }> {
+ return this.request(`/channels/${channelId}/voices`);
+ }
+
+ async setChannelVoices(
+ channelId: string,
+ profileIds: string[],
+ ): Promise<{ message: string }> {
+ return this.request(`/channels/${channelId}/voices`, {
+ method: 'PUT',
+ body: JSON.stringify({ profile_ids: profileIds }),
+ });
+ }
+
+ async getProfileChannels(profileId: string): Promise<{ channel_ids: string[] }> {
+ return this.request(`/profiles/${profileId}/channels`);
+ }
+
+ async setProfileChannels(
+ profileId: string,
+ channelIds: string[],
+ ): Promise<{ message: string }> {
+ return this.request(`/profiles/${profileId}/channels`, {
+ method: 'PUT',
+ body: JSON.stringify({ channel_ids: channelIds }),
+ });
+ }
}
export const apiClient = new ApiClient();
diff --git a/app/src/stores/audioChannelStore.ts b/app/src/stores/audioChannelStore.ts
new file mode 100644
index 00000000..f8e126ed
--- /dev/null
+++ b/app/src/stores/audioChannelStore.ts
@@ -0,0 +1,44 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+export interface AudioChannel {
+ id: string;
+ name: string;
+ is_default: boolean;
+ device_ids: string[];
+ created_at: string;
+}
+
+interface AudioChannelStore {
+ channels: AudioChannel[];
+ setChannels: (channels: AudioChannel[]) => void;
+ addChannel: (channel: AudioChannel) => void;
+ updateChannel: (id: string, channel: Partial<AudioChannel>) => void;
+ removeChannel: (id: string) => void;
+}
+
+export const useAudioChannelStore = create<AudioChannelStore>()(
+ persist(
+ (set) => ({
+ channels: [],
+ setChannels: (channels) => set({ channels }),
+ addChannel: (channel) =>
+ set((state) => ({
+ channels: [...state.channels, channel],
+ })),
+ updateChannel: (id, updates) =>
+ set((state) => ({
+ channels: state.channels.map((ch) =>
+ ch.id === id ? { ...ch, ...updates } : ch,
+ ),
+ })),
+ removeChannel: (id) =>
+ set((state) => ({
+ channels: state.channels.filter((ch) => ch.id !== id),
+ })),
+ }),
+ {
+ name: 'voicebox-audio-channels',
+ },
+ ),
+);
diff --git a/app/src/stores/playerStore.ts b/app/src/stores/playerStore.ts
index 006e0d85..d6b984a9 100644
--- a/app/src/stores/playerStore.ts
+++ b/app/src/stores/playerStore.ts
@@ -3,6 +3,7 @@ import { create } from 'zustand';
interface PlayerState {
audioUrl: string | null;
audioId: string | null;
+ profileId: string | null;
title: string | null;
isPlaying: boolean;
currentTime: number;
@@ -11,7 +12,7 @@ interface PlayerState {
isLooping: boolean;
shouldRestart: boolean;
- setAudio: (url: string, id: string, title?: string) => void;
+ setAudio: (url: string, id: string, profileId: string | null, title?: string) => void;
setIsPlaying: (playing: boolean) => void;
setCurrentTime: (time: number) => void;
setDuration: (duration: number) => void;
@@ -25,6 +26,7 @@ interface PlayerState {
export const usePlayerStore = create<PlayerState>((set) => ({
audioUrl: null,
audioId: null,
+ profileId: null,
title: null,
isPlaying: false,
currentTime: 0,
@@ -33,10 +35,11 @@ export const usePlayerStore = create<PlayerState>((set) => ({
isLooping: false,
shouldRestart: false,
- setAudio: (url, id, title) =>
+ setAudio: (url, id, profileId, title) =>
set({
audioUrl: url,
audioId: id,
+ profileId: profileId || null,
title: title || null,
currentTime: 0,
isPlaying: false,
@@ -53,6 +56,7 @@ export const usePlayerStore = create<PlayerState>((set) => ({
set({
audioUrl: null,
audioId: null,
+ profileId: null,
title: null,
isPlaying: false,
currentTime: 0,
diff --git a/backend/channels.py b/backend/channels.py
new file mode 100644
index 00000000..146c003d
--- /dev/null
+++ b/backend/channels.py
@@ -0,0 +1,263 @@
+"""
+Audio channel management module.
+"""
+
+from typing import List, Optional
+from datetime import datetime
+import uuid
+from sqlalchemy.orm import Session
+
+from .models import (
+ AudioChannelCreate,
+ AudioChannelUpdate,
+ AudioChannelResponse,
+ ChannelVoiceAssignment,
+ ProfileChannelAssignment,
+)
+from .database import (
+ AudioChannel as DBAudioChannel,
+ ChannelDeviceMapping as DBChannelDeviceMapping,
+ ProfileChannelMapping as DBProfileChannelMapping,
+ VoiceProfile as DBVoiceProfile,
+)
+
+
+async def list_channels(db: Session) -> List[AudioChannelResponse]:
+ """List all audio channels."""
+ channels = db.query(DBAudioChannel).all()
+ result = []
+
+ for channel in channels:
+ # Get device IDs for this channel
+ device_mappings = db.query(DBChannelDeviceMapping).filter_by(
+ channel_id=channel.id
+ ).all()
+ device_ids = [m.device_id for m in device_mappings]
+
+ result.append(AudioChannelResponse(
+ id=channel.id,
+ name=channel.name,
+ is_default=channel.is_default,
+ device_ids=device_ids,
+ created_at=channel.created_at,
+ ))
+
+ return result
+
+
+async def get_channel(channel_id: str, db: Session) -> Optional[AudioChannelResponse]:
+ """Get a channel by ID."""
+ channel = db.query(DBAudioChannel).filter_by(id=channel_id).first()
+ if not channel:
+ return None
+
+ # Get device IDs
+ device_mappings = db.query(DBChannelDeviceMapping).filter_by(
+ channel_id=channel.id
+ ).all()
+ device_ids = [m.device_id for m in device_mappings]
+
+ return AudioChannelResponse(
+ id=channel.id,
+ name=channel.name,
+ is_default=channel.is_default,
+ device_ids=device_ids,
+ created_at=channel.created_at,
+ )
+
+
+async def create_channel(
+ data: AudioChannelCreate,
+ db: Session,
+) -> AudioChannelResponse:
+ """Create a new audio channel."""
+ # Check if name already exists
+ existing = db.query(DBAudioChannel).filter_by(name=data.name).first()
+ if existing:
+ raise ValueError(f"Channel with name '{data.name}' already exists")
+
+ # Create channel
+ channel = DBAudioChannel(
+ id=str(uuid.uuid4()),
+ name=data.name,
+ is_default=False,
+ created_at=datetime.utcnow(),
+ )
+ db.add(channel)
+ db.flush()
+
+ # Add device mappings
+ for device_id in data.device_ids:
+ mapping = DBChannelDeviceMapping(
+ id=str(uuid.uuid4()),
+ channel_id=channel.id,
+ device_id=device_id,
+ )
+ db.add(mapping)
+
+ db.commit()
+ db.refresh(channel)
+
+ return AudioChannelResponse(
+ id=channel.id,
+ name=channel.name,
+ is_default=channel.is_default,
+ device_ids=data.device_ids,
+ created_at=channel.created_at,
+ )
+
+
+async def update_channel(
+ channel_id: str,
+ data: AudioChannelUpdate,
+ db: Session,
+) -> Optional[AudioChannelResponse]:
+ """Update an audio channel."""
+ channel = db.query(DBAudioChannel).filter_by(id=channel_id).first()
+ if not channel:
+ return None
+
+ if channel.is_default:
+ raise ValueError("Cannot modify the default channel")
+
+ # Update name if provided
+ if data.name is not None:
+ # Check if name already exists (excluding current channel)
+ existing = db.query(DBAudioChannel).filter(
+ DBAudioChannel.name == data.name,
+ DBAudioChannel.id != channel_id
+ ).first()
+ if existing:
+ raise ValueError(f"Channel with name '{data.name}' already exists")
+ channel.name = data.name
+
+ # Update device mappings if provided
+ if data.device_ids is not None:
+ # Delete existing mappings
+ db.query(DBChannelDeviceMapping).filter_by(channel_id=channel_id).delete()
+
+ # Add new mappings
+ for device_id in data.device_ids:
+ mapping = DBChannelDeviceMapping(
+ id=str(uuid.uuid4()),
+ channel_id=channel.id,
+ device_id=device_id,
+ )
+ db.add(mapping)
+
+ db.commit()
+ db.refresh(channel)
+
+ # Get updated device IDs
+ device_mappings = db.query(DBChannelDeviceMapping).filter_by(
+ channel_id=channel.id
+ ).all()
+ device_ids = [m.device_id for m in device_mappings]
+
+ return AudioChannelResponse(
+ id=channel.id,
+ name=channel.name,
+ is_default=channel.is_default,
+ device_ids=device_ids,
+ created_at=channel.created_at,
+ )
+
+
+async def delete_channel(channel_id: str, db: Session) -> bool:
+ """Delete an audio channel."""
+ channel = db.query(DBAudioChannel).filter_by(id=channel_id).first()
+ if not channel:
+ return False
+
+ if channel.is_default:
+ raise ValueError("Cannot delete the default channel")
+
+ # Delete device mappings
+ db.query(DBChannelDeviceMapping).filter_by(channel_id=channel_id).delete()
+
+ # Delete profile-channel mappings
+ db.query(DBProfileChannelMapping).filter_by(channel_id=channel_id).delete()
+
+ # Delete channel
+ db.delete(channel)
+ db.commit()
+
+ return True
+
+
+async def get_channel_voices(channel_id: str, db: Session) -> List[str]:
+ """Get list of profile IDs assigned to a channel."""
+ mappings = db.query(DBProfileChannelMapping).filter_by(
+ channel_id=channel_id
+ ).all()
+ return [m.profile_id for m in mappings]
+
+
+async def set_channel_voices(
+ channel_id: str,
+ data: ChannelVoiceAssignment,
+ db: Session,
+) -> None:
+ """Set which voices are assigned to a channel."""
+ # Verify channel exists
+ channel = db.query(DBAudioChannel).filter_by(id=channel_id).first()
+ if not channel:
+ raise ValueError(f"Channel {channel_id} not found")
+
+ # Verify all profiles exist
+ for profile_id in data.profile_ids:
+ profile = db.query(DBVoiceProfile).filter_by(id=profile_id).first()
+ if not profile:
+ raise ValueError(f"Profile {profile_id} not found")
+
+ # Delete existing mappings for this channel
+ db.query(DBProfileChannelMapping).filter_by(channel_id=channel_id).delete()
+
+ # Add new mappings
+ for profile_id in data.profile_ids:
+ mapping = DBProfileChannelMapping(
+ profile_id=profile_id,
+ channel_id=channel_id,
+ )
+ db.add(mapping)
+
+ db.commit()
+
+
+async def get_profile_channels(profile_id: str, db: Session) -> List[str]:
+ """Get list of channel IDs assigned to a profile."""
+ mappings = db.query(DBProfileChannelMapping).filter_by(
+ profile_id=profile_id
+ ).all()
+ return [m.channel_id for m in mappings]
+
+
+async def set_profile_channels(
+ profile_id: str,
+ data: ProfileChannelAssignment,
+ db: Session,
+) -> None:
+ """Set which channels a profile is assigned to."""
+ # Verify profile exists
+ profile = db.query(DBVoiceProfile).filter_by(id=profile_id).first()
+ if not profile:
+ raise ValueError(f"Profile {profile_id} not found")
+
+ # Verify all channels exist
+ for channel_id in data.channel_ids:
+ channel = db.query(DBAudioChannel).filter_by(id=channel_id).first()
+ if not channel:
+ raise ValueError(f"Channel {channel_id} not found")
+
+ # Delete existing mappings for this profile
+ db.query(DBProfileChannelMapping).filter_by(profile_id=profile_id).delete()
+
+ # Add new mappings
+ for channel_id in data.channel_ids:
+ mapping = DBProfileChannelMapping(
+ profile_id=profile_id,
+ channel_id=channel_id,
+ )
+ db.add(mapping)
+
+ db.commit()
diff --git a/backend/database.py b/backend/database.py
index 302ac5e4..1e48d86c 100644
--- a/backend/database.py
+++ b/backend/database.py
@@ -2,7 +2,7 @@
SQLite database ORM using SQLAlchemy.
"""
-from sqlalchemy import create_engine, Column, String, Integer, Float, DateTime, Text, ForeignKey
+from sqlalchemy import create_engine, Column, String, Integer, Float, DateTime, Text, ForeignKey, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from datetime import datetime
@@ -62,6 +62,33 @@ class Project(Base):
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+class AudioChannel(Base):
+ """Audio channel (bus) database model."""
+ __tablename__ = "audio_channels"
+
+ id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+ name = Column(String, nullable=False)
+ is_default = Column(Boolean, default=False)
+ created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class ChannelDeviceMapping(Base):
+ """Mapping between channels and OS audio devices."""
+ __tablename__ = "channel_device_mappings"
+
+ id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+ channel_id = Column(String, ForeignKey("audio_channels.id"), nullable=False)
+ device_id = Column(String, nullable=False) # OS device identifier
+
+
+class ProfileChannelMapping(Base):
+ """Mapping between voice profiles and audio channels (many-to-many)."""
+ __tablename__ = "profile_channel_mappings"
+
+ profile_id = Column(String, ForeignKey("profiles.id"), primary_key=True)
+ channel_id = Column(String, ForeignKey("audio_channels.id"), primary_key=True)
+
+
# Database setup will be initialized in init_db()
engine = None
SessionLocal = None
@@ -82,6 +109,31 @@ def init_db():
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base.metadata.create_all(bind=engine)
+
+ # Create default channel if it doesn't exist
+ db = SessionLocal()
+ try:
+ default_channel = db.query(AudioChannel).filter(AudioChannel.is_default == True).first()
+ if not default_channel:
+ default_channel = AudioChannel(
+ id=str(uuid.uuid4()),
+ name="Default",
+ is_default=True
+ )
+ db.add(default_channel)
+
+ # Assign all existing profiles to default channel
+ profiles = db.query(VoiceProfile).all()
+ for profile in profiles:
+ mapping = ProfileChannelMapping(
+ profile_id=profile.id,
+ channel_id=default_channel.id
+ )
+ db.add(mapping)
+
+ db.commit()
+ finally:
+ db.close()
def get_db():
diff --git a/backend/main.py b/backend/main.py
index cfd36a61..90008edd 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -19,7 +19,7 @@ import io
from pathlib import Path
import uuid
-from . import database, models, profiles, history, tts, transcribe, config, export_import
+from . import database, models, profiles, history, tts, transcribe, config, export_import, channels
from .database import get_db, Generation as DBGeneration, VoiceProfile as DBVoiceProfile
from .utils.progress import get_progress_manager
from .utils.tasks import get_task_manager
@@ -292,6 +292,125 @@ async def export_profile(
raise HTTPException(status_code=500, detail=str(e))
+# ============================================
+# AUDIO CHANNEL ENDPOINTS
+# ============================================
+
[email protected]("/channels", response_model=List[models.AudioChannelResponse])
+async def list_channels(db: Session = Depends(get_db)):
+ """List all audio channels."""
+ return await channels.list_channels(db)
+
+
[email protected]("/channels", response_model=models.AudioChannelResponse)
+async def create_channel(
+ data: models.AudioChannelCreate,
+ db: Session = Depends(get_db),
+):
+ """Create a new audio channel."""
+ try:
+ return await channels.create_channel(data, db)
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
[email protected]("/channels/{channel_id}", response_model=models.AudioChannelResponse)
+async def get_channel(
+ channel_id: str,
+ db: Session = Depends(get_db),
+):
+ """Get an audio channel by ID."""
+ channel = await channels.get_channel(channel_id, db)
+ if not channel:
+ raise HTTPException(status_code=404, detail="Channel not found")
+ return channel
+
+
[email protected]("/channels/{channel_id}", response_model=models.AudioChannelResponse)
+async def update_channel(
+ channel_id: str,
+ data: models.AudioChannelUpdate,
+ db: Session = Depends(get_db),
+):
+ """Update an audio channel."""
+ try:
+ channel = await channels.update_channel(channel_id, data, db)
+ if not channel:
+ raise HTTPException(status_code=404, detail="Channel not found")
+ return channel
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
[email protected]("/channels/{channel_id}")
+async def delete_channel(
+ channel_id: str,
+ db: Session = Depends(get_db),
+):
+ """Delete an audio channel."""
+ try:
+ success = await channels.delete_channel(channel_id, db)
+ if not success:
+ raise HTTPException(status_code=404, detail="Channel not found")
+ return {"message": "Channel deleted successfully"}
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
[email protected]("/channels/{channel_id}/voices")
+async def get_channel_voices(
+ channel_id: str,
+ db: Session = Depends(get_db),
+):
+ """Get list of profile IDs assigned to a channel."""
+ try:
+ profile_ids = await channels.get_channel_voices(channel_id, db)
+ return {"profile_ids": profile_ids}
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
[email protected]("/channels/{channel_id}/voices")
+async def set_channel_voices(
+ channel_id: str,
+ data: models.ChannelVoiceAssignment,
+ db: Session = Depends(get_db),
+):
+ """Set which voices are assigned to a channel."""
+ try:
+ await channels.set_channel_voices(channel_id, data, db)
+ return {"message": "Channel voices updated successfully"}
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
[email protected]("/profiles/{profile_id}/channels")
+async def get_profile_channels(
+ profile_id: str,
+ db: Session = Depends(get_db),
+):
+ """Get list of channel IDs assigned to a profile."""
+ try:
+ channel_ids = await channels.get_profile_channels(profile_id, db)
+ return {"channel_ids": channel_ids}
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
[email protected]("/profiles/{profile_id}/channels")
+async def set_profile_channels(
+ profile_id: str,
+ data: models.ProfileChannelAssignment,
+ db: Session = Depends(get_db),
+):
+ """Set which channels a profile is assigned to."""
+ try:
+ await channels.set_profile_channels(profile_id, data, db)
+ return {"message": "Profile channels updated successfully"}
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
# ============================================
# GENERATION ENDPOINTS
# ============================================
diff --git a/backend/models.py b/backend/models.py
index caeeebba..3c7af507 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -159,3 +159,37 @@ class ActiveTasksResponse(BaseModel):
"""Response model for active tasks."""
downloads: List[ActiveDownloadTask]
generations: List[ActiveGenerationTask]
+
+
+class AudioChannelCreate(BaseModel):
+ """Request model for creating an audio channel."""
+ name: str = Field(..., min_length=1, max_length=100)
+ device_ids: List[str] = Field(default_factory=list)
+
+
+class AudioChannelUpdate(BaseModel):
+ """Request model for updating an audio channel."""
+ name: Optional[str] = Field(None, min_length=1, max_length=100)
+ device_ids: Optional[List[str]] = None
+
+
+class AudioChannelResponse(BaseModel):
+ """Response model for audio channel."""
+ id: str
+ name: str
+ is_default: bool
+ device_ids: List[str]
+ created_at: datetime
+
+ class Config:
+ from_attributes = True
+
+
+class ChannelVoiceAssignment(BaseModel):
+ """Request model for assigning voices to a channel."""
+ profile_ids: List[str]
+
+
+class ProfileChannelAssignment(BaseModel):
+ """Request model for assigning channels to a profile."""
+ channel_ids: List[str]
diff --git a/tauri/src-tauri/Cargo.toml b/tauri/src-tauri/Cargo.toml
index cff60a87..343473b4 100644
--- a/tauri/src-tauri/Cargo.toml
+++ b/tauri/src-tauri/Cargo.toml
@@ -22,6 +22,8 @@ serde_json = "1.0"
tokio = { version = "1", features = ["full"] }
hound = "3.5"
base64 = "0.22"
+cpal = "0.15"
+symphonia = { version = "0.5", features = ["wav", "pcm"] }
[target.'cfg(target_os = "macos")'.dependencies]
screencapturekit = { version = "1", features = ["async"] }
diff --git a/tauri/src-tauri/src/audio_output.rs b/tauri/src-tauri/src/audio_output.rs
new file mode 100644
index 00000000..defa294f
--- /dev/null
+++ b/tauri/src-tauri/src/audio_output.rs
@@ -0,0 +1,357 @@
+use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use cpal::{Device, Host, SampleFormat, StreamConfig};
+use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct AudioOutputDevice {
+ pub id: String,
+ pub name: String,
+ pub is_default: bool,
+}
+
+pub struct AudioOutputState {
+ host: Host,
+}
+
+impl AudioOutputState {
+ pub fn new() -> Self {
+ Self {
+ host: cpal::default_host(),
+ }
+ }
+
+ pub fn list_output_devices(&self) -> Result<Vec<AudioOutputDevice>, String> {
+ let devices = self
+ .host
+ .output_devices()
+ .map_err(|e| format!("Failed to enumerate output devices: {}", e))?;
+
+ let default_device = self.host.default_output_device();
+
+ let mut result = Vec::new();
+ for device in devices {
+ let name = device
+ .name()
+ .map_err(|e| format!("Failed to get device name: {}", e))?;
+
+ // Generate a stable ID from the device name (cpal doesn't provide stable IDs)
+ let id = format!("device_{}", name.replace(' ', "_").to_lowercase());
+
+ let is_default = default_device
+ .as_ref()
+ .map(|d| d.name().unwrap_or_default() == name)
+ .unwrap_or(false);
+
+ result.push(AudioOutputDevice {
+ id,
+ name,
+ is_default,
+ });
+ }
+
+ Ok(result)
+ }
+
+ pub async fn play_audio_to_devices(
+ &self,
+ audio_data: Vec<u8>,
+ device_ids: Vec<String>,
+ ) -> Result<(), String> {
+ // Decode audio file (assuming WAV format)
+ let (samples, sample_rate, channels) = self.decode_wav(&audio_data)?;
+
+ // Find devices by ID
+ let devices: Vec<Device> = self
+ .host
+ .output_devices()
+ .map_err(|e| format!("Failed to enumerate devices: {}", e))?
+ .filter_map(|device| {
+ let name = device.name().ok()?;
+ let id = format!("device_{}", name.replace(' ', "_").to_lowercase());
+ if device_ids.contains(&id) {
+ Some(device)
+ } else {
+ None
+ }
+ })
+ .collect();
+
+ if devices.is_empty() {
+ return Err("No matching devices found".to_string());
+ }
+
+ // Play to each device
+ for device in devices {
+ self.play_to_device(&device, samples.clone(), sample_rate, channels)
+ .map_err(|e| format!("Failed to play to device: {}", e))?;
+ }
+
+ Ok(())
+ }
+
+ fn decode_wav(&self, data: &[u8]) -> Result<(Vec<f32>, u32, u16), String> {
+ use symphonia::core::formats::FormatOptions;
+ use symphonia::core::io::MediaSourceStream;
+ use symphonia::core::meta::MetadataOptions;
+ use symphonia::core::probe::Probe;
+
+ let mss = MediaSourceStream::new(
+ Box::new(std::io::Cursor::new(data)),
+ Default::default(),
+ );
+
+ let mut probe = Probe::default();
+ let mut format = probe
+ .format(
+ &Default::default(),
+ mss,
+ &FormatOptions::default(),
+ &MetadataOptions::default(),
+ )
+ .map_err(|e| format!("Failed to probe audio: {}", e))?
+ .format;
+
+ let track = format
+ .tracks()
+ .iter()
+ .find(|t| t.codec_params.codec != symphonia::core::codecs::CODEC_TYPE_NULL)
+ .ok_or("No audio track found")?;
+
+ let sample_rate = track
+ .codec_params
+ .sample_rate
+ .ok_or("No sample rate found")?;
+
+ let channels = track
+ .codec_params
+ .channels
+ .ok_or("No channels found")?
+ .count() as u16;
+
+ let mut decoder = symphonia::default::get_codecs()
+ .make(&track.codec_params, &Default::default())
+ .map_err(|e| format!("Failed to create decoder: {}", e))?;
+
+ let mut samples = Vec::new();
+ loop {
+ let packet = match format.next_packet() {
+ Ok(packet) => packet,
+ Err(_) => break, // End of stream
+ };
+
+ let decoded = decoder
+ .decode(&packet)
+ .map_err(|e| format!("Decode error: {}", e))?;
+
+ // Convert to f32 samples
+ let spec = *decoded.spec();
+ let duration = decoded.capacity() as u64;
+
+ // Handle multi-channel audio
+ if spec.channels.count() == 1 {
+ // Mono
+ let plane = decoded.plane(0);
+ for i in 0..duration {
+ if let Some(&sample) = plane.get(i as usize) {
+ samples.push(sample as f32 / 32768.0);
+ }
+ }
+ } else {
+ // Multi-channel - interleave
+ for i in 0..duration {
+ for ch in 0..spec.channels.count() {
+ if let Some(plane) = decoded.plane(ch) {
+ if let Some(&sample) = plane.get(i as usize) {
+ samples.push(sample as f32 / 32768.0);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ Ok((samples, sample_rate, channels))
+ }
+
+ fn play_to_device(
+ &self,
+ device: &Device,
+ samples: Vec<f32>,
+ sample_rate: u32,
+ channels: u16,
+ ) -> Result<(), String> {
+ let config = device
+ .default_output_config()
+ .map_err(|e| format!("Failed to get default config: {}", e))?;
+
+ // Prepare samples for the device's format
+ let device_sample_rate = config.sample_rate().0;
+ let device_channels = config.channels();
+
+ // Resample if needed (simple linear interpolation for now)
+ let resampled = if device_sample_rate != sample_rate {
+ self.resample(&samples, sample_rate, device_sample_rate)
+ } else {
+ samples
+ };
+
+ // Interleave/convert channels if needed
+ let interleaved = self.interleave_channels(&resampled, channels, device_channels);
+
+ // Create shared buffer for playback
+ let buffer: Arc<Mutex<Vec<f32>>> = Arc::new(Mutex::new(interleaved));
+ let position = Arc::new(AtomicUsize::new(0));
+ let buffer_clone = buffer.clone();
+ let position_clone = position.clone();
+
+ let err_fn = |err| eprintln!("Playback error: {}", err);
+
+ let stream_config = StreamConfig {
+ channels: device_channels,
+ sample_rate: cpal::SampleRate(device_sample_rate),
+ buffer_size: cpal::BufferSize::Default,
+ };
+
+ let stream = match config.sample_format() {
+ SampleFormat::F32 => {
+ let buffer = buffer_clone.clone();
+ let pos = position_clone.clone();
+ device
+ .build_output_stream(
+ &stream_config,
+ move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
+ let mut idx = pos.load(Ordering::Relaxed);
+ let buf = buffer.lock().unwrap();
+ for sample in data.iter_mut() {
+ if idx < buf.len() {
+ *sample = buf[idx];
+ idx += 1;
+ } else {
+ *sample = 0.0;
+ }
+ }
+ pos.store(idx, Ordering::Relaxed);
+ },
+ err_fn,
+ None,
+ )
+ .map_err(|e| format!("Failed to build stream: {}", e))?
+ }
+ SampleFormat::I16 => {
+ let buffer = buffer_clone.clone();
+ let pos = position_clone.clone();
+ device
+ .build_output_stream(
+ &stream_config,
+ move |data: &mut [i16], _: &cpal::OutputCallbackInfo| {
+ let mut idx = pos.load(Ordering::Relaxed);
+ let buf = buffer.lock().unwrap();
+ for sample in data.iter_mut() {
+ if idx < buf.len() {
+ *sample = (buf[idx] * 32767.0) as i16;
+ idx += 1;
+ } else {
+ *sample = 0;
+ }
+ }
+ pos.store(idx, Ordering::Relaxed);
+ },
+ err_fn,
+ None,
+ )
+ .map_err(|e| format!("Failed to build stream: {}", e))?
+ }
+ SampleFormat::U16 => {
+ let buffer = buffer_clone.clone();
+ let pos = position_clone.clone();
+ device
+ .build_output_stream(
+ &stream_config,
+ move |data: &mut [u16], _: &cpal::OutputCallbackInfo| {
+ let mut idx = pos.load(Ordering::Relaxed);
+ let buf = buffer.lock().unwrap();
+ for sample in data.iter_mut() {
+ if idx < buf.len() {
+ *sample = ((buf[idx] + 1.0) * 32767.5) as u16;
+ idx += 1;
+ } else {
+ *sample = 32768;
+ }
+ }
+ pos.store(idx, Ordering::Relaxed);
+ },
+ err_fn,
+ None,
+ )
+ .map_err(|e| format!("Failed to build stream: {}", e))?
+ }
+ _ => return Err("Unsupported sample format".to_string()),
+ };
+
+ stream.play().map_err(|e| format!("Failed to play stream: {}", e))?;
+
+ // Keep stream alive until playback completes
+ // In a real implementation, we'd track this and clean up when done
+ std::thread::spawn(move || {
+ std::thread::sleep(std::time::Duration::from_secs(30)); // Max 30s
+ });
+
+ Ok(())
+ }
+
+ fn resample(&self, samples: &[f32], from_rate: u32, to_rate: u32) -> Vec<f32> {
+ if from_rate == to_rate {
+ return samples.to_vec();
+ }
+
+ let ratio = to_rate as f64 / from_rate as f64;
+ let new_len = (samples.len() as f64 * ratio) as usize;
+ let mut resampled = Vec::with_capacity(new_len);
+
+ for i in 0..new_len {
+ let src_idx = (i as f64 / ratio) as usize;
+ if src_idx < samples.len() {
+ resampled.push(samples[src_idx]);
+ } else {
+ resampled.push(0.0);
+ }
+ }
+
+ resampled
+ }
+
+ fn interleave_channels(
+ &self,
+ samples: &[f32],
+ src_channels: u16,
+ dst_channels: u16,
+ ) -> Vec<f32> {
+ if src_channels == dst_channels {
+ return samples.to_vec();
+ }
+
+ let mut interleaved = Vec::new();
+ let samples_per_channel = samples.len() / src_channels as usize;
+
+ for i in 0..samples_per_channel {
+ for ch in 0..dst_channels {
+ let src_ch = if ch < src_channels { ch } else { src_channels - 1 };
+ let idx = (i * src_channels as usize) + src_ch as usize;
+ if idx < samples.len() {
+ interleaved.push(samples[idx]);
+ } else {
+ interleaved.push(0.0);
+ }
+ }
+ }
+
+ interleaved
+ }
+}
+
+impl Default for AudioOutputState {
+ fn default() -> Self {
+ Self::new()
+ }
+}
diff --git a/tauri/src-tauri/src/main.rs b/tauri/src-tauri/src/main.rs
index f44300c5..272aea06 100644
--- a/tauri/src-tauri/src/main.rs
+++ b/tauri/src-tauri/src/main.rs
@@ -2,6 +2,7 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
mod audio_capture;
+mod audio_output;
use std::sync::Mutex;
use tauri::{command, State, Manager, WindowEvent, Emitter, Listener, RunEvent};
@@ -368,6 +369,22 @@ fn is_system_audio_supported() -> bool {
audio_capture::is_supported()
}
+#[command]
+fn list_audio_output_devices(
+ state: State<'_, audio_output::AudioOutputState>,
+) -> Result<Vec<audio_output::AudioOutputDevice>, String> {
+ state.list_output_devices()
+}
+
+#[command]
+async fn play_audio_to_devices(
+ state: State<'_, audio_output::AudioOutputState>,
+ audio_data: Vec<u8>,
+ device_ids: Vec<String>,
+) -> Result<(), String> {
+ state.play_audio_to_devices(audio_data, device_ids).await
+}
+
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
tauri::Builder::default()
@@ -380,6 +397,7 @@ pub fn run() {
keep_running_on_close: Mutex::new(false),
})
.manage(audio_capture::AudioCaptureState::new())
+ .manage(audio_output::AudioOutputState::new())
.setup(|app| {
#[cfg(desktop)]
app.handle().plugin(tauri_plugin_updater::Builder::new().build())?;
@@ -420,7 +438,9 @@ pub fn run() {
set_keep_server_running,
start_system_audio_capture,
stop_system_audio_capture,
- is_system_audio_supported
+ is_system_audio_supported,
+ list_audio_output_devices,
+ play_audio_to_devices
])
.on_window_event(|window, event| {
if let WindowEvent::CloseRequested { api, .. } = event {