Update app.py

app.py

@@ -1,65 +1,155 @@
-from moviepy import *
+from moviepy.editor import *
 import pysrt
 import gradio as gr
-
-
+import traceback
+import os
+from pathlib import Path
 
 def time_to_seconds(time_obj):
-    return time_obj.hours * 3600 + time_obj.minutes * 60 + time_obj.seconds + time_obj.milliseconds / 1000
+    try:
+        return time_obj.hours * 3600 + time_obj.minutes * 60 + time_obj.seconds + time_obj.milliseconds / 1000
+    except Exception as e:
+        raise ValueError(f"Invalid time format: {e}")
+
+def validate_subtitle_time(subtitles, video_duration):
+    for i, subtitle in enumerate(subtitles):
+        start = time_to_seconds(subtitle.start)
+        end = time_to_seconds(subtitle.end)
+        if start > end:
+            raise ValueError(f"Subtitle {i+1}: Start time ({start}s) exceeds end time ({end}s)")
+        if end > video_duration + 2:
+            raise ValueError(f"Subtitle {i+1}: End time ({end}s) exceeds video duration ({video_duration}s)")
 
 def create_subtitle_clips(subtitles, videosize, fontsize, font, color, debug):
     subtitle_clips = []
-    color_clips=[]
-    for subtitle in subtitles:
-        start_time = time_to_seconds(subtitle.start) # Add 2 seconds offset
-        end_time = time_to_seconds(subtitle.end)
-        duration = end_time - start_time
-        video_width, video_height = videosize
-        max_width = video_width * 0.8
-        max_height = video_height * 0.2
-        #reshaped_text = arabic_reshaper.reshape(subtitle.text)
-        #bidi_text = get_display(reshaped_text)
-        text_clip = TextClip(font, subtitle.text, font_size=fontsize, size=(int(video_width * 0.8), int(video_height * 0.2)) ,text_align="center" ,color=color, method='caption').with_start(start_time).with_duration(duration)
-        #myclip = ColorClip(size=(int(video_width * 0.8), int(video_height * 0.2)) , color=(225, 0, 0)).with_opacity(0.2).with_start(start_time).with_duration(duration)
-        subtitle_x_position = 'center'
-        subtitle_y_position = video_height * 0.68
-        text_position = (subtitle_x_position, subtitle_y_position)
-        subtitle_clips.append(text_clip.with_position(text_position))
-        #color_clips.append(myclip.with_position(text_position))
+    try:
+        font_path = f"{font}.ttf"
+        if not Path(font_path).is_file():
+            raise FileNotFoundError(f"Font file '{font_path}' not found")
+        
+        for subtitle in subtitles:
+            start_time = time_to_seconds(subtitle.start)
+            end_time = time_to_seconds(subtitle.end)
+            duration = end_time - start_time
+            
+            if duration <= 0:
+                raise ValueError(f"Invalid subtitle duration at position {subtitle.position}")
+
+            video_width, video_height = videosize
+            text_clip = TextClip(
+                subtitle.text,
+                fontsize=fontsize,
+                font=font,
+                color=color,
+                size=(int(video_width * 0.8), int(video_height * 0.2)),
+                method='caption',
+                print_cmd=debug
+            ).set_start(start_time).set_duration(duration)
+            
+            subtitle_y_position = video_height * 0.68
+            subtitle_clips.append(text_clip.set_position(('center', subtitle_y_position)))
+            
+    except Exception as e:
+        raise RuntimeError(f"Error creating subtitle clips: {str(e)}") from e
+    
     return subtitle_clips
 
 def video_edit(srt, input_video, color, font, font_size, input_audio):
