Update app.py

app.py

@@ -48,7 +48,9 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
         return None, None, "Please upload a video"
     
     temp_dir = tempfile.mkdtemp()
+    output_dir = tempfile.mkdtemp()  # Separate directory for outputs
     print(f"Processing in temp directory: {temp_dir}")
+    print(f"Output directory: {output_dir}")
     
     try:
         # Extract audio
@@ -58,6 +60,7 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
         print(f"Extracting audio from: {video_file}")
         video = VideoFileClip(video_file)
         if not video.audio:
+            shutil.rmtree(output_dir)
             return None, None, "Video has no audio track"
         
         video.audio.write_audiofile(
@@ -90,17 +93,18 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
         if not result.get('chunks') or len(result['chunks']) == 0:
             error_msg = f"Transcription returned no segments. Full result: {result}"
             print(error_msg)
+            shutil.rmtree(output_dir)
             return None, None, error_msg
         
         print(f"Transcription complete: {len(result['chunks'])} segments")
         
-        # Create SRT
+        # Create SRT in output directory (persistent)
         progress(0.6, desc="Creating SRT...")
-        srt_path = os.path.join(temp_dir, "subtitles.srt")
+        srt_path = os.path.join(output_dir, "subtitles.srt")
         
         print(f"Creating SRT at: {srt_path}")
-        print(f"Temp directory exists: {os.path.exists(temp_dir)}")
-        print(f"Temp directory contents before SRT: {os.listdir(temp_dir)}")
+        print(f"Output directory exists: {os.path.exists(output_dir)}")
+        print(f"Output directory contents before SRT: {os.listdir(output_dir)}")
         
         try:
             with open(srt_path, 'w', encoding='utf-8-sig') as f:
@@ -113,6 +117,179 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
                         f.write(f"{format_srt_time(start)} --> {format_srt_time(end)}\n")
                         f.write(f"{text}\n\n")
             
+            print(f"SRT file write completed")
+        except Exception as e:
+            print(f"Error writing SRT file: {e}")
+            import traceback
+            print(traceback.format_exc())
+            shutil.rmtree(output_dir)
+            raise
+        
+        # Verify SRT was created
+        print(f"Checking if SRT exists: {os.path.exists(srt_path)}")
+        print(f"Output directory contents after SRT: {os.listdir(output_dir)}")
+        
+        if not os.path.exists(srt_path):
+            shutil.rmtree(output_dir)
+            return None, None, f"SRT file was not created at: {srt_path}\nDirectory contents: {os.listdir(output_dir)}"
+        
+        srt_size = os.path.getsize(srt_path)
+        if srt_size == 0:
+            shutil.rmtree(output_dir)
+            return None, None, f"SRT file is empty at: {srt_path}"
+        
+        print(f"SRT created successfully: {srt_path} ({srt_size} bytes)")
+        
+        # Read SRT content for debugging
+        try:
+            with open(srt_path, 'r', encoding='utf-8-sig') as f:
+                srt_preview = f.read()[:500]
+                print(f"SRT preview:\n{srt_preview}")
+        except Exception as e:
+            print(f"Error reading SRT file: {e}")
+        
+        # Burn subtitles
+        progress(0.85, desc="Burning subtitles...")
+        output_path = os.path.join(output_dir, "final.mp4")
+        
+        print("Burning subtitles with FFmpeg...")
+        
+        # Convert SRT to ASS first (more reliable with FFmpeg)
+        ass_path = os.path.join(output_dir, "subtitles.ass")
+        
+        print(f"Converting SRT to ASS for better compatibility...")
+        try:
+            subprocess.run([
+                'ffmpeg', '-y',
+                '-i', srt_path,
+                ass_path
+            ], check=True, capture_output=True, text=True)
+            
+            if not os.path.exists(ass_path):
+                raise Exception(f"Failed to create ASS file at {ass_path}")
+            
+            print(f"ASS file created: {ass_path} ({os.path.getsize(ass_path)} bytes)")
+        except subprocess.CalledProcessError as e:
+            print(f"SRT to ASS conversion failed: {e.stderr}")
+            shutil.rmtree(output_dir)
+            raise
+        
+        # Use ASS filter which is more reliable than subtitles filter
+        # For ass filter, we need to escape special characters differently
+        ass_path_escaped = ass_path.replace('\\', '\\\\').replace(':', '\\:')
+        
+        ffmpeg_cmd = [
+            'ffmpeg', '-y',
+            '-i', video_file,
+            '-vf', f"ass={ass_path_escaped}",
+            '-c:a', 'copy',
+            '-c:v', 'libx264',
+            '-preset', 'medium',
+            '-crf', '23',
+            output_path
+        ]
+        
+        print(f"FFmpeg command: {' '.join(ffmpeg_cmd)}")
+        
+        try:
+            ffmpeg_result = subprocess.run(
+                ffmpeg_cmd,
+                check=True,
+                capture_output=True,
+                text=True,
+                timeout=600
+            )
+            print(f"FFmpeg stdout: {ffmpeg_result.stdout}")
+            print(f"FFmpeg stderr: {ffmpeg_result.stderr}")
+        except subprocess.CalledProcessError as e:
+            print(f"FFmpeg failed!")
+            print(f"Return code: {e.returncode}")
+            print(f"Stdout: {e.stdout}")
+            print(f"Stderr: {e.stderr}")
+            shutil.rmtree(output_dir)
+            raise
+        
+        if not os.path.exists(output_path):
+            shutil.rmtree(output_dir)
+            return None, None, f"Output video was not created at: {output_path}"
+        
+        print(f"Video created: {output_path} ({os.path.getsize(output_path)} bytes)")
+        
+        progress(1.0, desc="Complete!")
+        
+        # Create status with preview
+        preview_lines = []
+        for i, chunk in enumerate(result['chunks'][:10], 1):
+            text = chunk['text'].strip()
+            start_time = chunk['timestamp'][0]
+            preview_lines.append(f"{i}. [{start_time:.1f}s] {text}")
+        
+        preview_text = "\n".join(preview_lines)
+        full_text = " ".join([c['text'].strip() for c in result['chunks']])
+        
+        status = f"""Processing Complete!
+Statistics:
+- Model: Whisper Large V3 Turbo
+- Device: {device}
+- Segments: {len(result['chunks'])}
+- Duration: {result['chunks'][-1]['timestamp'][1]:.1f}s
+- Language: {language}
+
+Preview (first 10 segments):
+{preview_text}
+
+Full Transcription:
+{full_text[:500]}{"..." if len(full_text) > 500 else ""}
+
+Files created successfully!
+"""
+        
+        # Don't cleanup output_dir - Gradio needs these files
+        return srt_path, output_path, status
+        
+    except subprocess.TimeoutExpired:
+        try:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
+        except:
+            pass
+        return None, None, "Processing timeout. Try a shorter video."
+    except subprocess.CalledProcessError as e:
+        try:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
+        except:
+            pass
+        error_detail = e.stderr.decode() if hasattr(e.stderr, 'decode') else str(e.stderr) if e.stderr else str(e)
+        return None, None, f"FFmpeg error: {error_detail}"
+    except Exception as e:
+        try:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
+        except:
+            pass
+        import traceback
+        error_trace = traceback.format_exc()
+        print(f"Error: {error_trace}")
+        return None, None, f"Error: {str(e)}\n\nDetails:\n{error_trace}"
+    finally:
+        # Only cleanup temp_dir (audio processing), keep output_dir for Gradio
+        try:
+            shutil.rmtree(temp_dir)
+            print(f"Cleaned up temp directory: {temp_dir}")
+        except Exception as e:
+            print(f"Cleanup warning: {e}")
+        # Note: output_dir is NOT cleaned up here - Gradio needs access to the files
+        # The files will be cleaned up by the OS eventually from /tmp/, 'w', encoding='utf-8-sig') as f:
+                for i, chunk in enumerate(result['chunks'], 1):
+                    start, end = chunk['timestamp']
+                    text = chunk['text'].strip()
+                    
+                    if text:
+                        f.write(f"{i}\n")
+                        f.write(f"{format_srt_time(start)} --> {format_srt_time(end)}\n")
+                        f.write(f"{text}\n\n")
+            
             print(f"SRT file write completed")
         except Exception as e:
             print(f"Error writing SRT file: {e}")