Update app.py

app.py

@@ -1,155 +1,65 @@
-from moviepy.editor import *
+from moviepy import *
 import pysrt
 import gradio as gr
-import traceback
-import os
-from pathlib import Path
 
-def time_to_seconds(time_obj):
-    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 time_to_seconds(time_obj):
+    return time_obj.hours * 3600 + time_obj.minutes * 60 + time_obj.seconds + time_obj.milliseconds / 1000
 
 def create_subtitle_clips(subtitles, videosize, fontsize, font, color, debug):
     subtitle_clips = []
-    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
-    
+    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))
     return subtitle_clips
 
 def video_edit(srt, input_video, color, font, font_size, input_audio):
-    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()
+    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
 
 with gr.Blocks() as demo:
-    gr.Markdown("## Video Subtitle Generator")
+    gr.Markdown("Start typing below and then click **Run** to see the progress and final output.")
     with gr.Column():
-        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
-    )
+        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
+        )
 
 demo.launch(debug=True)