Update app.py

app.py

@@ -23,17 +23,21 @@ def format_time(seconds):
 # Function to split text into segments by punctuation or limit to 7-8 words
 def split_text_into_segments(text):
     segments = []
+    # Split by punctuation (., !, ?)
     raw_segments = re.split(r'([.!?])', text)
     for i in range(0, len(raw_segments) - 1, 2):
+        # Combine segment with following punctuation
         sentence = raw_segments[i].strip() + raw_segments[i + 1]
         words = sentence.split()
         
+        # If segment is longer than 8 words, split into 7-8 word chunks
         if len(words) > 8:
             for j in range(0, len(words), 8):
                 segments.append(" ".join(words[j:j+8]))
         else:
             segments.append(sentence.strip())
     
+    # Handle remaining text after the last punctuation
     if len(raw_segments) % 2 == 1:
         remaining_text = raw_segments[-1].strip()
         words = remaining_text.split()
@@ -43,22 +47,27 @@ def split_text_into_segments(text):
     return segments
 
 # Function to generate SRT with accurate timing per batch and cross-check timing
-async def generate_accurate_srt(batch_text, batch_num, start_offset, pitch, voice, rate):
+async def generate_accurate_srt(batch_text, batch_num, start_offset, pitch, rate, voice):
     audio_file = f"batch_{batch_num}_audio.wav"
     
     # Generate the audio using edge-tts with pitch and rate adjustment
     tts = edge_tts.Communicate(batch_text, voice, rate=f"{rate}%", pitch=f"{pitch}Hz")
     await tts.save(audio_file)
 
+    # Get the actual length of the audio file
     actual_length = get_audio_length(audio_file)
+
+    # Split the text into segments based on punctuation and word count
     segments = split_text_into_segments(batch_text)
-    segment_duration = actual_length / len(segments)
+    segment_duration = actual_length / len(segments)  # Duration per segment
     start_time = start_offset
 
+    # Initialize SRT content
     srt_content = ""
     for index, segment in enumerate(segments):
         end_time = start_time + segment_duration
         
+        # If end_time exceeds actual audio length of the batch, adjust it
         if end_time > start_offset + actual_length:
             end_time = start_offset + actual_length
 
@@ -66,28 +75,35 @@ async def generate_accurate_srt(batch_text, batch_num, start_offset, pitch, voic
         srt_content += f"{format_time(start_time)} --> {format_time(end_time)}\n"
         srt_content += segment + "\n\n"
         
+        # Update start time for next segment
         start_time = end_time
 
-    return srt_content, audio_file, start_time
+    return srt_content, audio_file, start_time  # Return updated start time for cumulative tracking
 
 # Batch processing function with cumulative timing, progress indicator, and final SRT validation
-async def batch_process_srt_and_audio(script_text, pitch, voice, rate, progress=gr.Progress()):
+async def batch_process_srt_and_audio(script_text, pitch, rate, voice, progress=gr.Progress()):
     batches = [script_text[i:i+500] for i in range(0, len(script_text), 500)]
     all_srt_content = ""
     combined_audio = AudioSegment.empty()
-    start_offset = 0.0
+    start_offset = 0.0  # Track cumulative time offset for SRT timing
 
+    # Process each batch sequentially to ensure proper timing and cumulative offset tracking
     for batch_num, batch_text in enumerate(batches):
-        srt_content, audio_file, end_offset = await generate_accurate_srt(batch_text, batch_num, start_offset, pitch, voice, rate)
+        srt_content, audio_file, end_offset = await generate_accurate_srt(batch_text, batch_num, start_offset, pitch, rate, voice)
         all_srt_content += srt_content
 
+        # Append the audio of each batch to the combined audio
         batch_audio = AudioSegment.from_file(audio_file)
         combined_audio += batch_audio
-        start_offset = end_offset
+        start_offset = end_offset  # Update the start offset for the next batch
 
+        # Clean up the individual batch audio file
         os.remove(audio_file)
+
+        # Update progress
         progress((batch_num + 1) / len(batches))
 
+    # Final cross-check: Adjust any subtitle that exceeds the total audio length
     total_audio_length = combined_audio.duration_seconds
     validated_srt_content = ""
     for line in all_srt_content.strip().splitlines():
@@ -100,50 +116,42 @@ async def batch_process_srt_and_audio(script_text, pitch, voice, rate, progress=
             line = f"{format_time(start_time)} --> {format_time(end_time)}"
         validated_srt_content += line + "\n"
 
+    # Generate unique names for the final files
     unique_id = uuid.uuid4()
-    final_audio_path = f"final_audio_{unique_id}.mp3"
+    final_audio_path = f"final_audio_{unique_id}.mp3"  # Set to MP3
     final_srt_path = f"final_subtitles_{unique_id}.srt"
 
+    # Export combined audio directly as MP3 with 320 kbps bitrate
     combined_audio.export(final_audio_path, format="mp3", bitrate="320k")
 
+    # Export validated SRT with unique names
     with open(final_srt_path, "w") as srt_file:
         srt_file.write(validated_srt_content)
 
     return final_srt_path, final_audio_path
 
 # Gradio interface function
-async def process_script(script_text, pitch, voice, rate):
-    srt_path, audio_path = await batch_process_srt_and_audio(script_text, pitch, voice, rate)
+async def process_script(script_text, pitch, rate, voice):
+    srt_path, audio_path = await batch_process_srt_and_audio(script_text, pitch, rate, voice)
     return srt_path, audio_path, audio_path
 
-# List of available voices
-voices = {
-    "Jenny": "en-US-JennyNeural",
-    "Guy": "en-US-GuyNeural",
-    "Ana": "en-US-AnaNeural",
-    "Aria": "en-US-AriaNeural",
-    "Brian": "en-US-BrianNeural",
-    "Christopher": "en-US-ChristopherNeural",
-    "Eric": "en-US-EricNeural",
-    "Michelle": "en-US-MichelleNeural",
-    "Roger": "en-US-RogerNeural",
-}
-
-# Gradio interface setup with voice selection and speech rate adjustment
+# Gradio interface setup with pitch adjustment slider, rate adjustment slider, and voice selection
+voice_options = ["en-US-AndrewNeural", "en-US-JennyNeural", "en-US-GuyNeural"]  # Example voice options
+
 app = gr.Interface(
     fn=process_script,
     inputs=[
         gr.Textbox(label="Enter Script Text", lines=10),
-        gr.Dropdown(label="Select Voice", choices=list(voices.keys()), value="Jenny"),
-        gr.Slider(label="Speech Rate Adjustment (%)", minimum=0, maximum=2, step=0.1, value=1),
-        gr.Slider(label="Pitch Adjustment (Hz)", minimum=-100, maximum=100, step=1, value=1)
+        gr.Slider(label="Pitch Adjustment (Hz)", minimum=-100, maximum=100, step=1, value=0),
+        gr.Slider(label="Rate Adjustment (%)", minimum=-100, maximum=100, step=1, value=0),
+        gr.Dropdown(label="Select Speaker", choices=voice_options, value=voice_options[0])  # Dropdown for voice selection
     ],
     outputs=[
         gr.File(label="Download SRT File"),
         gr.File(label="Download Audio File"),
         gr.Audio(label="Play Audio")
     ],
-    description="HIVEcorp TTS Generator with customizable voice, speech rate, and pitch adjustments."
+    description="HIVEcorp TTS Generator with adjustable pitch, rate, and speaker selection."
 )
 
 app.launch()