Update app.py

app.py

@@ -1,16 +1,16 @@
 import gradio as gr
 import os
 import tempfile
-import moviepy.editor as mp
+import subprocess
 import assemblyai as aai
 from deep_translator import GoogleTranslator
 import pysrt
-from gtts import gTTS
-from pydub import AudioSegment
 import logging
 import sys
+import shutil
+from pathlib import Path
 
-# Set up logging to debug issues
+# Set up logging
 logging.basicConfig(level=logging.INFO, 
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                    stream=sys.stdout)
@@ -27,59 +27,83 @@ LANGUAGES = {
     "Hindi": "hi"
 }
 
-def extract_audio(video_path, output_dir):
+# Create a permanent output directory
+OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "outputs")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def extract_audio(video_path):
+    """Extract audio from video file using ffmpeg"""
     try:
-        logger.info(f"Loading video from: {video_path}")
-        video = mp.VideoFileClip(video_path)
-        logger.info(f"Video duration: {video.duration} seconds")
+        logger.info(f"Extracting audio from video: {video_path}")
+        audio_path = os.path.join(OUTPUT_DIR, "audio.wav")
+        
+        # Use ffmpeg to extract audio
+        cmd = [
+            'ffmpeg',
+            '-i', video_path,
+            '-vn',  # No video
+            '-acodec', 'pcm_s16le',  # PCM format
+            '-ar', '44100',  # Sample rate
+            '-ac', '2',  # Stereo
+            '-y',  # Overwrite output file
+            audio_path
+        ]
+        
+        logger.info(f"Running command: {' '.join(cmd)}")
+        process = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if process.returncode != 0:
+            logger.error(f"Audio extraction failed: {process.stderr}")
+            raise Exception(f"Audio extraction failed: {process.stderr}")
         
-        audio_path = os.path.join(output_dir, "audio.wav")
-        logger.info(f"Extracting audio to: {audio_path}")
-        video.audio.write_audiofile(audio_path, logger=None)
         return audio_path
     except Exception as e:
         logger.error(f"Audio extraction failed: {str(e)}", exc_info=True)
         raise Exception(f"Audio extraction failed: {str(e)}")
 
-def generate_subtitles(audio_path, output_dir):
+def generate_subtitles(audio_path):
+    """Generate subtitles using AssemblyAI"""
     try:
-        logger.info(f"Transcribing audio with AssemblyAI")
+        logger.info(f"Transcribing audio with AssemblyAI: {audio_path}")
         transcriber = aai.Transcriber()
         transcript = transcriber.transcribe(audio_path)
         
-        srt_path = os.path.join(output_dir, "subtitles.srt")
+        srt_path = os.path.join(OUTPUT_DIR, "subtitles.srt")
         logger.info(f"Saving subtitles to: {srt_path}")
+        
         with open(srt_path, "w", encoding="utf-8") as f:
             f.write(transcript.export_subtitles_srt())
+            
         return srt_path
     except Exception as e:
         logger.error(f"Subtitle generation failed: {str(e)}", exc_info=True)
         raise Exception(f"Subtitle generation failed: {str(e)}")
 
-def translate_subtitles(srt_path, target_langs, output_dir):
+def translate_subtitles(srt_path, target_langs):
+    """Translate subtitles to target languages"""
     try:
         logger.info(f"Loading subtitles from: {srt_path}")
         subs = pysrt.open(srt_path, encoding="utf-8")
         results = {}
         
-        for lang in target_langs:
-            logger.info(f"Translating to language: {lang}")
+        for lang_code in target_langs:
+            logger.info(f"Translating to language code: {lang_code}")
             translated_subs = subs[:]
-            translator = GoogleTranslator(source="auto", target=lang)
+            translator = GoogleTranslator(source="auto", target=lang_code)
             
             for i, sub in enumerate(translated_subs):
                 try:
                     sub.text = translator.translate(sub.text)
                     if i % 10 == 0:  # Log progress every 10 subtitles
-                        logger.info(f"Translated {i+1}/{len(translated_subs)} subtitles to {lang}")
+                        logger.info(f"Translated {i+1}/{len(translated_subs)} subtitles to {lang_code}")
                 except Exception as e:
                     logger.warning(f"Failed to translate subtitle: {sub.text}. Error: {str(e)}")
                     # Keep original text if translation fails
             
