import React, { useCallback, useEffect, useRef, useState, MouseEventHandler } from 'react'; import { Box, Button, color, config, Header, IconButton, Menu, MenuItem, PopOut, RectCords, Scroll, Switch, Text, toRem, } from 'folds'; import FocusTrap from 'focus-trap-react'; import { Icon, Icons } from '../../../components/icons'; import { Page, PageContent, PageHeader } from '../../../components/page'; import { SequenceCard } from '../../../components/sequence-card'; import { SettingTile } from '../../../components/setting-tile'; import { SequenceCardStyle } from '../styles.css'; import { stopPropagation } from '../../../utils/keyboard'; import { useSetting } from '../../../state/hooks/settings'; import { settingsAtom } from '../../../state/settings'; /** Represents an audio device (microphone or speaker) */ interface AudioDevice { deviceId: string; label: string; kind: MediaDeviceKind; } /** Screen share resolution presets */ export type ScreenShareResolution = '720p' | '1080p' | '1440p' | '4k' | 'source'; /** Screen share resolution configs */ export const SCREEN_SHARE_RESOLUTIONS: Record< ScreenShareResolution, { width: number; height: number; label: string } > = { '720p': { width: 1280, height: 720, label: '720p (HD)' }, '1080p': { width: 1920, height: 1080, label: '1080p (Full HD)' }, '1440p': { width: 2560, height: 1440, label: '1440p (2K)' }, '4k': { width: 3840, height: 2160, label: '4K (Ultra HD)' }, source: { width: 0, height: 0, label: 'Source Resolution' }, }; /** Screen share bitrate presets in kbps */ export type ScreenShareBitrate = 'low' | 'medium' | 'high' | 'ultra'; /** Screen share bitrate configs */ export const SCREEN_SHARE_BITRATES: Record = { low: { bitrate: 1000, label: 'Low (1 Mbps)' }, medium: { bitrate: 2500, label: 'Medium (2.5 Mbps)' }, high: { bitrate: 5000, label: 'High (5 Mbps)' }, ultra: { bitrate: 10000, label: 'Ultra (10 Mbps)' }, }; /** Stored audio device settings */ interface AudioSettings { microphoneId: string | null; speakerId: string | null; noiseSuppression: boolean; echoCancellation: boolean; autoGainControl: boolean; screenShareResolution: ScreenShareResolution; screenShareBitrate: ScreenShareBitrate; screenShareFrameRate: number; } const AUDIO_SETTINGS_KEY = 'cinny_audio_settings'; /** Default audio settings */ const DEFAULT_AUDIO_SETTINGS: AudioSettings = { microphoneId: null, speakerId: null, noiseSuppression: true, echoCancellation: true, autoGainControl: true, screenShareResolution: '1080p', screenShareBitrate: 'high', screenShareFrameRate: 30, }; /** * Loads audio settings from localStorage * @returns The stored audio settings or defaults */ function loadAudioSettings(): AudioSettings { try { const stored = localStorage.getItem(AUDIO_SETTINGS_KEY); if (stored) { return { ...DEFAULT_AUDIO_SETTINGS, ...JSON.parse(stored) }; } } catch (e) { console.error('Failed to load audio settings:', e); } return DEFAULT_AUDIO_SETTINGS; } /** Dispatched on window after audio settings are persisted. */ export const AUDIO_SETTINGS_CHANGED_EVENT = 'paarrot-audio-settings-changed'; /** * Saves audio settings to localStorage * @param settings - The audio settings to save */ function saveAudioSettings(settings: AudioSettings): void { try { localStorage.setItem(AUDIO_SETTINGS_KEY, JSON.stringify(settings)); window.dispatchEvent(new CustomEvent(AUDIO_SETTINGS_CHANGED_EVENT)); } catch (e) { console.error('Failed to save audio settings:', e); } } /** * Gets the currently stored audio settings * @returns The stored audio settings */ export function getAudioSettings(): AudioSettings { return loadAudioSettings(); } /** * LiveKit / getUserMedia capture options from stored settings. * Always sets voiceIsolation explicitly — LiveKit 2.20 defaults it to true, * which overrides noiseSuppression when left unset. */ export function getAudioCaptureOptions(): { deviceId?: string; noiseSuppression: boolean; echoCancellation: boolean; autoGainControl: boolean; voiceIsolation: boolean; } { const settings = getAudioSettings(); return { deviceId: settings.microphoneId || undefined, noiseSuppression: settings.noiseSuppression, echoCancellation: settings.echoCancellation, autoGainControl: settings.autoGainControl, voiceIsolation: settings.noiseSuppression, }; } /** MediaTrackConstraints for getUserMedia / applyConstraints from UI settings. */ function getMicTrackConstraints(settings: AudioSettings): MediaTrackConstraints { return { ...(settings.microphoneId ? { deviceId: { exact: settings.microphoneId } } : {}), noiseSuppression: settings.noiseSuppression, echoCancellation: settings.echoCancellation, autoGainControl: settings.autoGainControl, // Experimental; Chromium / Electron. Keep in sync with noise suppression. voiceIsolation: settings.noiseSuppression, } as MediaTrackConstraints; } type DeviceSelectorProps = { devices: AudioDevice[]; selectedId: string | null; onSelect: (deviceId: string) => void; }; /** * Dropdown menu for selecting an audio device */ function DeviceSelector({ devices, selectedId, onSelect }: DeviceSelectorProps) { return ( {devices.length === 0 ? ( No devices found ) : ( devices.map((device) => ( onSelect(device.deviceId)} > {device.label || `Unknown Device (${device.deviceId.slice(0, 8)}...)`} )) )} ); } type DeviceSelectButtonProps = { devices: AudioDevice[]; selectedId: string | null; onSelect: (deviceId: string) => void; }; /** * Button that opens a device selection dropdown */ function DeviceSelectButton({ devices, selectedId, onSelect }: DeviceSelectButtonProps) { const [menuCords, setMenuCords] = useState(); const selectedDevice = devices.find((d) => d.deviceId === selectedId); const displayLabel = selectedDevice?.label || selectedDevice?.deviceId.slice(0, 8) || 'Default'; const handleClick: MouseEventHandler = (evt) => { setMenuCords(evt.currentTarget.getBoundingClientRect()); }; const handleSelect = (deviceId: string) => { onSelect(deviceId); setMenuCords(undefined); }; return ( <> setMenuCords(undefined), clickOutsideDeactivates: true, isKeyForward: (evt: KeyboardEvent) => evt.key === 'ArrowDown' || evt.key === 'ArrowRight', isKeyBackward: (evt: KeyboardEvent) => evt.key === 'ArrowUp' || evt.key === 'ArrowLeft', escapeDeactivates: stopPropagation, }} > } /> ); } type ScreenShareResolutionSelectProps = { value: ScreenShareResolution; onChange: (value: ScreenShareResolution) => void; }; /** * Dropdown for selecting screen share resolution */ function ScreenShareResolutionSelect({ value, onChange }: ScreenShareResolutionSelectProps) { const [menuCords, setMenuCords] = useState(); const handleClick: MouseEventHandler = (evt) => { setMenuCords(evt.currentTarget.getBoundingClientRect()); }; const handleSelect = (resolution: ScreenShareResolution) => { onChange(resolution); setMenuCords(undefined); }; return ( <> setMenuCords(undefined), clickOutsideDeactivates: true, escapeDeactivates: stopPropagation, }} > {(Object.keys(SCREEN_SHARE_RESOLUTIONS) as ScreenShareResolution[]).map((res) => ( handleSelect(res)} > {SCREEN_SHARE_RESOLUTIONS[res].label} ))} } /> ); } type ScreenShareBitrateSelectProps = { value: ScreenShareBitrate; onChange: (value: ScreenShareBitrate) => void; }; /** * Dropdown for selecting screen share bitrate */ function ScreenShareBitrateSelect({ value, onChange }: ScreenShareBitrateSelectProps) { const [menuCords, setMenuCords] = useState(); const handleClick: MouseEventHandler = (evt) => { setMenuCords(evt.currentTarget.getBoundingClientRect()); }; const handleSelect = (bitrate: ScreenShareBitrate) => { onChange(bitrate); setMenuCords(undefined); }; return ( <> setMenuCords(undefined), clickOutsideDeactivates: true, escapeDeactivates: stopPropagation, }} > {(Object.keys(SCREEN_SHARE_BITRATES) as ScreenShareBitrate[]).map((br) => ( handleSelect(br)} > {SCREEN_SHARE_BITRATES[br].label} ))} } /> ); } type ScreenShareFrameRateSelectProps = { value: number; onChange: (value: number) => void; }; const FRAME_RATES = [15, 24, 30, 60]; /** * Dropdown for selecting screen share frame rate */ function ScreenShareFrameRateSelect({ value, onChange }: ScreenShareFrameRateSelectProps) { const [menuCords, setMenuCords] = useState(); const handleClick: MouseEventHandler = (evt) => { setMenuCords(evt.currentTarget.getBoundingClientRect()); }; const handleSelect = (frameRate: number) => { onChange(frameRate); setMenuCords(undefined); }; return ( <> setMenuCords(undefined), clickOutsideDeactivates: true, escapeDeactivates: stopPropagation, }} > {FRAME_RATES.map((fr) => ( handleSelect(fr)} > {fr} FPS ))} } /> ); } type AudioProps = { requestClose: () => void; }; /** * Audio settings page component * Allows users to select microphone and speaker devices for calls */ export function Audio({ requestClose }: AudioProps) { const [microphones, setMicrophones] = useState([]); const [speakers, setSpeakers] = useState([]); const [settings, setSettings] = useState(loadAudioSettings); const [permissionStatus, setPermissionStatus] = useState<'granted' | 'denied' | 'prompt'>( 'prompt', ); const [micTestState, setMicTestState] = useState<'idle' | 'testing' | 'done' | 'error'>('idle'); const [micLevel, setMicLevel] = useState(0); const [speakerTestState, setSpeakerTestState] = useState<'idle' | 'testing' | 'done' | 'error'>( 'idle', ); const [micMonitoring, setMicMonitoring] = useState(false); const micAnimFrameRef = useRef(null); const micMonitorContextRef = useRef(null); const micMonitorStreamRef = useRef(null); const micMonitorGainRef = useRef(null); const [showRemoteCursor, setShowRemoteCursor] = useSetting(settingsAtom, 'showRemoteCursor'); useEffect(() => { const loadDevices = async () => { try { // Request permission to access media devices await navigator.mediaDevices.getUserMedia({ audio: true }); setPermissionStatus('granted'); const devices = await navigator.mediaDevices.enumerateDevices(); const mics = devices .filter((d) => d.kind === 'audioinput') .map((d) => ({ deviceId: d.deviceId, label: d.label, kind: d.kind, })); const spks = devices .filter((d) => d.kind === 'audiooutput') .map((d) => ({ deviceId: d.deviceId, label: d.label, kind: d.kind, })); setMicrophones(mics); setSpeakers(spks); // If no device is selected yet, use the first available if (!settings.microphoneId && mics.length > 0) { setSettings((prev) => ({ ...prev, microphoneId: mics[0].deviceId })); } if (!settings.speakerId && spks.length > 0) { setSettings((prev) => ({ ...prev, speakerId: spks[0].deviceId })); } } catch (e) { console.error('Failed to enumerate devices:', e); setPermissionStatus('denied'); } }; loadDevices(); // Listen for device changes const handleDeviceChange = () => { loadDevices(); }; navigator.mediaDevices.addEventListener('devicechange', handleDeviceChange); return () => { navigator.mediaDevices.removeEventListener('devicechange', handleDeviceChange); }; }, [settings.microphoneId, settings.speakerId]); const handleMicrophoneSelect = (deviceId: string) => { const newSettings = { ...settings, microphoneId: deviceId }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleSpeakerSelect = (deviceId: string) => { const newSettings = { ...settings, speakerId: deviceId }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleNoiseSuppressionChange = (enabled: boolean) => { const newSettings = { ...settings, noiseSuppression: enabled }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleEchoCancellationChange = (enabled: boolean) => { const newSettings = { ...settings, echoCancellation: enabled }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleAutoGainControlChange = (enabled: boolean) => { const newSettings = { ...settings, autoGainControl: enabled }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleScreenShareResolutionChange = (resolution: ScreenShareResolution) => { const newSettings = { ...settings, screenShareResolution: resolution }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleScreenShareBitrateChange = (bitrate: ScreenShareBitrate) => { const newSettings = { ...settings, screenShareBitrate: bitrate }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleScreenShareFrameRateChange = (frameRate: number) => { const newSettings = { ...settings, screenShareFrameRate: frameRate }; setSettings(newSettings); saveAudioSettings(newSettings); }; const handleTestMicrophone = useCallback(async () => { if (micTestState === 'testing') return; setMicTestState('testing'); setMicLevel(0); try { const stream = await navigator.mediaDevices.getUserMedia({ audio: settings.microphoneId ? { deviceId: { exact: settings.microphoneId } } : true, }); const audioContext = new AudioContext(); const analyser = audioContext.createAnalyser(); analyser.fftSize = 256; const dataArray = new Uint8Array(analyser.frequencyBinCount); const microphone = audioContext.createMediaStreamSource(stream); microphone.connect(analyser); const tick = () => { analyser.getByteFrequencyData(dataArray); const avg = dataArray.reduce((a, b) => a + b, 0) / dataArray.length; setMicLevel(Math.min(100, Math.round((avg / 255) * 100 * 3))); micAnimFrameRef.current = requestAnimationFrame(tick); }; micAnimFrameRef.current = requestAnimationFrame(tick); setTimeout(() => { if (micAnimFrameRef.current !== null) { cancelAnimationFrame(micAnimFrameRef.current); micAnimFrameRef.current = null; } stream.getTracks().forEach((track) => track.stop()); audioContext.close(); setMicLevel(0); setMicTestState('done'); setTimeout(() => setMicTestState('idle'), 2000); }, 3000); } catch (e) { console.error('Microphone test failed:', e); setMicTestState('error'); setTimeout(() => setMicTestState('idle'), 2000); } }, [micTestState, settings.microphoneId]); const handleTestSpeaker = useCallback(async () => { if (speakerTestState === 'testing') return; setSpeakerTestState('testing'); try { const audioContext = new AudioContext(); const oscillator = audioContext.createOscillator(); const gainNode = audioContext.createGain(); oscillator.connect(gainNode); gainNode.connect(audioContext.destination); oscillator.frequency.value = 440; gainNode.gain.setValueAtTime(0, audioContext.currentTime); gainNode.gain.linearRampToValueAtTime(0.15, audioContext.currentTime + 0.1); gainNode.gain.linearRampToValueAtTime(0, audioContext.currentTime + 1.0); oscillator.start(); oscillator.stop(audioContext.currentTime + 1.0); setTimeout(() => { audioContext.close(); setSpeakerTestState('done'); setTimeout(() => setSpeakerTestState('idle'), 2000); }, 1200); } catch (e) { console.error('Speaker test failed:', e); setSpeakerTestState('error'); setTimeout(() => setSpeakerTestState('idle'), 2000); } }, [speakerTestState]); const handleMicMonitoringToggle = useCallback(async () => { if (micMonitoring) { // Stop monitoring if (micAnimFrameRef.current !== null) { cancelAnimationFrame(micAnimFrameRef.current); micAnimFrameRef.current = null; } if (micMonitorStreamRef.current) { micMonitorStreamRef.current.getTracks().forEach((track) => track.stop()); micMonitorStreamRef.current = null; } if (micMonitorContextRef.current) { micMonitorContextRef.current.close(); micMonitorContextRef.current = null; } micMonitorGainRef.current = null; setMicLevel(0); setMicMonitoring(false); } else { // Start monitoring try { const stream = await navigator.mediaDevices.getUserMedia({ audio: getMicTrackConstraints(settings), }); const audioContext = new AudioContext(); const analyser = audioContext.createAnalyser(); analyser.fftSize = 256; const dataArray = new Uint8Array(analyser.frequencyBinCount); const microphone = audioContext.createMediaStreamSource(stream); const gainNode = audioContext.createGain(); // Connect microphone to analyser for level monitoring microphone.connect(analyser); // Connect microphone to speakers for playback microphone.connect(gainNode); gainNode.connect(audioContext.destination); gainNode.gain.value = 1.0; // Full volume playback micMonitorContextRef.current = audioContext; micMonitorStreamRef.current = stream; micMonitorGainRef.current = gainNode; const tick = () => { analyser.getByteFrequencyData(dataArray); const avg = dataArray.reduce((a, b) => a + b, 0) / dataArray.length; setMicLevel(Math.min(100, Math.round((avg / 255) * 100 * 3))); micAnimFrameRef.current = requestAnimationFrame(tick); }; micAnimFrameRef.current = requestAnimationFrame(tick); setMicMonitoring(true); } catch (e) { console.error('Microphone monitoring failed:', e); } } }, [ micMonitoring, settings.microphoneId, settings.noiseSuppression, settings.echoCancellation, settings.autoGainControl, ]); // Cleanup monitoring on unmount useEffect( () => () => { if (micAnimFrameRef.current !== null) { cancelAnimationFrame(micAnimFrameRef.current); } if (micMonitorStreamRef.current) { micMonitorStreamRef.current.getTracks().forEach((track) => track.stop()); } if (micMonitorContextRef.current) { micMonitorContextRef.current.close(); } }, [], ); // Apply processing toggles to the live monitor track without tearing it down. useEffect(() => { if (!micMonitoring) return; const track = micMonitorStreamRef.current?.getAudioTracks()[0]; if (!track) return; track .applyConstraints({ noiseSuppression: settings.noiseSuppression, echoCancellation: settings.echoCancellation, autoGainControl: settings.autoGainControl, voiceIsolation: settings.noiseSuppression, } as MediaTrackConstraints) .catch((e) => console.error('Failed to apply mic processing constraints:', e)); }, [ micMonitoring, settings.noiseSuppression, settings.echoCancellation, settings.autoGainControl, ]); let micVariant: 'Critical' | 'Success' | 'Secondary'; if (micTestState === 'error') { micVariant = 'Critical'; } else if (micTestState === 'done') { micVariant = 'Success'; } else { micVariant = 'Secondary'; } let micLabel = 'Test'; if (micTestState === 'testing') { micLabel = 'Testing...'; } else if (micTestState === 'done') { micLabel = 'Done ✓'; } else if (micTestState === 'error') { micLabel = 'Failed'; } let speakerVariant: 'Critical' | 'Success' | 'Secondary'; if (speakerTestState === 'error') { speakerVariant = 'Critical'; } else if (speakerTestState === 'done') { speakerVariant = 'Success'; } else { speakerVariant = 'Secondary'; } let speakerLabel = 'Test'; if (speakerTestState === 'testing') { speakerLabel = 'Playing...'; } else if (speakerTestState === 'done') { speakerLabel = 'Done ✓'; } else if (speakerTestState === 'error') { speakerLabel = 'Failed'; } return ( Audio & Video {permissionStatus === 'denied' && (
Permission Required
)}
Microphone
{(micTestState === 'testing' || micMonitoring) && ( )} } />
Speaker
} />
Audio Processing
} /> } /> } />
Screen Sharing
} /> } /> } /> } />
Tips
• If you don't see your devices, make sure they are connected and permissions are granted. • The "Test" button will help verify your devices are working correctly. • Changes are saved automatically and will apply to your next call.
); }