Code changes

app.py

@@ -1,96 +1,149 @@
 import gradio as gr
 import numpy as np
-import torch
-import torchaudio
-import threading
+import soundcard as sc
 import queue
+import torch
 import time
+import threading
 import os
 import urllib.request
+import torchaudio
 from scipy.spatial.distance import cosine
-from collections import deque
-import tempfile
-import librosa
+from RealtimeSTT import AudioToTextRecorder
+import json
 
-# Configuration parameters
-FINAL_TRANSCRIPTION_MODEL = "openai/whisper-small"
+# Simplified configuration parameters
+SILENCE_THRESHS = [0, 0.4]
+FINAL_TRANSCRIPTION_MODEL = "distil-large-v3"
+FINAL_BEAM_SIZE = 5
+REALTIME_TRANSCRIPTION_MODEL = "distil-small.en"
+REALTIME_BEAM_SIZE = 5
 TRANSCRIPTION_LANGUAGE = "en"
+SILERO_SENSITIVITY = 0.4
+WEBRTC_SENSITIVITY = 3
+MIN_LENGTH_OF_RECORDING = 0.7
+PRE_RECORDING_BUFFER_DURATION = 0.35
+
+# Speaker change detection parameters
 DEFAULT_CHANGE_THRESHOLD = 0.7
 EMBEDDING_HISTORY_SIZE = 5
 MIN_SEGMENT_DURATION = 1.0
 DEFAULT_MAX_SPEAKERS = 4
-ABSOLUTE_MAX_SPEAKERS = 6
+ABSOLUTE_MAX_SPEAKERS = 10
+
+# Global variables
+FAST_SENTENCE_END = True
+USE_MICROPHONE = False
 SAMPLE_RATE = 16000
+BUFFER_SIZE = 512
+CHANNELS = 1
 
-# Speaker colors for up to 6 speakers
+# Speaker colors
 SPEAKER_COLORS = [
-    "#FFD700",  # Gold
-    "#FF6B6B",  # Red
-    "#4ECDC4",  # Teal
-    "#45B7D1",  # Blue
-    "#96CEB4",  # Green
-    "#FFEAA7",  # Yellow
+    "#FFFF00",  # Yellow
+    "#FF0000",  # Red
+    "#00FF00",  # Green
+    "#00FFFF",  # Cyan
+    "#FF00FF",  # Magenta
+    "#0000FF",  # Blue
+    "#FF8000",  # Orange
+    "#00FF80",  # Spring Green
+    "#8000FF",  # Purple
+    "#FFFFFF",  # White
 ]
 
 SPEAKER_COLOR_NAMES = [
-    "Gold", "Red", "Teal", "Blue", "Green", "Yellow"
+    "Yellow", "Red", "Green", "Cyan", "Magenta", 
+    "Blue", "Orange", "Spring Green", "Purple", "White"
 ]
 
 
 class SpeechBrainEncoder:
-    """Simplified encoder for speaker embeddings using torch audio features"""
+    """ECAPA-TDNN encoder from SpeechBrain for speaker embeddings"""
     def __init__(self, device="cpu"):
         self.device = device
-        self.embedding_dim = 128
-        self.model_loaded = True
+        self.model = None
+        self.embedding_dim = 192
+        self.model_loaded = False
+        self.cache_dir = os.path.join(os.path.expanduser("~"), ".cache", "speechbrain")
+        os.makedirs(self.cache_dir, exist_ok=True)
+    
+    def _download_model(self):
+        """Download pre-trained SpeechBrain ECAPA-TDNN model if not present"""
+        model_url = "https://huggingface.co/speechbrain/spkrec-ecapa-voxceleb/resolve/main/embedding_model.ckpt"
+        model_path = os.path.join(self.cache_dir, "embedding_model.ckpt")
+        
+        if not os.path.exists(model_path):
+            print(f"Downloading ECAPA-TDNN model to {model_path}...")
+            urllib.request.urlretrieve(model_url, model_path)
         
+        return model_path
+    
     def load_model(self):