-            output_path = os.path.join(output_dir, f"subtitles_{lang}.srt")
+            output_path = os.path.join(OUTPUT_DIR, f"subtitles_{lang_code}.srt")
             logger.info(f"Saving translated subtitles to: {output_path}")
             translated_subs.save(output_path, encoding='utf-8')
-            results[lang] = output_path
+            results[lang_code] = output_path
             
         return results
     except Exception as e:
@@ -87,19 +111,22 @@ def translate_subtitles(srt_path, target_langs, output_dir):
         raise Exception(f"Translation failed: {str(e)}")
 
 def add_subtitles_ffmpeg(video_path, srt_path, output_path):
-    """Alternative method to add subtitles using ffmpeg directly"""
+    """Add subtitles to video using ffmpeg"""
     try:
-        import subprocess
-        
-        logger.info(f"Adding subtitles using ffmpeg")
+        logger.info(f"Adding subtitles to video using ffmpeg")
         cmd = [
             'ffmpeg',
-            '-i', video_path,
-            '-i', srt_path,
-            '-c:v', 'copy',
-            '-c:a', 'copy',
-            '-c:s', 'mov_text',
-            '-metadata:s:s:0', 'language=eng',
+            '-i', video_path,           # Input video
+            '-f', 'srt',                # SRT format
+            '-i', srt_path,             # Input subtitles
+            '-map', '0:v',              # Map video from first input
+            '-map', '0:a',              # Map audio from first input
+            '-map', '1',                # Map subtitles from second input
+            '-c:v', 'copy',             # Copy video codec
+            '-c:a', 'copy',             # Copy audio codec
+            '-c:s', 'mov_text',         # Use mov_text codec for subtitles
+            '-metadata:s:s:0', 'language=eng',  # Set subtitle language
+            '-y',                       # Overwrite output file
             output_path
         ]
         
@@ -108,75 +135,93 @@ def add_subtitles_ffmpeg(video_path, srt_path, output_path):
         
         if process.returncode != 0:
             logger.error(f"ffmpeg error: {process.stderr}")
-            raise Exception(f"ffmpeg error: {process.stderr}")
+            
+            # If subtitle embedding fails, try burning subtitles into video
+            logger.info("Attempting to burn subtitles into video")
+            cmd = [
+                'ffmpeg',
+                '-i', video_path,           # Input video
+                '-vf', f"subtitles='{srt_path}'",  # Burn subtitles into video
+                '-c:a', 'copy',             # Copy audio codec
+                '-y',                       # Overwrite output file
+                output_path
+            ]
+            
+            logger.info(f"Running fallback command: {' '.join(cmd)}")
+            process = subprocess.run(cmd, capture_output=True, text=True)
+            
+            if process.returncode != 0:
+                logger.error(f"Subtitle burning failed: {process.stderr}")
+                raise Exception(f"Failed to add subtitles: {process.stderr}")
         
         return output_path
     except Exception as e:
-        logger.error(f"ffmpeg subtitle merge failed: {str(e)}", exc_info=True)
-        raise Exception(f"ffmpeg subtitle merge failed: {str(e)}")
+        logger.error(f"Subtitle addition failed: {str(e)}", exc_info=True)
+        raise Exception(f"Subtitle addition failed: {str(e)}")
 
 def process_video(video_file, source_lang, target_langs, progress=gr.Progress()):
-    with tempfile.TemporaryDirectory() as tmpdir:
+    """Process video with translation"""
+    try:
+        progress(0.1, "Starting processing...")
+        logger.info(f"Processing video: {video_file}")
+        
+        # Make sure we have ffmpeg installed
         try:
-            logger.info(f"Starting video processing in temp dir: {tmpdir}")
-            
-            progress(0.1, "Extracting audio...")
-            audio_path = extract_audio(video_file, tmpdir)
-            
-            progress(0.3, "Generating subtitles...")
-            srt_path = generate_subtitles(audio_path, tmpdir)
-            
-            progress(0.5, "Translating subtitles...")
-            translated_subs = translate_subtitles(
-                srt_path, 
-                [LANGUAGES[lang] for lang in target_langs],
-                tmpdir
-            )
-            
-            progress(0.7, "Generating outputs...")
-            output_files = []
+            subprocess.run(['ffmpeg', '-version'], capture_output=True, check=True)
+            logger.info("ffmpeg is installed and working")
+        except (subprocess.SubprocessError, FileNotFoundError):
+            error_msg = "ffmpeg is not installed or not in PATH. Please install ffmpeg."
+            logger.error(error_msg)
+            return None, error_msg
+        
+        # Extract audio
+        progress(0.2, "Extracting audio...")
+        audio_path = extract_audio(video_file)
+        
+        # Generate subtitles
+        progress(0.4, "Generating subtitles...")
+        srt_path = generate_subtitles(audio_path)
+        
+        # Translate subtitles
+        progress(0.6, "Translating subtitles...")
+        target_lang_codes = [LANGUAGES[lang] for lang in target_langs]
+        translated_subs = translate_subtitles(srt_path, target_lang_codes)
+        
+        # Add subtitles to video for each language
+        progress(0.8, "Creating output videos...")
+        output_videos = []
+        
+        # Create a copy of the video file in our output directory first
+        base_video = os.path.join(OUTPUT_DIR, "base_video.mp4")
+        shutil.copy(video_file, base_video)
+        
+        for lang_code, sub_path in translated_subs.items():
+            output_path = os.path.join(OUTPUT_DIR, f"output_{lang_code}.mp4")
+            logger.info(f"Adding {lang_code} subtitles to video: {output_path}")
             
-            for lang, sub_path in translated_subs.items():
-                output_path = os.path.join(tmpdir, f"output_{lang}.mp4")
-                logger.info(f"Creating output video with {lang} subtitles at: {output_path}")
+            try:
+                output_video = add_subtitles_ffmpeg(base_video, sub_path, output_path)
                 
-                # Try ffmpeg method first
-                try:
-                    add_subtitles_ffmpeg(video_file, sub_path, output_path)
-                    
-                    # Verify the output file exists and has content
-                    if os.path.exists(output_path) and os.path.getsize(output_path) > 1000:
-                        output_files.append(output_path)
-                        logger.info(f"Successfully created output file: {output_path}")
-                    else:
-                        logger.warning(f"Output file is missing or too small: {output_path}")
-                        raise Exception("Output file verification failed")
-                except Exception as e:
-                    logger.error(f"ffmpeg method failed: {str(e)}", exc_info=True)
-                    
-                    # If ffmpeg fails, create a copy of the original video as a fallback
-                    logger.info("Using fallback method: copying original video")
-                    import shutil
-                    fallback_path = os.path.join(tmpdir, f"fallback_{lang}.mp4")
-                    shutil.copy(video_file, fallback_path)
-                    output_files.append(fallback_path)
-            
-            if not output_files:
-                raise Exception("No output files were generated")
+                # Verify the output file exists and has content
+                if os.path.exists(output_video) and os.path.getsize(output_video) > 1000:
+                    logger.info(f"Successfully created output file: {output_video}")
+                    output_videos.append(output_video)
+                else:
+                    logger.warning(f"Output file is missing or too small: {output_video}")
+            except Exception as e:
+                logger.error(f"Failed to create video with {lang_code} subtitles: {str(e)}")
                 
-            progress(1.0, "Done!")
+        # If all output videos failed, return the original
+        if not output_videos:
+            logger.warning("All subtitle additions failed, returning original video")
+            output_videos = [base_video]
             
-            # Copy the file to a location outside the temp directory to prevent it from being deleted
-            final_output = os.path.join(os.path.dirname(video_file), "translated_video.mp4")
-            import shutil
-            shutil.copy(output_files[0], final_output)
-            logger.info(f"Final output saved to: {final_output}")
-            
-            return final_output
-            
-        except Exception as e:
-            logger.error(f"Processing failed: {str(e)}", exc_info=True)
-            raise gr.Error(f"Processing failed: {str(e)}")
+        progress(1.0, "Done!")
+        return output_videos[0], f"Processing complete. Video saved to: {output_videos[0]}"
+        
+    except Exception as e:
+        logger.error(f"Processing failed: {str(e)}", exc_info=True)
+        return None, f"Processing failed: {str(e)}"
 
 with gr.Blocks() as demo:
     gr.Markdown("# Video Translation System")