Update app.py

app.py

@@ -161,25 +161,70 @@ def generate_translated_audio(srt_path, target_lang):
             audio_file = os.path.join(temp_dir, f"chunk_{i:04d}.mp3")
             
             try:
-                tts = gTTS(text=text, lang=target_lang, slow=False)
-                tts.save(audio_file)
-                audio_files.append(audio_file)
-                timings.append((start_time, end_time, duration, audio_file))
+                # Add a retry mechanism for Hindi and other potentially problematic languages
+                retry_count = 0
+                max_retries = 3
+                while retry_count < max_retries:
+                    try:
+                        # For Hindi, use slower speed which might improve reliability
+                        slow_option = target_lang == "hi" 
+                        tts = gTTS(text=text, lang=target_lang, slow=slow_option)
+                        tts.save(audio_file)
+                        break
+                    except Exception as e:
+                        retry_count += 1
+                        logger.warning(f"TTS attempt {retry_count} failed for {target_lang}: {str(e)}")
+                        time.sleep(1)  # Wait before retrying
+                        
+                        # If still failing after retries, try with shorter text
+                        if retry_count == max_retries and len(text) > 100:
+                            logger.warning(f"Trying with shortened text for {target_lang}")
+                            shortened_text = text[:100] + "..."
+                            tts = gTTS(text=shortened_text, lang=target_lang, slow=True)
+                            tts.save(audio_file)
+                
+                if os.path.exists(audio_file) and os.path.getsize(audio_file) > 0:
+                    audio_files.append(audio_file)
+                    timings.append((start_time, end_time, duration, audio_file))
+                else:
+                    logger.warning(f"Generated audio file is empty or does not exist: {audio_file}")
+                    
             except Exception as e:
                 logger.warning(f"Failed to generate TTS for: {text}. Error: {str(e)}")
         
+        # Check if we actually generated any audio files
+        if not audio_files:
+            logger.warning(f"No audio files were generated for {target_lang}")
+            # Create a silent audio file as fallback
+            silent_audio = os.path.join(OUTPUT_DIR, f"translated_audio_{target_lang}.wav")
+            silent_cmd = [
+                'ffmpeg',
+                '-f', 'lavfi',
+                '-i', f'anullsrc=r=44100:cl=stereo',
+                '-t', '180',  # 3 minutes default
+                '-q:a', '0',
+                '-y',
+                silent_audio
+            ]
+            subprocess.run(silent_cmd, capture_output=True)
+            return silent_audio
+        
         # Create a silent audio track the same length as the original video
         silence_file = os.path.join(temp_dir, "silence.wav")
-        video_duration_cmd = [
-            'ffprobe', 
-            '-v', 'error', 
-            '-show_entries', 'format=duration', 
-            '-of', 'default=noprint_wrappers=1:nokey=1', 
-            os.path.join(OUTPUT_DIR, "base_video.mp4")
-        ]
-        
-        duration_result = subprocess.run(video_duration_cmd, capture_output=True, text=True)
-        video_duration = float(duration_result.stdout.strip())
+        try:
+            video_duration_cmd = [
+                'ffprobe', 
+                '-v', 'error', 
+                '-show_entries', 'format=duration', 
+                '-of', 'default=noprint_wrappers=1:nokey=1', 
+                os.path.join(OUTPUT_DIR, "base_video.mp4")
+            ]
+            
+            duration_result = subprocess.run(video_duration_cmd, capture_output=True, text=True)
+            video_duration = float(duration_result.stdout.strip())
+        except Exception as e:
+            logger.warning(f"Could not determine video duration: {str(e)}. Using default of 180 seconds.")
+            video_duration = 180.0
         
         # Create silent audio track
         silent_cmd = [
@@ -229,68 +274,179 @@ def generate_translated_audio(srt_path, target_lang):
         
         # Run the command
         logger.info(f"Combining audio segments: {' '.join(cmd)}")
-        subprocess.run(cmd, capture_output=True)
+        process = subprocess.run(cmd, capture_output=True)
+        
+        if process.returncode != 0:
+            logger.error(f"Audio combination failed: {process.stderr}")
+            # Create a fallback silent audio as last resort
+            silent_audio = os.path.join(OUTPUT_DIR, f"translated_audio_{target_lang}.wav")
+            silent_cmd = [
+                'ffmpeg',
+                '-f', 'lavfi',
+                '-i', f'anullsrc=r=44100:cl=stereo',
+                '-t', str(video_duration),
+                '-q:a', '0',
+                '-y',
+                silent_audio
+            ]
+            subprocess.run(silent_cmd, capture_output=True)
+            output_audio = silent_audio
+        
+        # Verify the output file exists
+        if not os.path.exists(output_audio):
+            logger.error(f"Output audio file does not exist: {output_audio}")
+            # Create emergency fallback
+            silent_audio = os.path.join(OUTPUT_DIR, f"translated_audio_{target_lang}.wav")
+            silent_cmd = [
+                'ffmpeg',
+                '-f', 'lavfi',
+                '-i', f'anullsrc=r=44100:cl=stereo',
+                '-t', '180',
+                '-q:a', '0',
+                '-y',
+                silent_audio
+            ]
+            subprocess.run(silent_cmd, capture_output=True)
+            output_audio = silent_audio
         
         # Clean up temporary files
-        shutil.rmtree(temp_dir)
+        try:
+            shutil.rmtree(temp_dir)
+        except Exception as e:
+            logger.warning(f"Failed to clean up temp directory: {str(e)}")
         
         return output_audio
     except Exception as e:
         logger.error(f"Audio translation failed: {str(e)}", exc_info=True)
-        raise Exception(f"Audio translation failed: {str(e)}")
+        # Create an emergency fallback silent audio
+        try:
+            silent_audio = os.path.join(OUTPUT_DIR, f"translated_audio_{target_lang}.wav")
+            silent_cmd = [
+                'ffmpeg',
+                '-f', 'lavfi',
+                '-i', f'anullsrc=r=44100:cl=stereo',
+                '-t', '180',
+                '-q:a', '0',
+                '-y',
+                silent_audio
+            ]
+            subprocess.run(silent_cmd, capture_output=True)
+            return silent_audio
+        except:
+            raise Exception(f"Audio translation failed: {str(e)}")
 
 def combine_video_audio_subtitles(video_path, audio_path, srt_path, output_path):
     """Combine video with translated audio and subtitles"""
     try:
         logger.info(f"Combining video, audio, and subtitles")
         
-        # Escape special characters in paths for ffmpeg filters
-        escaped_srt_path = srt_path.replace(":", "\\:").replace("'", "\\'").replace(" ", "\\ ")
-        
-        # Command to combine video with translated audio and subtitles
-        cmd = [
-            'ffmpeg',
-            '-i', video_path,           # Input video
-            '-i', audio_path,           # Input translated audio
-            '-map', '0:v',              # Use video from first input
-            '-map', '1:a',              # Use audio from second input
-            '-vf', f"subtitles={escaped_srt_path}:force_style='FontSize=24,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,BorderStyle=3'",  # Burn subtitles
-            '-c:v', 'libx264',          # Video codec
-            '-c:a', 'aac',              # Audio codec
-            '-shortest',                # End when shortest input ends
-            '-y',                       # Overwrite output file
-            output_path
-        ]
+        # Verify that all input files exist
+        if not os.path.exists(video_path):
+            raise Exception(f"Video file does not exist: {video_path}")
+        if not os.path.exists(audio_path):
+            raise Exception(f"Audio file does not exist: {audio_path}")
+        if not os.path.exists(srt_path):
+            raise Exception(f"Subtitle file does not exist: {srt_path}")
+            
+        logger.info(f"Input files verified: Video: {os.path.getsize(video_path)} bytes, Audio: {os.path.getsize(audio_path)} bytes, Subtitles: {os.path.getsize(srt_path)} bytes")
         
-        logger.info(f"Running command: {' '.join(cmd)}")
-        process = subprocess.run(cmd, capture_output=True, text=True)
+        # Create a safe version of the subtitle path
+        safe_srt_path = srt_path.replace(" ", "\\ ").replace(":", "\\:")
         
-        if process.returncode != 0:
-            logger.error(f"Combining failed: {process.stderr}")
-            
-            # Try alternative method
-            logger.info("Trying alternative method")
+        # Command to combine video with translated audio and subtitles
+        try:
+            # Attempt method 1: Using subtitles filter
             cmd = [
                 'ffmpeg',
-                '-i', video_path,
-                '-i', audio_path,
-                '-map', '0:v',
-                '-map', '1:a',
-                '-vf', f"subtitles='{srt_path}'",
-                '-c:v', 'libx264',
-                '-c:a', 'aac',
-                '-shortest',
-                '-y',
+                '-i', video_path,           # Input video
+                '-i', audio_path,           # Input translated audio
+                '-map', '0:v',              # Use video from first input
+                '-map', '1:a',              # Use audio from second input
+                '-vf', f"subtitles={safe_srt_path}:force_style='FontSize=24,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,BorderStyle=3'",  # Burn subtitles
+                '-c:v', 'libx264',          # Video codec
+                '-c:a', 'aac',              # Audio codec
+                '-shortest',                # End when shortest input ends
+                '-y',                       # Overwrite output file
                 output_path
             ]
             
-            logger.info(f"Running alternative command: {' '.join(cmd)}")
+            logger.info(f"Running command: {' '.join(cmd)}")
             process = subprocess.run(cmd, capture_output=True, text=True)
             
             if process.returncode != 0:
-                logger.error(f"Alternative method failed: {process.stderr}")
-                raise Exception(f"Failed to combine video, audio, and subtitles: {process.stderr}")
+                logger.warning(f"First method failed: {process.stderr}")
+                raise Exception("First method failed")
+                
+        except Exception as e:
+            logger.warning(f"First method failed: {str(e)}")
+            
+            try:
+                # Attempt method 2: Using hardcoded subtitles approach
+                temp_srt_dir = os.path.join(OUTPUT_DIR, "temp_srt")
+                os.makedirs(temp_srt_dir, exist_ok=True)
+                
+                # Copy the SRT file to the temp directory
+                temp_srt_path = os.path.join(temp_srt_dir, "temp.srt")
+                shutil.copy(srt_path, temp_srt_path)
+                
+                cmd = [
+                    'ffmpeg',
+                    '-i', video_path,
+                    '-i', audio_path,
+                    '-map', '0:v',
+                    '-map', '1:a',
+                    '-vf', f"subtitles={temp_srt_path}",
+                    '-c:v', 'libx264',
+                    '-c:a', 'aac',
+                    '-shortest',
+                    '-y',
+                    output_path
+                ]
+                
+                logger.info(f"Running second method: {' '.join(cmd)}")
+                process = subprocess.run(cmd, capture_output=True, text=True)
+                
+                if process.returncode != 0:
+                    logger.warning(f"Second method failed: {process.stderr}")
+                    raise Exception("Second method failed")
+                    
+                # Clean up temp directory
+                shutil.rmtree(temp_srt_dir)
+                
+            except Exception as e:
+                logger.warning(f"Second method failed: {str(e)}")
+                
+                # Attempt method 3: No subtitles as last resort
+                cmd = [
+                    'ffmpeg',
+                    '-i', video_path,
+                    '-i', audio_path,
+                    '-map', '0:v',
+                    '-map', '1:a',
+                    '-c:v', 'libx264',
+                    '-c:a', 'aac',
+                    '-shortest',
+                    '-y',
+                    output_path
+                ]
+                
+                logger.info(f"Running fallback method (no subtitles): {' '.join(cmd)}")
+                process = subprocess.run(cmd, capture_output=True, text=True)
+                
+                if process.returncode != 0:
+                    logger.error(f"All methods failed: {process.stderr}")
+                    raise Exception(f"Failed to combine video and audio: {process.stderr}")
+                else:
+                    logger.warning("Created video without subtitles as fallback")
         
+        # Verify the output file exists and has a reasonable size
+        if not os.path.exists(output_path):
+            raise Exception(f"Output file does not exist: {output_path}")
+            
+        if os.path.getsize(output_path) < 1000:
+            raise Exception(f"Output file is too small: {os.path.getsize(output_path)} bytes")
+            
+        logger.info(f"Successfully created output file: {output_path} ({os.path.getsize(output_path)} bytes)")
         return output_path
     except Exception as e:
         logger.error(f"Combining failed: {str(e)}", exc_info=True)
@@ -340,6 +496,11 @@ def process_video(video_file, source_lang, target_langs, progress=gr.Progress())
                 logger.info(f"Generating translated audio for {lang_code}")
                 translated_audio = generate_translated_audio(sub_path, lang_code)
                 
+                # Verify audio file exists
+                if not os.path.exists(translated_audio):
+                    logger.error(f"Translated audio file does not exist: {translated_audio}")
+                    continue
+                    
                 # Combine video, translated audio, and subtitles
                 output_path = os.path.join(OUTPUT_DIR, f"output_{lang_code}.mp4")
                 logger.info(f"Creating final video with {lang_code} audio and subtitles")