-        """Model loading simulation"""
-        return True
+        """Load the ECAPA-TDNN model"""
+        try:
+            from speechbrain.pretrained import EncoderClassifier
+            
+            model_path = self._download_model()
+            
+            self.model = EncoderClassifier.from_hparams(
+                source="speechbrain/spkrec-ecapa-voxceleb",
+                savedir=self.cache_dir,
+                run_opts={"device": self.device}
+            )
+            
+            self.model_loaded = True
+            return True
+        except Exception as e:
+            print(f"Error loading ECAPA-TDNN model: {e}")
+            return False
     
     def embed_utterance(self, audio, sr=16000):
-        """Extract simple spectral features as speaker embedding"""
+        """Extract speaker embedding from audio"""
+        if not self.model_loaded:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        
         try:
             if isinstance(audio, np.ndarray):
-                waveform = torch.tensor(audio, dtype=torch.float32)
+                waveform = torch.tensor(audio, dtype=torch.float32).unsqueeze(0)
             else:
-                waveform = audio
-                
-            if len(waveform.shape) == 1:
-                waveform = waveform.unsqueeze(0)
+                waveform = audio.unsqueeze(0)
             
-            # Resample if needed
             if sr != 16000:
                 waveform = torchaudio.functional.resample(waveform, orig_freq=sr, new_freq=16000)
             
-            # Extract MFCC features as a simple embedding
-            mfcc_transform = torchaudio.transforms.MFCC(
-                sample_rate=16000,
-                n_mfcc=13,
-                melkwargs={'n_mels': 40}
-            )
+            with torch.no_grad():
+                embedding = self.model.encode_batch(waveform)
+                
+            return embedding.squeeze().cpu().numpy()
+        except Exception as e:
+            print(f"Error extracting embedding: {e}")
+            return np.zeros(self.embedding_dim)
+
+
+class AudioProcessor:
+    """Processes audio data to extract speaker embeddings"""
+    def __init__(self, encoder):
+        self.encoder = encoder
+    
+    def extract_embedding(self, audio_int16):
+        try:
+            float_audio = audio_int16.astype(np.float32) / 32768.0
             
-            mfcc = mfcc_transform(waveform)
-            # Take mean across time dimension and flatten
-            embedding = mfcc.mean(dim=2).flatten()
+            if np.abs(float_audio).max() > 1.0:
+                float_audio = float_audio / np.abs(float_audio).max()
             
-            # Pad or truncate to fixed size
-            if len(embedding) > self.embedding_dim:
-                embedding = embedding[:self.embedding_dim]
-            elif len(embedding) < self.embedding_dim:
-                padding = torch.zeros(self.embedding_dim - len(embedding))
-                embedding = torch.cat([embedding, padding])
-                
-            return embedding.numpy()
+            embedding = self.encoder.embed_utterance(float_audio)
             
+            return embedding
         except Exception as e:
-            print(f"Error extracting embedding: {e}")
-            return np.random.randn(self.embedding_dim)
+            print(f"Embedding extraction error: {e}")
+            return np.zeros(self.encoder.embedding_dim)
 
 
 class SpeakerChangeDetector:
-    """Speaker change detector for real-time diarization"""
-    def __init__(self, embedding_dim=128, change_threshold=DEFAULT_CHANGE_THRESHOLD, max_speakers=DEFAULT_MAX_SPEAKERS):
+    """Speaker change detector that supports a configurable number of speakers"""
+    def __init__(self, embedding_dim=192, change_threshold=DEFAULT_CHANGE_THRESHOLD, max_speakers=DEFAULT_MAX_SPEAKERS):
         self.embedding_dim = embedding_dim
         self.change_threshold = change_threshold
         self.max_speakers = min(max_speakers, ABSOLUTE_MAX_SPEAKERS)
@@ -110,6 +163,7 @@ class SpeakerChangeDetector:
             for speaker_id in list(self.active_speakers):
                 if speaker_id >= new_max:
                     self.active_speakers.discard(speaker_id)
+            
             if self.current_speaker >= new_max:
                 self.current_speaker = 0
         
@@ -161,6 +215,7 @@ class SpeakerChangeDetector:
                     
                     if speaker_mean is not None:
                         speaker_similarity = 1.0 - cosine(embedding, speaker_mean)
+                        
                         if speaker_similarity > best_similarity:
                             best_similarity = speaker_similarity
                             best_speaker = speaker_id
@@ -201,317 +256,481 @@ class SpeakerChangeDetector:
         if 0 <= speaker_id < len(SPEAKER_COLORS):
             return SPEAKER_COLORS[speaker_id]
         return "#FFFFFF"
+    
+    def get_status_info(self):
+        """Return status information about the speaker change detector"""
+        speaker_counts = [len(self.speaker_embeddings[i]) for i in range(self.max_speakers)]
+        
+        return {
+            "current_speaker": self.current_speaker,
+            "speaker_counts": speaker_counts,
+            "active_speakers": len(self.active_speakers),
+            "max_speakers": self.max_speakers,
+            "last_similarity": self.last_similarity,
+            "threshold": self.change_threshold
+        }
 
 
-class RealTimeASRDiarization:
-    """Main class for real-time ASR with speaker diarization"""
+class RealtimeSpeakerDiarization:
     def __init__(self):
-        self.encoder = SpeechBrainEncoder()
-        self.encoder.load_model()
-        self.speaker_detector = SpeakerChangeDetector()
-        self.transcription_queue = queue.Queue()
-        self.conversation_history = []
-        self.is_processing = False
-        
-        # Load Whisper model
+        self.encoder = None
+        self.audio_processor = None
+        self.speaker_detector = None
+        self.recorder = None
+        self.recording_thread = None
+        self.sentence_queue = queue.Queue()
+        self.full_sentences = []
+        self.sentence_speakers = []
+        self.pending_sentences = []
+        self.displayed_text = ""
+        self.last_realtime_text = ""
+        self.is_running = False
+        self.change_threshold = DEFAULT_CHANGE_THRESHOLD
+        self.max_speakers = DEFAULT_MAX_SPEAKERS
+        
+    def initialize_models(self):
+        """Initialize the speaker encoder model"""
         try:
-            import whisper
-            self.whisper_model = whisper.load_model("base")
-        except ImportError:
-            print("Whisper not available, using mock transcription")
-            self.whisper_model = None
+            device_str = "cuda" if torch.cuda.is_available() else "cpu"
+            print(f"Using device: {device_str}")
+            
+            self.encoder = SpeechBrainEncoder(device=device_str)
+            success = self.encoder.load_model()
+            
+            if success:
+                self.audio_processor = AudioProcessor(self.encoder)
+                self.speaker_detector = SpeakerChangeDetector(
+                    embedding_dim=self.encoder.embedding_dim,
+                    change_threshold=self.change_threshold,
+                    max_speakers=self.max_speakers
+                )
+                print("ECAPA-TDNN model loaded successfully!")
+                return True
+            else:
+                print("Failed to load ECAPA-TDNN model")
+                return False
+        except Exception as e:
+            print(f"Model initialization error: {e}")
+            return False
+    
+    def live_text_detected(self, text):
+        """Callback for real-time transcription updates"""
+        text = text.strip()
+        if text:
+            sentence_delimiters = '.?!。'
+            prob_sentence_end = (
+                len(self.last_realtime_text) > 0
+                and text[-1] in sentence_delimiters
+                and self.last_realtime_text[-1] in sentence_delimiters
+            )
+
+            self.last_realtime_text = text
+
+            if prob_sentence_end and FAST_SENTENCE_END:
+                self.recorder.stop()
+            elif prob_sentence_end:
+                self.recorder.post_speech_silence_duration = SILENCE_THRESHS[0]
+            else:
+                self.recorder.post_speech_silence_duration = SILENCE_THRESHS[1]
+    
+    def process_final_text(self, text):
+        """Process final transcribed text with speaker embedding"""
+        text = text.strip()
+        if text:
+            try:
+                bytes_data = self.recorder.last_transcription_bytes
+                self.sentence_queue.put((text, bytes_data))
+                self.pending_sentences.append(text)
+            except Exception as e:
+                print(f"Error processing final text: {e}")
     
-    def transcribe_audio(self, audio_data, sr=16000):
-        """Transcribe audio using Whisper"""
+    def process_sentence_queue(self):
+        """Process sentences in the queue for speaker detection"""
+        while self.is_running:
+            try:
+                text, bytes_data = self.sentence_queue.get(timeout=1)
+                
+                # Convert audio data to int16
+                audio_int16 = np.int16(bytes_data * 32767)
+                
+                # Extract speaker embedding
+                speaker_embedding = self.audio_processor.extract_embedding(audio_int16)
+                
+                # Store sentence and embedding
+                self.full_sentences.append((text, speaker_embedding))
+                
+                # Fill in missing speaker assignments
+                while len(self.sentence_speakers) < len(self.full_sentences) - 1:
+                    self.sentence_speakers.append(0)
+                
+                # Detect speaker changes
+                speaker_id, similarity = self.speaker_detector.add_embedding(speaker_embedding)
+                self.sentence_speakers.append(speaker_id)
+                
+                # Remove from pending
+                if text in self.pending_sentences:
+                    self.pending_sentences.remove(text)
+                    
+            except queue.Empty:
+                continue
+            except Exception as e:
+                print(f"Error processing sentence: {e}")
+    
+    def start_recording(self):
+        """Start the recording and transcription process"""
+        if self.encoder is None:
+            return "Please initialize models first!"
+        
         try:
-            if self.whisper_model is None:
-                return "Mock transcription: Hello, this is a test."
+            # Setup recorder configuration
+            recorder_config = {
+                'spinner': False,
+                'use_microphone': USE_MICROPHONE,
+                'model': FINAL_TRANSCRIPTION_MODEL,
+                'language': TRANSCRIPTION_LANGUAGE,
+                'silero_sensitivity': SILERO_SENSITIVITY,
+                'webrtc_sensitivity': WEBRTC_SENSITIVITY,
+                'post_speech_silence_duration': SILENCE_THRESHS[1],
+                'min_length_of_recording': MIN_LENGTH_OF_RECORDING,
+                'pre_recording_buffer_duration': PRE_RECORDING_BUFFER_DURATION,
+                'min_gap_between_recordings': 0,
+                'enable_realtime_transcription': True,
+                'realtime_processing_pause': 0,
+                'realtime_model_type': REALTIME_TRANSCRIPTION_MODEL,
+                'on_realtime_transcription_update': self.live_text_detected,
+                'beam_size': FINAL_BEAM_SIZE,
+                'beam_size_realtime': REALTIME_BEAM_SIZE,
+                'buffer_size': BUFFER_SIZE,
+                'sample_rate': SAMPLE_RATE,
+            }
+
+            self.recorder = AudioToTextRecorder(**recorder_config)
             
-            # Ensure audio is the right format
-            if isinstance(audio_data, tuple):
-                sr, audio_data = audio_data
+            # Start sentence processing thread
+            self.is_running = True
+            self.sentence_thread = threading.Thread(target=self.process_sentence_queue, daemon=True)
+            self.sentence_thread.start()
             
-            if len(audio_data.shape) > 1:
-                audio_data = audio_data.mean(axis=1)
+            # Start audio capture thread
+            self.audio_thread = threading.Thread(target=self.capture_audio, daemon=True)
+            self.audio_thread.start()
             
-            # Normalize audio
-            audio_data = audio_data.astype(np.float32)
-            if np.abs(audio_data).max() > 1.0:
-                audio_data = audio_data / np.abs(audio_data).max()
+            # Start transcription thread
+            self.transcription_thread = threading.Thread(target=self.run_transcription, daemon=True)
+            self.transcription_thread.start()
             
-            # Resample to 16kHz if needed
-            if sr != 16000:
-                audio_data = librosa.resample(audio_data, orig_sr=sr, target_sr=16000)
+            return "Recording started successfully!"
             
-            # Transcribe
-            result = self.whisper_model.transcribe(audio_data, language="en")
-            return result["text"].strip()
+        except Exception as e:
+            return f"Error starting recording: {e}"
+    
+    def capture_audio(self):
+        """Capture audio from default speaker/microphone"""
+        try:
+            device_id = str(sc.default_speaker().name if not USE_MICROPHONE else sc.default_microphone().name)
+            include_loopback = not USE_MICROPHONE
             
