Update app.py

app.py

@@ -96,11 +96,11 @@ async def process_segment(segment: str, idx: int, voice: str, rate: str, 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)
         
-        srt_content = f"{idx}\n"
-        
-        return srt_content, segment_audio, segment_duration
+        return "", segment_audio, segment_duration
     finally:
         if os.path.exists(audio_file):
             os.remove(audio_file)
@@ -118,41 +118,41 @@ async def process_chunk_parallel(chunks: List[str], start_idx: int, voice: str,
     srt_content = ""
     current_time = 0
     
-    # Fix: Use enumerate to get both index and segment content
-    for idx, (srt_part, audio_part, duration) in enumerate(results):
-        srt_content += srt_part
-        srt_content += f"{format_time_ms(current_time)} --> {format_time_ms(current_time + duration)}\n"
-        srt_content += chunks[idx] + "\n\n"  # Use the actual segment from chunks
+    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"
         
         combined_audio += audio_part
-        current_time += duration
+        # 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)
     
-    # Split segments into chunks for parallel processing
-    chunk_size = 10  # Process 10 segments at a time
+    # Process smaller chunks for better timing control
+    chunk_size = 5  # Reduced from 10 to 5 for better timing control
     chunks = [segments[i:i + chunk_size] for i in range(0, len(segments), chunk_size)]
     
     final_srt = ""
     final_audio = AudioSegment.empty()
     
-    # Process chunks in parallel
-    chunk_tasks = []
-    for i, chunk in enumerate(chunks):
-        start_idx = i * chunk_size + 1
-        task = process_chunk_parallel(chunk, start_idx, voice, rate, pitch)
-        chunk_tasks.append(task)
-    
-    # Gather results
-    chunk_results = await asyncio.gather(*chunk_tasks)
-    
-    # Combine results
-    for srt_content, audio_content in chunk_results:
+    # 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
+        )
         final_srt += srt_content
         final_audio += audio_content
+        current_index += len(chunk)
     
     # Export final files
     unique_id = uuid.uuid4()