-    print(input_video)
-    input_video_name = input_video.split(".mp4")[0]
-    video = VideoFileClip(input_video)
-    audio = AudioFileClip(input_audio)
-    video = video.with_audio(audio)
-    print(video)
-    output_video_file = input_video_name + '_subtitled' + ".mp4"
-    subtitles = pysrt.open(srt, encoding="utf-8")
-    subtitle_clips = create_subtitle_clips(subtitles, video.size, int(font_size), f'{font}.ttf', color, False)
-    final_video = CompositeVideoClip([video]+ subtitle_clips)
-    final_video.write_videofile(output_video_file, codec="libx264", audio_codec="aac", logger=None, preset = "faster", fps=24)
-    print('final')
-    video.close()
-    audio.close()
-    return output_video_file
+    try:
+        # Input validation
+        if not all([srt, input_video, input_audio]):
+            raise ValueError("All input files are required")
+        
+        if not os.path.exists(input_video):
+            raise FileNotFoundError(f"Video file {input_video} not found")
+        
+        if not os.path.exists(input_audio):
+            raise FileNotFoundError(f"Audio file {input_audio} not found")
+        
+        # Process files
+        input_video_name = os.path.splitext(input_video)[0]
+        output_video_file = f"{input_video_name}_subtitled.mp4"
+        
+        with VideoFileClip(input_video) as video:
+            video_duration = video.duration
+            
+            # Load subtitles
+            try:
+                subtitles = pysrt.open(srt.name, encoding='utf-8')
+            except Exception as e:
+                raise ValueError(f"Error loading SRT file: {str(e)}")
+            
+            validate_subtitle_time(subtitles, video_duration)
+            
+            # Process audio
+            with AudioFileClip(input_audio) as audio:
+                if audio.duration < video_duration:
+                    raise ValueError("Audio duration is shorter than video duration")
+                
+                video = video.set_audio(audio)
+                
+                # Create subtitles
+                subtitle_clips = create_subtitle_clips(
+                    subtitles,
+                    video.size,
+                    int(font_size),
+                    font,
+                    color,
+                    debug=False
+                )
+                
+                # Compose final video
+                final_video = CompositeVideoClip([video] + subtitle_clips)
+                
+                # Write output
+                try:
+                    final_video.write_videofile(
+                        output_video_file,
+                        codec="libx264",
+                        audio_codec="aac",
+                        preset="fast",
+                        threads=4,
+                        logger=None
+                    )
+                except Exception as e:
+                    raise RuntimeError(f"Error writing video file: {str(e)}")
+                
+        return output_video_file
+    
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        raise gr.Error(f"Processing failed: {str(e)}\n\nDebug Info:\n{error_trace}")
+    
+    finally:
+        # Cleanup resources
+        if 'final_video' in locals():
+            final_video.close()
+        if 'subtitle_clips' in locals():
+            for clip in subtitle_clips:
+                clip.close()
 
 with gr.Blocks() as demo:
-    gr.Markdown("Start typing below and then click **Run** to see the progress and final output.")
+    gr.Markdown("## Video Subtitle Generator")
     with gr.Column():
-        srt_file = gr.File()
-        video_in = gr.Video()
-        color = gr.Text()
-        font = gr.Text()
-        font_size = gr.Number()
-        audio_in = gr.Audio(type = "filepath")
-        btn = gr.Button("Create")
-        output_video = gr.Video()
-        btn.click(
-            fn=video_edit,
-            inputs=[srt_file, video_in, color, font, font_size, audio_in],
-            outputs=output_video
-        )
+        with gr.Row():
+            srt_file = gr.File(label="SRT Subtitle File", type="file")
+            video_in = gr.Video(label="Input Video", format="mp4")
+            audio_in = gr.Audio(label="Input Audio", type="filepath")
+        with gr.Row():
+            color = gr.ColorPicker(label="Text Color", value="#ffffff")
+            font = gr.Dropdown(
+                label="Font",
+                choices=["Arial", "Helvetica", "Times-New-Roman", "Courier-New"],
+                value="Arial"
+            )
+            font_size = gr.Slider(12, 72, value=32, label="Font Size")
+        btn = gr.Button("Generate Subtitled Video", variant="primary")
+        output_video = gr.Video(label="Output Video")
+    
+    btn.click(
+        fn=video_edit,
+        inputs=[srt_file, video_in, color, font, font_size, audio_in],
+        outputs=output_video
+    )
 
 demo.launch(debug=True)