add smaller chuncks

audio_extractor.py

@@ -254,25 +254,63 @@ class SimpleAudioExtractor:
         except Exception as e:
             raise Exception(f"Failed to convert audio to WAV: {str(e)}")
 
-def chunk_audio_1min(waveform, sample_rate):
-    """Create 1-minute chunks from audio"""
-    chunk_length_sec = 60  # 1 minute chunks
-    chunk_samples = chunk_length_sec * sample_rate
+def chunk_audio_adaptive(waveform, sample_rate, min_chunk_sec=2):
+    """Create adaptive chunks from audio, handling small voices and short audio"""
     total_samples = waveform.size(1)
+    duration_sec = total_samples / sample_rate
+    
+    print(f"🎵 Audio duration: {duration_sec:.2f} seconds ({duration_sec/60:.2f} minutes)")
+    
+    # For very short audio (less than 5 seconds), return as single chunk
+    if duration_sec <= 5:
+        print(f"📦 Audio is very short ({duration_sec:.2f}s), keeping as single chunk")
+        return [waveform]
+    
+    # For short audio (5-30 seconds), create smaller chunks
+    elif duration_sec <= 30:
+        chunk_length_sec = max(min_chunk_sec, duration_sec / 3)  # Split into ~3 chunks
+        print(f"📦 Short audio detected, using {chunk_length_sec:.1f}s chunks")
+    
+    # For medium audio (30s-2min), use 30-second chunks
+    elif duration_sec <= 120:
+        chunk_length_sec = 30
+        print(f"📦 Medium audio detected, using {chunk_length_sec}s chunks")
+    
+    # For long audio (>2min), use 1-minute chunks
+    else:
+        chunk_length_sec = 60
+        print(f"📦 Long audio detected, using {chunk_length_sec}s chunks")
+    
+    chunk_samples = int(chunk_length_sec * sample_rate)
     chunks = []
+    min_samples = int(min_chunk_sec * sample_rate)  # Minimum chunk size
 
     for start in range(0, total_samples, chunk_samples):
         end = min(start + chunk_samples, total_samples)
         chunk = waveform[:, start:end]
-        # Only include chunks that are at least 10 seconds long
-        if chunk.size(1) > sample_rate * 10:
+        
+        # Include chunk if it meets minimum size OR if it's the last chunk and we have no chunks yet
+        if chunk.size(1) >= min_samples or (len(chunks) == 0 and start + chunk_samples >= total_samples):
             chunks.append(chunk)
+            chunk_dur = chunk.size(1) / sample_rate
+            print(f"  ✓ Chunk {len(chunks)}: {chunk_dur:.2f}s")
+        else:
+            # If chunk is too small, merge it with the previous chunk if possible
+            if chunks:
+                print(f"  📎 Merging small chunk ({chunk.size(1) / sample_rate:.2f}s) with previous")
+                chunks[-1] = torch.cat([chunks[-1], chunk], dim=1)
+                merged_dur = chunks[-1].size(1) / sample_rate
+                print(f"  ✓ Merged chunk {len(chunks)}: {merged_dur:.2f}s")
+            else:
+                # If no previous chunks, keep it anyway (better than losing audio)
+                chunks.append(chunk)
+                print(f"  ⚠️ Keeping small chunk {len(chunks)}: {chunk.size(1) / sample_rate:.2f}s (no other chunks)")
     
-    print(f"📦 Created {len(chunks)} 1-minute chunks")
+    print(f"📦 Created {len(chunks)} adaptive chunks")
     return chunks
 
-def prepare_audio(video_source):
-    """Main function to extract and prepare 1-minute audio chunks"""
+def prepare_audio(video_source, min_chunk_seconds=2):
+    """Main function to extract and prepare adaptive audio chunks for small voices"""
     try:
         print(f"🎵 Extracting audio from source...")
         extractor = SimpleAudioExtractor()
@@ -295,21 +333,34 @@ def prepare_audio(video_source):
         end = time.time()
         print(f"[⏱️] Audio preparation took {end - start:.2f} seconds.")
 
-        # Calculate duration and create 1-minute chunks
+        # Calculate duration
         duration_minutes = waveform.size(1) / sample_rate / 60
         
-        print(f"🧩 Creating 1-minute chunks...")
+        print(f"🧩 Creating adaptive chunks (min {min_chunk_seconds}s)...")
         start = time.time()
-        chunks = chunk_audio_1min(waveform, sample_rate)
+        chunks = chunk_audio_adaptive(waveform, sample_rate, min_chunk_seconds)
         end = time.time()
         print(f"[⏱️] Chunking took {end - start:.2f} seconds. Total chunks: {len(chunks)}")
 
+        # Log chunk details
+        print("📋 Chunk Summary:")
+        total_chunk_duration = 0
+        for i, chunk in enumerate(chunks, 1):
+            chunk_duration = chunk.size(1) / sample_rate
+            total_chunk_duration += chunk_duration
+            print(f"  Chunk {i}: {chunk_duration:.2f}s")
+        
+        print(f"  Total chunked duration: {total_chunk_duration:.2f}s")
+        print(f"  Original duration: {duration_minutes * 60:.2f}s")
+
         return {
             "success": True,
             "chunks": chunks,
             "audio_path": audio_path,
             "duration_minutes": duration_minutes,
-            "total_chunks": len(chunks)
+            "total_chunks": len(chunks),
+            "chunk_details": [{"chunk_id": i+1, "duration_seconds": chunk.size(1) / sample_rate} 
+                            for i, chunk in enumerate(chunks)]
         }
 
     except Exception as e: