Update app.py

app.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from moviepy.editor import VideoFileClip, AudioFileClip, TextClip, CompositeVideoClip
+from moviepy.editor import VideoFileClip, AudioFileClip, TextClip, CompositeVideoClip, concatenate_audioclips
 import whisper
 from translate import Translator
 from gtts import gTTS
@@ -7,20 +7,17 @@ import tempfile
 import os
 import numpy as np
 from datetime import timedelta
-import json
-from indic_transliteration import sanscript
-from indic_transliteration.sanscript import transliterate
-import azure.cognitiveservices.speech as speechsdk
-import ffmpeg
+import shutil
+from pathlib import Path
 
 # Set page configuration
 st.set_page_config(
-    page_title="translate",
+    page_title="Tamil Movie Dubber",
     page_icon="🎬",
     layout="wide"
 )
 
-# Custom CSS to improve the interface
+# Custom CSS
 st.markdown("""
     <style>
     .stButton>button {
@@ -36,7 +33,7 @@ st.markdown("""
     </style>
     """, unsafe_allow_html=True)
 
-# Tamil-specific voice configurations
+# Tamil voice configurations
 TAMIL_VOICES = {
     'Female 1': {'name': 'ta-IN-PallaviNeural', 'style': 'normal'},
     'Female 2': {'name': 'ta-IN-PallaviNeural', 'style': 'formal'},
@@ -66,37 +63,36 @@ def load_whisper_model():
     """Load Whisper model with caching"""
     return whisper.load_model("base")
 
-class TamilDubber:
+class VideoProcessor:
     def __init__(self):
+        self.temp_dir = Path(tempfile.mkdtemp())
         self.whisper_model = load_whisper_model()
-        self.temp_dir = tempfile.mkdtemp()
-        
-    def create_temp_file(self, suffix):
-        """Create a temporary file in the temp directory"""
-        return os.path.join(self.temp_dir, f"temp_{os.urandom(8).hex()}{suffix}")
+
+    def create_temp_path(self, suffix):
+        """Create a temporary file path"""
+        return str(self.temp_dir / f"temp_{os.urandom(4).hex()}{suffix}")
 
     def cleanup(self):
-        """Clean up temporary files"""
-        import shutil
+        """Clean up temporary directory"""
         try:
             shutil.rmtree(self.temp_dir)
         except Exception as e:
             st.warning(f"Cleanup warning: {e}")
 
-    def extract_audio(self, video_path):
-        """Extract audio and transcribe using Whisper"""
+    def transcribe_video(self, video_path):
+        """Transcribe video audio using Whisper"""
         try:
-            video = VideoFileClip(video_path)
-            audio_path = self.create_temp_file(".wav")
-            video.audio.write_audiofile(audio_path, fps=16000)
-            
-            # Transcribe using Whisper
-            result = self.whisper_model.transcribe(audio_path)
-            return result["segments"], video.duration
-            
+            with VideoFileClip(video_path) as video:
+                # Extract audio to temporary file
+                audio_path = self.create_temp_path(".wav")
+                video.audio.write_audiofile(audio_path, fps=16000, verbose=False, logger=None)
+                
+                # Transcribe using Whisper
+                result = self.whisper_model.transcribe(audio_path)
+                return result["segments"], video.duration
+                
         except Exception as e:
-            st.error(f"Error in audio extraction: {e}")
-            raise
+            raise Exception(f"Transcription error: {str(e)}")
 
     def translate_segments(self, segments):
         """Translate segments to Tamil"""
@@ -124,128 +120,173 @@ class TamilDubber:
                     "end": segment["end"],
                     "duration": segment["end"] - segment["start"]
                 })
-                
+        
         return translated_segments
 
-    def generate_audio(self, text, voice_style="normal"):
+    def generate_tamil_audio(self, text):
         """Generate Tamil audio using gTTS"""
         try:
-            temp_path = self.create_temp_file(".mp3")
+            audio_path = self.create_temp_path(".mp3")
             tts = gTTS(text=text, lang='ta', slow=False)
-            tts.save(temp_path)
-            return temp_path
+            tts.save(audio_path)
+            return audio_path
         except Exception as e:
-            st.error(f"Error in audio generation: {e}")
-            raise
+            raise Exception(f"Audio generation error: {str(e)}")
 
-    def create_subtitles(self, segments, output_path):
-        """Generate SRT subtitles"""
-        try:
-            with open(output_path, 'w', encoding='utf-8') as f:
-                for idx, segment in enumerate(segments, 1):
-                    start_time = str(timedelta(seconds=int(segment["start"])))
-                    end_time = str(timedelta(seconds=int(segment["end"])))
-                    f.write(f"{idx}\n")
-                    f.write(f"{start_time} --> {end_time}\n")
-                    f.write(f"{segment['text']}\n\n")
-        except Exception as e:
-            st.error(f"Error creating subtitles: {e}")
-            raise
+    def create_subtitle_clip(self, txt, fontsize, color, size):
+        """Create a subtitle clip"""
+        return TextClip(
+            txt=txt,
+            fontsize=fontsize,
+            color=color,
+            bg_color='rgba(0,0,0,0.5)',
+            size=size,
+            method='caption'
+        )
+
+def process_video(video_data, voice_type, generate_subtitles=True, subtitle_size=24, subtitle_color='white'):
+    """Main video processing function"""
+    processor = VideoProcessor()
+    
+    try:
+        # Save uploaded video to temporary file
+        input_path = processor.create_temp_path(".mp4")
+        with open(input_path, "wb") as f:
+            f.write(video_data)
+
+        # Load video
+        video = VideoFileClip(input_path)
+        
+        # Create progress tracking
+        progress_text = st.empty()
+        progress_bar = st.progress(0)
+        
+        # Step 1: Transcribe
+        progress_text.text("Transcribing video...")
+        segments, duration = processor.transcribe_video(input_path)
+        progress_bar.progress(0.25)
+        
+        # Step 2: Translate
+        progress_text.text("Translating to Tamil...")
+        translated_segments = processor.translate_segments(segments)
+        progress_bar.progress(0.50)
+        
+        # Step 3: Generate audio
+        progress_text.text("Generating Tamil audio...")
+        subtitle_clips = []
+        audio_clips = []
+        
+        for i, segment in enumerate(translated_segments):
+            # Generate audio
+            audio_path = processor.generate_tamil_audio(segment["text"])
+            audio_clip = AudioFileClip(audio_path)
+            audio_clips.append(audio_clip.set_start(segment["start"]))
+            
+            # Create subtitle if enabled
+            if generate_subtitles:
+                subtitle_clip = processor.create_subtitle_clip(
+                    segment["text"],
+                    subtitle_size,
+                    subtitle_color,
+                    (video.w, None)
+                )
+                subtitle_clip = (subtitle_clip
+                               .set_position(('center', 'bottom'))
+                               .set_start(segment["start"])
+                               .set_duration(segment["duration"]))
+                subtitle_clips.append(subtitle_clip)
+            
+            progress_bar.progress(0.50 + (0.4 * (i + 1) / len(translated_segments)))
+        
+        # Step 4: Combine everything
+        progress_text.text("Creating final video...")
+        
+        # Combine audio clips
+        final_audio = CompositeVideoClip([*audio_clips])
+        
+        # Create final video
+        if generate_subtitles:
+            final_video = CompositeVideoClip([video, *subtitle_clips])
+        else:
+            final_video = video
+        
+        # Set audio
+        final_video = final_video.set_audio(final_audio)
+        
+        # Write final video
+        output_path = processor.create_temp_path(".mp4")
+        final_video.write_videofile(
+            output_path,
+            codec='libx264',
+            audio_codec='aac',
+            temp_audiofile=processor.create_temp_path(".m4a"),
+            remove_temp=True,
+            verbose=False,
+            logger=None
+        )
+        
+        progress_bar.progress(1.0)
+        progress_text.text("Processing complete!")
+        
+        return output_path
+        
+    except Exception as e:
+        raise Exception(f"Video processing error: {str(e)}")
+        
+    finally:
+        # Cleanup
+        processor.cleanup()
 
 def main():
     st.title("Tamil Movie Dubbing System")
     st.markdown("""
-    👋 Welcome to the Tamil Movie Dubbing System! This tool helps you:
+    👋 Welcome! This tool helps you:
     - 🎥 Convert English videos to Tamil
     - 🗣️ Generate Tamil voiceovers
     - 📝 Add Tamil subtitles
     """)
     
-    st.sidebar.header("டப்பிங் அமைப்புகள்")  # Dubbing Settings in Tamil
-
-    # File uploader with clear instructions
-    st.info("Please upload a video file (MP4, MOV, or AVI format)")
+    # File uploader
     video_file = st.file_uploader("Upload Video File", type=['mp4', 'mov', 'avi'])
     
     if not video_file:
-        st.warning("Please upload a video to begin the dubbing process.")
+        st.warning("Please upload a video to begin.")
         return
-
-    # Settings in sidebar
-    with st.sidebar:
-        st.subheader("Voice Settings")
+    
+    # Settings
+    col1, col2 = st.columns(2)
+    
+    with col1:
         voice_type = st.selectbox("Select Voice", list(TAMIL_VOICES.keys()))
+    
+    with col2:
+        generate_subtitles = st.checkbox("Generate Subtitles", value=True)
         
-        st.subheader("Subtitle Settings")
-        generate_subtitles = st.checkbox("Generate Tamil Subtitles", value=True)
-        if generate_subtitles:
+    if generate_subtitles:
+        col3, col4 = st.columns(2)
+        with col3:
             subtitle_size = st.slider("Subtitle Size", 16, 32, 24)
+        with col4:
             subtitle_color = st.color_picker("Subtitle Color", "#FFFFFF")
-
-    # Main process
-    if st.button("Start Tamil Dubbing"):
+    
+    # Process video
+    if st.button("Start Dubbing"):
         try:
-            dubber = TamilDubber()
-            
-            # Create progress containers
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            try:
-                # Save uploaded video
-                temp_video_path = dubber.create_temp_file(".mp4")
-                with open(temp_video_path, "wb") as f:
-                    f.write(video_file.read())
-
-                # Extract audio and transcribe
-                status_text.text("📥 Extracting audio and transcribing...")
-                segments, video_duration = dubber.extract_audio(temp_video_path)
-                progress_bar.progress(0.25)
-
-                # Translate segments
-                status_text.text("🔄 Translating to Tamil...")
-                translated_segments = dubber.translate_segments(segments)
-                progress_bar.progress(0.50)
-
-                # Generate Tamil audio
-                status_text.text("🔊 Generating Tamil audio...")
-                video = VideoFileClip(temp_video_path)
+            with st.spinner("Processing video..."):
+                output_path = process_video(
+                    video_file.read(),
+                    voice_type,
+                    generate_subtitles,
+                    subtitle_size if generate_subtitles else 24,
+                    subtitle_color if generate_subtitles else 'white'
+                )
                 
-                audio_segments = []
-                for idx, segment in enumerate(translated_segments):
-                    audio_path = dubber.generate_audio(segment["text"])
-                    audio_segments.append({
-                        "audio": AudioFileClip(audio_path),
-                        "start": segment["start"]
-                    })
-                    progress_bar.progress(0.50 + (0.25 * (idx + 1) / len(translated_segments)))
-
-                # Create final video
-                status_text.text("🎬 Creating final video...")
-                output_path = dubber.create_temp_file(".mp4")
+                # Show success message
+                st.success("டப்பிங் வெற்றிகரமாக முடிந்தது!")
                 
-                # Add subtitles if enabled
-                if generate_subtitles:
-                    srt_path = dubber.create_temp_file(".srt")
-                    dubber.create_subtitles(translated_segments, srt_path)
-                    
-                    # Use ffmpeg to add subtitles
-                    stream = ffmpeg.input(temp_video_path)
-                    stream = ffmpeg.output(stream, output_path, 
-                                        vf=f'subtitles={srt_path}:force_style=\'FontSize={subtitle_size},PrimaryColour={subtitle_color}\'',
-                                        acodec='aac')
-                    ffmpeg.run(stream, overwrite_output=True)
-                else:
-                    # Just copy the video if no subtitles
-                    video.write_videofile(output_path)
-
-                progress_bar.progress(1.0)
-                status_text.text("✅ Dubbing completed!")
-
-                # Display result
-                st.success("டப்பிங் வெற்றிகரமாக முடிந்தது!")  # Dubbing completed successfully in Tamil
+                # Display video
                 st.video(output_path)
-
+                
                 # Download button
                 with open(output_path, "rb") as f:
                     st.download_button(
@@ -254,14 +295,10 @@ def main():
                         file_name="tamil_dubbed_video.mp4",
                         mime="video/mp4"
                     )
-
-            finally:
-                # Cleanup
-                dubber.cleanup()
                 
         except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-            st.error("Please try again with a different video or check if the video format is supported.")
+            st.error(f"Processing failed: {str(e)}")
+            st.error("Please try uploading a different video or check if the format is supported.")
 
 if __name__ == "__main__":
     main()