+            with sc.get_microphone(id=device_id, include_loopback=include_loopback).recorder(
+                samplerate=SAMPLE_RATE, blocksize=BUFFER_SIZE
+            ) as mic:
+                while self.is_running:
+                    audio_data = mic.record(numframes=BUFFER_SIZE)
+                    
+                    if audio_data.shape[1] > 1 and CHANNELS == 1:
+                        audio_data = audio_data[:, 0]
+                    
+                    audio_int16 = (audio_data.flatten() * 32767).astype(np.int16)
+                    audio_bytes = audio_int16.tobytes()
+                    self.recorder.feed_audio(audio_bytes)
+                    
+        except Exception as e:
+            print(f"Audio capture error: {e}")
+    
+    def run_transcription(self):
+        """Run the transcription loop"""
+        try:
+            while self.is_running:
+                self.recorder.text(self.process_final_text)
         except Exception as e:
             print(f"Transcription error: {e}")
-            return ""
     
-    def extract_speaker_embedding(self, audio_data, sr=16000):
-        """Extract speaker embedding from audio"""
-        return self.encoder.embed_utterance(audio_data, sr)
+    def stop_recording(self):
+        """Stop the recording process"""
+        self.is_running = False
+        if self.recorder:
+            self.recorder.stop()
+        return "Recording stopped!"
     
-    def process_audio_segment(self, audio_data, sr=16000):
-        """Process an audio segment for transcription and speaker identification"""
-        if len(audio_data) < sr * 0.5:  # Skip very short segments
-            return None, None, None
-        
-        # Transcribe the audio
-        transcription = self.transcribe_audio(audio_data, sr)
-        
-        if not transcription:
-            return None, None, None
-        
-        # Extract speaker embedding
-        embedding = self.extract_speaker_embedding(audio_data, sr)
-        
-        # Detect speaker
-        speaker_id, similarity = self.speaker_detector.add_embedding(embedding)
+    def clear_conversation(self):
+        """Clear all conversation data"""
+        self.full_sentences = []
+        self.sentence_speakers = []
+        self.pending_sentences = []
+        self.displayed_text = ""
+        self.last_realtime_text = ""
+        
+        if self.speaker_detector:
+            self.speaker_detector = SpeakerChangeDetector(
+                embedding_dim=self.encoder.embedding_dim,
+                change_threshold=self.change_threshold,
+                max_speakers=self.max_speakers
+            )
         
-        return transcription, speaker_id, similarity
+        return "Conversation cleared!"
     
-    def update_conversation(self, transcription, speaker_id):
-        """Update conversation history with new transcription"""
-        speaker_name = f"Speaker {speaker_id + 1}"
-        color = self.speaker_detector.get_color_for_speaker(speaker_id)
-        
-        entry = {
-            "speaker": speaker_name,
-            "text": transcription,
-            "color": color,
-            "timestamp": time.time()
-        }
+    def update_settings(self, threshold, max_speakers):
+        """Update speaker detection settings"""
+        self.change_threshold = threshold
+        self.max_speakers = max_speakers
         
-        self.conversation_history.append(entry)
-        return entry
-    
-    def format_conversation_html(self):
-        """Format conversation history as HTML"""
-        if not self.conversation_history:
-            return "<p><i>No conversation yet. Start speaking to see real-time transcription with speaker diarization.</i></p>"
-        
-        html_parts = []
-        for entry in self.conversation_history:
-            html_parts.append(
-                f'<p><span style="color: {entry["color"]}; font-weight: bold;">'
-                f'{entry["speaker"]}:</span> {entry["text"]}</p>'
-            )
+        if self.speaker_detector:
+            self.speaker_detector.set_change_threshold(threshold)
+            self.speaker_detector.set_max_speakers(max_speakers)
         
-        return "".join(html_parts)
+        return f"Settings updated: Threshold={threshold:.2f}, Max Speakers={max_speakers}"
+    
+    def get_formatted_conversation(self):
+        """Get the formatted conversation with speaker colors"""
+        try:
+            sentences_with_style = []
+            
+            # Process completed sentences
+            for i, sentence in enumerate(self.full_sentences):
+                sentence_text, _ = sentence
+                if i >= len(self.sentence_speakers):
+                    color = "#FFFFFF"
+                else:
+                    speaker_id = self.sentence_speakers[i]
+                    color = self.speaker_detector.get_color_for_speaker(speaker_id)
+                    speaker_name = f"Speaker {speaker_id + 1}"
+                    
+                sentences_with_style.append(
+                    f'<span style="color:{color};"><b>{speaker_name}:</b> {sentence_text}</span>')
+            
+            # Add pending sentences
+            for pending_sentence in self.pending_sentences:
+                sentences_with_style.append(
+                    f'<span style="color:#60FFFF;"><b>Processing:</b> {pending_sentence}</span>')
+            
+            if sentences_with_style:
+                return "<br><br>".join(sentences_with_style)
+            else:
+                return "Waiting for speech input..."
+                
+        except Exception as e:
+            return f"Error formatting conversation: {e}"
     
     def get_status_info(self):
         """Get current status information"""
-        status = {
-            "active_speakers": len(self.speaker_detector.active_speakers),
-            "max_speakers": self.speaker_detector.max_speakers,
-            "current_speaker": self.speaker_detector.current_speaker + 1,
-            "total_segments": len(self.conversation_history),
-            "threshold": self.speaker_detector.change_threshold
-        }
-        return status
-    
-    def clear_conversation(self):
-        """Clear conversation history and reset speaker detector"""
-        self.conversation_history = []
-        self.speaker_detector = SpeakerChangeDetector(
-            change_threshold=self.speaker_detector.change_threshold,
-            max_speakers=self.speaker_detector.max_speakers
-        )
-    
-    def set_parameters(self, threshold, max_speakers):
-        """Update parameters"""
-        self.speaker_detector.set_change_threshold(threshold)
-        self.speaker_detector.set_max_speakers(max_speakers)
+        if not self.speaker_detector:
+            return "Speaker detector not initialized"
+        
+        try:
+            status = self.speaker_detector.get_status_info()
+            
+            status_lines = [
+                f"**Current Speaker:** {status['current_speaker'] + 1}",
+                f"**Active Speakers:** {status['active_speakers']} of {status['max_speakers']}",
+                f"**Last Similarity:** {status['last_similarity']:.3f}",
+                f"**Change Threshold:** {status['threshold']:.2f}",
+                f"**Total Sentences:** {len(self.full_sentences)}",
+                "",
+                "**Speaker Segment Counts:**"
+            ]
+            
+            for i in range(status['max_speakers']):
+                color_name = SPEAKER_COLOR_NAMES[i] if i < len(SPEAKER_COLOR_NAMES) else f"Speaker {i+1}"
+                status_lines.append(f"Speaker {i+1} ({color_name}): {status['speaker_counts'][i]}")
+            
+            return "\n".join(status_lines)
+            
+        except Exception as e:
+            return f"Error getting status: {e}"
 
 
 # Global instance
-asr_system = RealTimeASRDiarization()
+diarization_system = RealtimeSpeakerDiarization()
 
 
-def process_audio_realtime(audio_data, threshold, max_speakers):
-    """Process audio in real-time"""
-    global asr_system
-    
-    if audio_data is None:
-        return asr_system.format_conversation_html(), get_status_display()
-    
-    # Update parameters
-    asr_system.set_parameters(threshold, max_speakers)
-    
-    try:
-        # Process the audio segment
-        sr, audio_array = audio_data
-        
-        # Convert to float32 and normalize
-        if audio_array.dtype != np.float32:
-            audio_array = audio_array.astype(np.float32)
-            if audio_array.dtype == np.int16:
-                audio_array = audio_array / 32768.0
-            elif audio_array.dtype == np.int32:
-                audio_array = audio_array / 2147483648.0
-        
-        # Process the audio segment
-        transcription, speaker_id, similarity = asr_system.process_audio_segment(audio_array, sr)
-        
-        if transcription and speaker_id is not None:
-            # Update conversation
-            asr_system.update_conversation(transcription, speaker_id)
-    
-    except Exception as e:
-        print(f"Error processing audio: {e}")
-    
-    return asr_system.format_conversation_html(), get_status_display()
+def initialize_system():
+    """Initialize the diarization system"""
+    success = diarization_system.initialize_models()
+    if success:
+        return "✅ System initialized successfully! Models loaded."
+    else:
+        return "❌ Failed to initialize system. Please check the logs."
 
 
-def get_status_display():
-    """Get formatted status display"""
-    status = asr_system.get_status_info()
-    
-    status_html = f"""
-    <div style="font-family: monospace; font-size: 12px;">
-    <strong>Status:</strong><br>
-    Current Speaker: {status['current_speaker']}<br>
-    Active Speakers: {status['active_speakers']} / {status['max_speakers']}<br>
-    Total Segments: {status['total_segments']}<br>
-    Threshold: {status['threshold']:.2f}<br>
-    </div>
-    """
-    
-    return status_html
+def start_recording():
+    """Start recording and transcription"""
+    return diarization_system.start_recording()
+
+
+def stop_recording():
+    """Stop recording and transcription"""
+    return diarization_system.stop_recording()
 
 
 def clear_conversation():
     """Clear the conversation"""
