input stream

app/services/processor.py

@@ -60,13 +60,9 @@ def convert_audio_to_wav(audio_path: Path) -> Path:
 
 
 def format_timestamp(seconds: float) -> str:
-    """Format seconds to MM:SS.ms or HH:MM:SS.ms"""
-    hours = int(seconds // 3600)
-    minutes = int((seconds % 3600) // 60)
-    secs = seconds % 60
-    if hours > 0:
-        return f"{hours:02d}:{minutes:02d}:{secs:05.2f}"
-    return f"{minutes:02d}:{secs:05.2f}"
+    m = int(seconds // 60)
+    s = seconds % 60
+    return f"{m:02d}:{s:06.3f}"
 
 
 def pad_and_refine_tensor(
@@ -84,37 +80,34 @@ def pad_and_refine_tensor(
     """
     total_len = waveform.shape[1]
 
-    start_s = max(start_s - pad_ms / 1000, 0)
-    end_s = min(end_s + pad_ms / 1000, total_len / sr)
-
-    start_idx = int(start_s * sr)
-    end_idx = int(end_s * sr)
+    start_idx = max(int((start_s - pad_ms / 1000) * sr), 0)
+    end_idx = min(int((end_s + pad_ms / 1000) * sr), total_len)
 
     if end_idx <= start_idx:
         return None
 
-    seg = waveform[:, start_idx:end_idx]
-    if seg.numel() == 0:
+    segment  = waveform[:, start_idx:end_idx]
+    if segment .numel() == 0:
         return None
 
     # RMS energy
-    rms = torch.sqrt(torch.mean(seg ** 2, dim=0))
-    if rms.numel() == 0:
-        return None
+    rms = torch.sqrt(torch.mean(segment ** 2) + 1e-9)
+    threshold = rms / silence_db_delta
 
-    threshold = torch.quantile(rms, 0.2)
-    valid = torch.where(rms > threshold)[0]
+    energy = torch.abs(segment)
+    valid = torch.where(energy > threshold)[0]
 
     if valid.numel() == 0:
         return None
 
-    refined_start = start_idx + valid[0].item()
-    refined_end = start_idx + valid[-1].item()
 
-    if refined_end - refined_start < (min_duration_ms / 1000) * sr:
+    new_start = start_idx + valid[0].item()
+    new_end = start_idx + valid[-1].item()
+
+    if new_end - new_start < int(min_duration_ms / 1000 * sr):
         return None
 
-    return refined_start, refined_end
+    return new_start, new_end
 
 
 # =========================
@@ -143,7 +136,7 @@ class Processor:
 
         import asyncio
 
-        total_start = time.time()
+        t0= time.time()
 
         # Step 1: Convert to WAV
         logger.info("Step 1: Converting audio to WAV 16kHz...")
@@ -158,37 +151,35 @@ class Processor:
         
         # Step 3: Diarization
         logger.info("Step 3: Running diarization...")
+        
         try:
-            diar_segments = await DiarizationService.diarize_async(wav_path)
+            diarization_segments = await DiarizationService.diarize_async(wav_path)
         except Exception as e:
             logger.error(f"Diarization failed: {e}")
-            # Fallback: create single segment for whole audio
-            diar_segments = [SpeakerSegment(
-                start=0.0,
-                end=duration,
-                speaker="Speaker 1"
-            )]
+            diarization_segments = []
+
+        if not diarization_segments:
+            diarization_segments = [
+                SpeakerSegment(0.0, duration, "Speaker 1")
+            ]
         
         # Sort by start time
-        diar_segments.sort(key=lambda x: x.start)
+        diarization_segments.sort(key=lambda x: x.start)
         
 
         # Step 4: Refine segment boundaries
         refined_segments: List[SpeakerSegment] = []
 
-        for seg in diar_segments:
-            start, end = seg.start, seg.end
+        for seg in diarization_segments:
+            start_idx = int(seg.start * sr)
+            end_idx = int(seg.end * sr)
 
             if pad_refine:
-                refined = pad_and_refine_tensor(waveform, sr, start, end)
-                if refined is None:
-                    start_idx = int(start * sr)
-                    end_idx = int(end * sr)
-                else:
+                refined = pad_and_refine_tensor(
+                    waveform, sr, seg.start, seg.end
+                )
+                if refined:
                     start_idx, end_idx = refined
-            else:
-                start_idx = int(start * sr)
-                end_idx = int(end * sr)
 
             if end_idx <= start_idx:
                 continue
@@ -197,12 +188,17 @@ class Processor:
                 SpeakerSegment(
                     start=start_idx / sr,
                     end=end_idx / sr,
-                    speaker=seg.speaker
+                    speaker=seg.speaker or "Speaker 1"
                 )
             )
+        if not refined_segments:
+                refined_segments = [
+                    SpeakerSegment(0.0, duration, "Speaker 1")
+                ]
+    
+        logger.info(f"Refined segments: {len(refined_segments)}")
 
         # Step 5: Transcribe
-        logger.info(f"Step 5: Transcribing {len(refined_segments)} segments...")
         vad_options = None
         if vad_filter:
             vad_options = {
@@ -213,49 +209,71 @@ class Processor:
             }
 
         processed_segments: List[TranscriptSegment] = []
-        unique_speakers = set()
+        speakers = set()
+
+        for seg in refined_segments:
+            start = int(seg.start * sr)
+            end = int(seg.end * sr)
+
+            if end <= start:
+                continue
 
-        for idx, seg in enumerate(refined_segments):
-            logger.info(f"Transcribing segment {idx+1}/{len(refined_segments)} ({seg.speaker})...")
-            start_sample = int(seg.start * sr)
-            end_sample = int(seg.end * sr)
-            if end_sample <= start_sample:
+            audio_slice = y[start:end]
+            if audio_slice.size < sr * 0.25:
                 continue
-            y_seg = waveform[:, start_sample:end_sample]
+
             try:
                 text = await TranscriptionService.transcribe_segment_async(
-                    audio_array=y_seg,
+                    audio_array=audio_slice,
                     model_name=model_name,
                     language=language,
                     vad_options=vad_options,
                     beam_size=beam_size,
                     temperature=temperature,
                     best_of=best_of,
-                    initial_prompt=initial_prompt
+                    initial_prompt=initial_prompt,
                 )
-                if text.strip():
-                    unique_speakers.add(seg.speaker)
-                    processed_segments.append(TranscriptSegment(start=seg.start, end=seg.end, speaker=seg.speaker, text=text.strip()))
             except Exception as e:
-                logger.error(f"Error transcribing segment {idx}: {e}")
+                logger.error(f"Transcribe error: {e}")
+                continue
+
+            if not text or not text.strip():
                 continue
 
-        processing_time = time.time() - total_start
-        logger.info(f"Processing complete: {len(processed_segments)} segments, {len(unique_speakers)} speakers in {processing_time:.1f}s")
+            processed_segments.append(
+                TranscriptSegment(
+                    start=seg.start,
+                    end=seg.end,
+                    speaker=seg.speaker,
+                    text=text.strip(),
+                )
+            )
+            speakers.add(seg.speaker)
+
+        if not processed_segments:
+            processed_segments = [
+                TranscriptSegment(
+                    start=0.0,
+                    end=duration,
+                    speaker="Speaker 1",
+                    text="(No speech detected)"
+                )
+            ]
+            speakers.add("Speaker 1")
+
+        processing_time = time.time() - t0
 
-        # Step 6: Generate outputs
-        txt_content = cls._generate_txt(processed_segments, unique_speakers, processing_time, duration)
+        txt_content = cls._generate_txt(processed_segments, speakers, processing_time, duration)
         csv_content = cls._generate_csv(processed_segments)
 
         return ProcessingResult(
             segments=processed_segments,
-            speaker_count=len(unique_speakers),
+            speaker_count=len(speakers),
             duration=duration,
             processing_time=processing_time,
             txt_content=txt_content,
-            csv_content=csv_content
+            csv_content=csv_content,
         )
-
     @classmethod
     def _generate_txt(cls, segments: List[TranscriptSegment], speakers: set, processing_time: float, duration: float) -> str:
         lines = [