Update app.py

app.py

@@ -2,13 +2,15 @@ import gradio as gr
 import edge_tts
 import asyncio
 import tempfile
+import os
 from moviepy.editor import AudioFileClip
-import re
 
+# Get all available voices
 async def get_voices():
     voices = await edge_tts.list_voices()
     return {f"{v['ShortName']} - {v['Locale']} ({v['Gender']})": v['ShortName'] for v in voices}
 
+# Text to speech functionality
 async def text_to_speech(text, voice, rate, pitch):
     if not text.strip():
         return None, gr.Warning("Please enter the text to convert.")
@@ -19,83 +21,104 @@ async def text_to_speech(text, voice, rate, pitch):
     rate_str = f"{rate:+d}%"
     pitch_str = f"{pitch:+d}Hz"
     communicate = edge_tts.Communicate(text, voice_short_name, rate=rate_str, pitch=pitch_str)
-    
     with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
         tmp_path = tmp_file.name
         await communicate.save(tmp_path)
-    
     return tmp_path, None
 
-def generate_srt(text, audio_duration, max_words_per_line):
-    # Eliminate extra spaces and split into words
-    text = re.sub(r'\s+', ' ', text.strip())
-    words = text.split()
-    srt_lines = []
-    current_line = []
-    total_words = len(words)
-    
-    for i, word in enumerate(words):
-        current_line.append(word)
-        # Create a line if we reach the max words per line or at the end of the text
-        if len(current_line) >= max_words_per_line or i == total_words - 1:
-            line_text = ' '.join(current_line)
-            # Adjust duration proportionally
-            duration = audio_duration * (len(current_line) / total_words)
-            start_time = (sum(len(' '.join(srt_lines[j].split()[2:])) for j in range(len(srt_lines))) / total_words) * audio_duration if srt_lines else 0
-            
-            end_time = start_time + duration
+# Generate SRT file with specified lines of subtitles
+def generate_srt(words, audio_duration, srt_path, num_lines):
+    with open(srt_path, 'w', encoding='utf-8') as srt_file:
+        segment_duration = audio_duration / (len(words) // (5 * num_lines))  # Average duration for each segment
+        current_time = 0
+        
+        for i in range(0, len(words), 5 * num_lines):  # Adjusting for the number of lines
+            lines = []
+            for j in range(num_lines):
+                line = ' '.join(words[i + j * 5:i + (j + 1) * 5])  # 5 words per line
+                if line:
+                    lines.append(line)
+                    
+            start_time = current_time
+            end_time = start_time + segment_duration  # Adjust duration for the current segment
             
-            # Formatting time for SRT
-            start_time_str = f"{int(start_time // 3600):02}:{int((start_time % 3600) // 60):02}:{int(start_time % 60):02},{int((start_time % 1) * 1000):03}"
-            end_time_str = f"{int(end_time // 3600):02}:{int((end_time % 3600) // 60):02}:{int(end_time % 60):02},{int((end_time % 1) * 1000):03}"
+            start_time_str = format_srt_time(start_time)
+            end_time_str = format_srt_time(end_time)
+            srt_file.write(f"{i // (5 * num_lines) + 1}\n{start_time_str} --> {end_time_str}\n" + "\n".join(lines) + "\n\n")
             
-            srt_lines.append(f"{len(srt_lines) + 1}\n{start_time_str} --> {end_time_str}\n{line_text}\n")
-            current_line = []
-    
-    return ''.join(srt_lines)
+            current_time += segment_duration  # Update current time for the next segment
+
+    return srt_path
 
-def tts_interface(text, voice, rate, pitch, max_words_per_line):
-    audio_path, warning = asyncio.run(text_to_speech(text, voice, rate, pitch))
+def format_srt_time(seconds):
+    millis = int((seconds - int(seconds)) * 1000)
+    seconds = int(seconds)
+    minutes = seconds // 60
+    hours = minutes // 60
+    minutes %= 60
+    seconds %= 60
+    return f"{hours:02}:{minutes:02}:{seconds:02},{millis:03}"
+
+# Text to audio and SRT functionality
+async def text_to_audio_and_srt(text, voice, rate, pitch, num_lines):
+    audio_path, warning = await text_to_speech(text, voice, rate, pitch)
     if warning:
         return None, None, warning
+
+    audio_clip = AudioFileClip(audio_path)
+    audio_duration = audio_clip.duration
     
-    # Calculate audio duration
-    audio_duration = AudioFileClip(audio_path).duration  # Get duration in seconds
-    
-    # Generate SRT file
-    srt_content = generate_srt(text, audio_duration, max_words_per_line)
-    srt_path = audio_path.replace('.mp3', '_subtitle.srt')
-    
-    with open(srt_path, 'w') as f:
-        f.write(srt_content)
+    # Generate SRT file based on the entire text
+    base_name = os.path.splitext(audio_path)[0]
+    srt_path = f"{base_name}_subtitle.srt"
+    words = text.split()
+    generate_srt(words, audio_duration, srt_path, num_lines)
 
     return audio_path, srt_path, None
 
+# Gradio interface function
+def tts_interface(text, voice, rate, pitch, num_lines):
+    audio_path, srt_path, warning = asyncio.run(text_to_audio_and_srt(text, voice, rate, pitch, num_lines))
+    return audio_path, srt_path, warning
+
+# Create Gradio app
 async def create_demo():
     voices = await get_voices()
     
-    demo = gr.Interface(
-        fn=tts_interface,
-        inputs=[
-            gr.Textbox(label="Input Text", lines=5),
-            gr.Dropdown(choices=[""] + list(voices.keys()), label="Select Voice", value=""),
-            gr.Slider(minimum=-50, maximum=50, value=0, label="Rate Adjustment (%)", step=1),
-            gr.Slider(minimum=-20, maximum=20, value=0, label="Pitch Adjustment (Hz)", step=1),
-            gr.Slider(minimum=3, maximum=8, value=5, label="Max Words per Line", step=1),
-        ],
-        outputs=[
-            gr.Audio(label="Generated Audio", type="filepath"),
-            gr.File(label="Generated Subtitle (.srt)"),
-            gr.Markdown(label="Warning", visible=False)
-        ],
-        title="Edge TTS Text to Speech with SRT",
-        description="Convert text to speech and generate synchronized subtitles based on speech rate.",
-        analytics_enabled=False,
-        allow_flagging=False,
-    )
-    
+    with gr.Blocks() as demo:
+        gr.Markdown(
+            """
+            <h1 style="text-align: center; color: #333;">Text to Speech with Subtitles</h1>
+            <p style="text-align: center; color: #555;">Convert your text to natural-sounding speech and generate subtitles (SRT) for your audio.</p>
+            """, 
+            elem_id="header"
+        )
+
+        with gr.Row():
+            with gr.Column():
+                text_input = gr.Textbox(label="Input Text", lines=5, placeholder="Enter text here...")
+                voice_dropdown = gr.Dropdown(choices=[""] + list(voices.keys()), label="Select Voice", value="")
+                rate_slider = gr.Slider(minimum=-50, maximum=50, value=0, label="Rate Adjustment (%)", step=1)
+                pitch_slider = gr.Slider(minimum=-20, maximum=20, value=0, label="Pitch Adjustment (Hz)", step=1)
+                
+                num_lines_slider = gr.Slider(minimum=1, maximum=5, value=2, label="Number of SRT Lines", step=1)
+                
+                generate_button = gr.Button("Generate Audio and Subtitles", variant="primary")
+
+            with gr.Column():
+                output_audio = gr.Audio(label="Generated Audio", type="filepath")
+                output_srt = gr.File(label="Generated SRT", file_count="single")
+                warning_msg = gr.Markdown(label="Warning", visible=False)
+
+        generate_button.click(
+            fn=tts_interface,
+            inputs=[text_input, voice_dropdown, rate_slider, pitch_slider, num_lines_slider],
+            outputs=[output_audio, output_srt, warning_msg]
+        )
+
     return demo
 
+# Run the app
 if __name__ == "__main__":
     demo = asyncio.run(create_demo())
     demo.launch()