-    global asr_system
-    asr_system.clear_conversation()
-    return asr_system.format_conversation_html(), get_status_display()
+    return diarization_system.clear_conversation()
+
+
+def update_settings(threshold, max_speakers):
+    """Update system settings"""
+    return diarization_system.update_settings(threshold, max_speakers)
+
 
+def get_conversation():
+    """Get the current conversation"""
+    return diarization_system.get_formatted_conversation()
 
+
+def get_status():
+    """Get system status"""
+    return diarization_system.get_status_info()
+
+
+# Create Gradio interface
 def create_interface():
-    """Create Gradio interface"""
-    
-    with gr.Blocks(
-        title="Real-time ASR with Speaker Diarization",
-        theme=gr.themes.Soft(),
-        css="""
-        .conversation-box {
-            height: 400px;
-            overflow-y: auto;
-            border: 1px solid #ddd;
-            padding: 10px;
-            background-color: #f9f9f9;
-        }
-        .status-box {
-            border: 1px solid #ccc;
-            padding: 10px;
-            background-color: #f0f0f0;
-        }
-        """
-    ) as demo:
-        
-        gr.Markdown(
-            """
-            # 🎤 Real-time ASR with Live Speaker Diarization
-            
-            This application provides real-time speech recognition with speaker diarization. 
-            It can distinguish between different speakers and display their conversations in different colors.
-            
-            **Instructions:**
-            1. Adjust the speaker change threshold and maximum speakers
-            2. Click the microphone button to start recording
-            3. Speak naturally - the system will detect speaker changes and transcribe speech
-            4. Each speaker will be assigned a different color
-            """
-        )
+    with gr.Blocks(title="Real-time Speaker Diarization", theme=gr.themes.Dark()) as app:
+        gr.Markdown("# 🎤 Real-time Speech Recognition with Speaker Diarization")
+        gr.Markdown("This app performs real-time speech recognition with automatic speaker identification and color-coding.")
         
         with gr.Row():
-            with gr.Column(scale=3):
+            with gr.Column(scale=2):
                 # Main conversation display
-                conversation_display = gr.HTML(
-                    value="<p><i>Click the microphone to start recording...</i></p>",
-                    elem_classes=["conversation-box"]
+                conversation_output = gr.HTML(
+                    value="<i>Click 'Initialize System' to start...</i>",
+                    label="Live Conversation"
                 )
                 
-                # Audio input
-                audio_input = gr.Audio(
-                    source="microphone",
-                    type="numpy",
-                    streaming=True,
-                    label="🎤 Microphone Input"
-                )
+                # Control buttons
+                with gr.Row():
+                    init_btn = gr.Button("🔧 Initialize System", variant="secondary")
+                    start_btn = gr.Button("🎙️ Start Recording", variant="primary", interactive=False)
+                    stop_btn = gr.Button("⏹️ Stop Recording", variant="stop", interactive=False)
+                    clear_btn = gr.Button("🗑️ Clear Conversation", interactive=False)
                 
+                # Status display
+                status_output = gr.Textbox(
+                    label="System Status",
+                    value="System not initialized",
+                    lines=8,
+                    interactive=False
+                )
+            
             with gr.Column(scale=1):
-                # Controls
-                gr.Markdown("### Controls")
+                # Settings panel
+                gr.Markdown("## ⚙️ Settings")
                 
                 threshold_slider = gr.Slider(
                     minimum=0.1,
-                    maximum=0.9,
-                    value=DEFAULT_CHANGE_THRESHOLD,
+                    maximum=0.95,
                     step=0.05,
-                    label="Speaker Change Threshold",
-                    info="Higher values = less sensitive to speaker changes"
+                    value=DEFAULT_CHANGE_THRESHOLD,
+                    label="Speaker Change Sensitivity",
+                    info="Lower values = more sensitive to speaker changes"
                 )
                 
                 max_speakers_slider = gr.Slider(
                     minimum=2,
                     maximum=ABSOLUTE_MAX_SPEAKERS,
-                    value=DEFAULT_MAX_SPEAKERS,
                     step=1,
-                    label="Maximum Speakers",
-                    info="Maximum number of different speakers to detect"
+                    value=DEFAULT_MAX_SPEAKERS,
+                    label="Maximum Number of Speakers"
                 )
                 
-                clear_btn = gr.Button("🗑️ Clear Conversation", variant="secondary")
-                
-                # Status display
-                gr.Markdown("### Status")
-                status_display = gr.HTML(
-                    value=get_status_display(),
-                    elem_classes=["status-box"]
-                )
+                update_settings_btn = gr.Button("Update Settings")
                 
                 # Speaker color legend
-                gr.Markdown("### Speaker Colors")
-                legend_html = ""
-                for i in range(ABSOLUTE_MAX_SPEAKERS):
-                    color = SPEAKER_COLORS[i]
-                    name = SPEAKER_COLOR_NAMES[i]
-                    legend_html += f'<p><span style="color: {color}; font-weight: bold;">● Speaker {i+1} ({name})</span></p>'
+                gr.Markdown("## 🎨 Speaker Colors")
+                color_info = []
+                for i, (color, name) in enumerate(zip(SPEAKER_COLORS, SPEAKER_COLOR_NAMES)):
+                    color_info.append(f'<span style="color:{color};">■</span> Speaker {i+1} ({name})')
                 
-                gr.HTML(legend_html)
+                gr.HTML("<br>".join(color_info[:DEFAULT_MAX_SPEAKERS]))
+        
+        # Auto-refresh conversation and status
+        def refresh_display():
+            return get_conversation(), get_status()
         
         # Event handlers
-        audio_input.change(
-            fn=process_audio_realtime,
-            inputs=[audio_input, threshold_slider, max_speakers_slider],
-            outputs=[conversation_display, status_display],
-            show_progress=False
+        def on_initialize():
+            result = initialize_system()
+            if "successfully" in result:
+                return (
+                    result,
+                    gr.update(interactive=True),   # start_btn
+                    gr.update(interactive=True),   # clear_btn
+                    get_conversation(),
+                    get_status()
+                )
+            else:
+                return (
+                    result,
+                    gr.update(interactive=False),  # start_btn
+                    gr.update(interactive=False),  # clear_btn
+                    get_conversation(),
+                    get_status()
+                )
+        
+        def on_start():
+            result = start_recording()
+            return (
+                result,
+                gr.update(interactive=False),  # start_btn
+                gr.update(interactive=True),   # stop_btn
+            )
+        
+        def on_stop():
+            result = stop_recording()
+            return (
+                result,
+                gr.update(interactive=True),   # start_btn
+                gr.update(interactive=False),  # stop_btn
+            )
+        
+        # Connect event handlers
+        init_btn.click(
+            on_initialize,
+            outputs=[status_output, start_btn, clear_btn, conversation_output, status_output]
+        )
+        
+        start_btn.click(
+            on_start,
+            outputs=[status_output, start_btn, stop_btn]
+        )
+        
+        stop_btn.click(
+            on_stop,
+            outputs=[status_output, start_btn, stop_btn]
         )
         
         clear_btn.click(
-            fn=clear_conversation,
-            outputs=[conversation_display, status_display]
+            clear_conversation,
+            outputs=[status_output]
+        )
+        
+        update_settings_btn.click(
+            update_settings,
+            inputs=[threshold_slider, max_speakers_slider],
+            outputs=[status_output]
         )
         
-        # Update status periodically
-        demo.load(
-            fn=lambda: (asr_system.format_conversation_html(), get_status_display()),
-            outputs=[conversation_display, status_display],
-            every=2
+        # Auto-refresh every 2 seconds when recording
+        refresh_timer = gr.Timer(2.0)
+        refresh_timer.tick(
+            refresh_display,
+            outputs=[conversation_output, status_output]
         )
     
-    return demo
+    return app
 
 
 if __name__ == "__main__":
-    # Create and launch the interface
-    demo = create_interface()
-    demo.launch(
+    app = create_interface()
+    app.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=True