add

audio_extractor.py

@@ -254,63 +254,33 @@ class SimpleAudioExtractor:
         except Exception as e:
             raise Exception(f"Failed to convert audio to WAV: {str(e)}")
 
-def chunk_audio_adaptive(waveform, sample_rate, min_chunk_sec=2):
-    """Create adaptive chunks from audio, handling small voices and short audio"""
+def chunk_audio_1min(waveform, sample_rate, short_audio_threshold=30):
+    """Create 1-minute chunks from audio, handle short audio as single chunk"""
     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")
+    # If audio is short (≤30 seconds by default), return as single chunk
+    if duration_sec <= short_audio_threshold:
+        print(f"📦 Short audio ({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)
+    # For longer audio, use 1-minute chunks
+    chunk_length_sec = 60  # 1 minute chunks
+    chunk_samples = 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]
-        
-        # 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):
+        # Only include chunks that are at least 10 seconds long
+        if chunk.size(1) > sample_rate * 10:
             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)} adaptive chunks")
+    print(f"📦 Created {len(chunks)} 1-minute chunks")
     return chunks
 
-def prepare_audio(video_source, min_chunk_seconds=2):
-    """Main function to extract and prepare adaptive audio chunks for small voices"""
+def prepare_audio(video_source, short_audio_threshold=30):
+    """Main function to extract and prepare audio chunks, handling short audio as single segment"""
     try:
         print(f"🎵 Extracting audio from source...")
         extractor = SimpleAudioExtractor()
@@ -333,34 +303,21 @@ def prepare_audio(video_source, min_chunk_seconds=2):
         end = time.time()
         print(f"[⏱️] Audio preparation took {end - start:.2f} seconds.")
 
-        # Calculate duration
+        # Calculate duration and create chunks
         duration_minutes = waveform.size(1) / sample_rate / 60
         
-        print(f"🧩 Creating adaptive chunks (min {min_chunk_seconds}s)...")
+        print(f"🧩 Creating chunks (short audio threshold: {short_audio_threshold}s)...")
         start = time.time()
-        chunks = chunk_audio_adaptive(waveform, sample_rate, min_chunk_seconds)
+        chunks = chunk_audio_1min(waveform, sample_rate, short_audio_threshold)
         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),
-            "chunk_details": [{"chunk_id": i+1, "duration_seconds": chunk.size(1) / sample_rate} 
-                            for i, chunk in enumerate(chunks)]
+            "total_chunks": len(chunks)
         }
 
     except Exception as e: