Update app.py

app.py

@@ -392,48 +392,59 @@ def process_entry(entry, i, video_width, video_height, add_voiceover, target_lan
             audio_segment = None
 
     return i, txt_clip, audio_segment, error_message
+def add_transcript_voiceover(video_path, translated_json, output_path, add_voiceover=False, target_language="en", speaker_sample_paths=None):
+    video = VideoFileClip(video_path)
+    font_path = "./NotoSansSC-Regular.ttf"
 
-def process_entry(entry, i, video_width, video_height, add_voiceover, target_language, font_path, speaker_sample_paths=None):
-    logger.debug(f"Processing entry {i}: {entry}")
-    error_message = None
-
-    try:
-        txt_clip = create_subtitle_clip_pil(entry["translated"], entry["start"], entry["end"], video_width, video_height, font_path)
-    except Exception as e:
-        error_message = f"❌ Failed to create subtitle clip for entry {i}: {e}"
-        logger.error(error_message)
-        txt_clip = None
+    text_clips = []
+    audio_segments = []
+    error_messages = []
 
-    audio_segment = None
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [executor.submit(process_entry, entry, i, video.w, video.h, add_voiceover, target_language, font_path, speaker_sample_paths)
+                   for i, entry in enumerate(translated_json)]
+
+        results = []
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                i, txt_clip, audio_segment, error = future.result()
+                results.append((i, txt_clip, audio_segment))
+                if error:
+                    error_messages.append(f"[Entry {i}] {error}")
+            except Exception as e:
+                err = f"❌ Unexpected error in future result: {e}"
+                logger.error(err)
+                error_messages.append(err)
+
+    # Sort by entry index to ensure order
+    results.sort(key=lambda x: x[0])
+    text_clips = [clip for _, clip, _ in results if clip]
     if add_voiceover:
-        try:
-            segment_audio_path = f"segment_{i}_voiceover.wav"
-            desired_duration = entry["end"] - entry["start"]
-            speaker = entry.get("speaker", "default")
-            speaker_wav_path = f"speaker_{speaker}_sample.wav"
-
-            generate_voiceover_clone([entry], desired_duration, target_language, speaker_wav_path, segment_audio_path)
+        audio_segments = [segment for _, _, segment in results if segment]
 
-            if not os.path.exists(segment_audio_path):
-                raise FileNotFoundError(f"Voiceover file not generated at: {segment_audio_path}")
-
-            audio_clip = AudioFileClip(segment_audio_path)
-            logger.debug(f"Audio clip duration: {audio_clip.duration}, Desired duration: {desired_duration}")
-
-            if audio_clip.duration < desired_duration:
-                silence_duration = desired_duration - audio_clip.duration
-                audio_clip = concatenate_audioclips([audio_clip, silence(duration=silence_duration)])
-                logger.info(f"Padded audio with {silence_duration} seconds of silence.")
+    final_video = CompositeVideoClip([video] + text_clips)
 
-            audio_segment = audio_clip.set_start(entry["start"]).set_duration(desired_duration)
-
-        except Exception as e:
-            err = f"❌ Failed to generate audio segment for entry {i}: {e}"
-            logger.error(err)
-            error_message = error_message + " | " + err if error_message else err
-            audio_segment = None
-
-    return i, txt_clip, audio_segment, error_message
+    if add_voiceover:
+        if audio_segments:
+            final_audio = CompositeAudioClip(audio_segments).set_duration(video.duration)
+            final_video = final_video.set_audio(final_audio)
+        else:
+            logger.warning("⚠️ No audio segments available. Adding silent fallback.")
+            silent_audio = AudioClip(lambda t: 0, duration=video.duration)
+            final_video = final_video.set_audio(silent_audio)
+
+    logger.info(f"Saving the final video to: {output_path}")
+    final_video.write_videofile(output_path, codec="libx264", audio_codec="aac")
+
+    logger.info("Video processing completed successfully.")
+
+    # Optional: return errors
+    if error_messages:
+        logger.warning("⚠️ Errors encountered during processing:")
+        for msg in error_messages:
+            logger.warning(msg)
+
+    return error_messages
 
 import os
 import traceback