Update app.py

app.py

@@ -9,6 +9,17 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import List, Tuple
 import math
 
+class TimingManager:
+    def __init__(self):
+        self.current_time = 0
+        self.segment_gap = 100  # ms gap between segments
+    
+    def get_timing(self, duration):
+        start_time = self.current_time
+        end_time = start_time + duration
+        self.current_time = end_time + self.segment_gap
+        return start_time, end_time
+
 def get_audio_length(audio_file):
     audio = AudioSegment.from_file(audio_file)
     return len(audio) / 1000
@@ -88,71 +99,70 @@ def smart_text_split(text, words_per_line, lines_per_segment):
     
     return segments
 
-async def process_segment(segment: str, idx: int, voice: str, rate: str, pitch: str) -> Tuple[str, AudioSegment, int]:
-    """Process a single segment concurrently"""
+async def process_segment(segment: str, idx: int, voice: str, rate: str, pitch: str, timing_mgr: TimingManager) -> Tuple[str, AudioSegment]:
+    """Process a single segment with accurate timing"""
     audio_file = f"temp_segment_{idx}_{uuid.uuid4()}.wav"
     try:
         tts = edge_tts.Communicate(segment, voice, rate=rate, pitch=pitch)
         await tts.save(audio_file)
         
         segment_audio = AudioSegment.from_file(audio_file)
-        # Add small silence at the end of each segment
-        segment_audio = segment_audio + AudioSegment.silent(duration=250)
         segment_duration = len(segment_audio)
         
-        return "", segment_audio, segment_duration
+        # Get timing from manager
+        start_time, end_time = timing_mgr.get_timing(segment_duration)
+        
+        # Format SRT entry
+        srt_content = (
+            f"{idx}\n"
+            f"{format_time_ms(start_time)} --> {format_time_ms(end_time)}\n"
+            f"{segment}\n\n"
+        )
+        
+        return srt_content, segment_audio
     finally:
         if os.path.exists(audio_file):
             os.remove(audio_file)
 
-async def process_chunk_parallel(chunks: List[str], start_idx: int, voice: str, rate: str, pitch: str) -> Tuple[str, AudioSegment]:
-    """Process a chunk of segments in parallel"""
-    tasks = [
-        process_segment(segment, i + start_idx, voice, rate, pitch)
-        for i, segment in enumerate(chunks, 1)
-    ]
-    
-    results = await asyncio.gather(*tasks)
-    
+async def process_chunk_parallel(chunks: List[str], start_idx: int, voice: str, rate: str, pitch: str, timing_mgr: TimingManager) -> Tuple[str, AudioSegment]:
+    """Process chunks with sequential timing"""
     combined_audio = AudioSegment.empty()
     srt_content = ""
-    current_time = 0
     
-    for idx, (_, audio_part, duration) in enumerate(results, start_idx):
-        # Calculate start and end times
-        start_time = current_time
-        end_time = start_time + duration
-        
-        # Format SRT entry
-        srt_content += f"{idx}\n"
-        srt_content += f"{format_time_ms(start_time)} --> {format_time_ms(end_time)}\n"
-        srt_content += chunks[idx - start_idx] + "\n\n"
-        
+    # Process segments sequentially to maintain timing
+    for i, segment in enumerate(chunks, start_idx):
+        srt_part, audio_part = await process_segment(segment, i, voice, rate, pitch, timing_mgr)
+        srt_content += srt_part
         combined_audio += audio_part
-        # Add the duration plus a small gap
-        current_time = end_time + 100  # 100ms gap between segments
     
     return srt_content, combined_audio
 
 async def generate_accurate_srt(text, voice, rate, pitch, words_per_line, lines_per_segment):
     segments = smart_text_split(text, words_per_line, lines_per_segment)
+    timing_mgr = TimingManager()
     
-    # Process smaller chunks for better timing control
-    chunk_size = 5  # Reduced from 10 to 5 for better timing control
+    # Process in smaller chunks
+    chunk_size = 5
     chunks = [segments[i:i + chunk_size] for i in range(0, len(segments), chunk_size)]
     
     final_srt = ""
     final_audio = AudioSegment.empty()
-    
-    # Process chunks in sequence for better timing accuracy
     current_index = 1
-    for chunk in chunks:
-        srt_content, audio_content = await process_chunk_parallel(
-            chunk, current_index, voice, rate, pitch
-        )
+    
+    # Process chunks in parallel but maintain sequential timing
+    chunk_tasks = []
+    for i, chunk in enumerate(chunks):
+        start_idx = current_index + (i * chunk_size)
+        task = process_chunk_parallel(chunk, start_idx, voice, rate, pitch, timing_mgr)
+        chunk_tasks.append(task)
+    
+    # Gather results in order
+    chunk_results = await asyncio.gather(*chunk_tasks)
+    
+    # Combine results
+    for srt_content, audio_content in chunk_results:
         final_srt += srt_content
         final_audio += audio_content
-        current_index += len(chunk)
     
     # Export final files
     unique_id = uuid.uuid4()