Update app.py

app.py

@@ -3,29 +3,127 @@ import subprocess
 import static_ffmpeg
 import os
 import tempfile
+import requests
 from datetime import datetime
+from pathlib import Path
 
 # Add static ffmpeg to PATH
 static_ffmpeg.add_paths()
 
-def stitch_media(video_file, audio_file, subtitle_file, crf_quality=23):
+def download_file_from_url(url, output_dir, filename):
+    """Download a file from URL and save it to output directory."""
+    try:
+        response = requests.get(url, stream=True, timeout=30)
+        response.raise_for_status()
+        
+        file_path = os.path.join(output_dir, filename)
+        with open(file_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        
+        return file_path
+    except Exception as e:
+        raise Exception(f"Failed to download file from URL: {str(e)}")
+
+def validate_and_get_file(uploaded_file, url_string, file_type, temp_dir):
     """
-    Stitch video, audio, and subtitle files together using ffmpeg
-    All files are handled through Gradio's temporary file system
+    Validate that only one input method is used and return the file path.
+
+    Args:
+        uploaded_file: Uploaded file object (or None)
+        url_string: URL string (or empty)
+        file_type: Type of file (for naming downloaded files)
+        temp_dir: Temporary directory to store downloaded files
+        
+    Returns:
+        tuple: (file_path, error_message)
     """
+    has_upload = uploaded_file is not None
+    has_url = url_string and url_string.strip()
+
+    # Validation: Must have exactly one input method
+    if not has_upload and not has_url:
+        return None, f"❌ Please provide {file_type} either by upload or URL"
+
+    if has_upload and has_url:
+        return None, f"❌ Please use only ONE method for {file_type}: either upload OR URL (not both)"
+
+    # Handle uploaded file
+    if has_upload:
+        file_path = uploaded_file.name if hasattr(uploaded_file, 'name') else uploaded_file
+        return file_path, None
+
+    # Handle URL download
+    if has_url:
+        try:
+            # Get file extension from URL or use default
+            url_parts = url_string.strip().split('/')
+            original_filename = url_parts[-1] if url_parts else f"{file_type}_file"
+            
+            # Add extension if missing
+            if '.' not in original_filename:
+                ext_map = {
+                    'video': '.mp4',
+                    'audio': '.wav',
+                    'subtitle': '.srt'
+                }
+                original_filename += ext_map.get(file_type, '.tmp')
+            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"{file_type}_{timestamp}_{original_filename}"
+            
+            file_path = download_file_from_url(url_string.strip(), temp_dir, filename)
+            return file_path, None
+            
+        except Exception as e:
+            return None, f"❌ Error downloading {file_type} from URL: {str(e)}"
+
+    return None, f"❌ Unknown error processing {file_type}"
+
+def stitch_media(
+video_file, video_url,
+audio_file, audio_url,
+subtitle_file, subtitle_url,
+crf_quality=23
+):
+    """
+    Stitch video, audio, and subtitle files together using ffmpeg.
+    Files can be uploaded or fetched from URLs.
+    """
+    temp_dir = tempfile.mkdtemp()
+
     try:
-        # Validate inputs
-        if not video_file or not audio_file or not subtitle_file:
-            return None, "❌ Please upload all three files (video, audio, subtitle)"
+        # Validate and get video file
+        video_path, video_error = validate_and_get_file(
+            video_file, video_url, 'video', temp_dir
+        )
+        if video_error:
+            return None, video_error
+        
+        # Validate and get audio file
+        audio_path, audio_error = validate_and_get_file(
+            audio_file, audio_url, 'audio', temp_dir
+        )
+        if audio_error:
+            return None, audio_error
         
-        # Gradio automatically provides temporary file paths
-        video_path = video_file.name if hasattr(video_file, 'name') else video_file
-        audio_path = audio_file.name if hasattr(audio_file, 'name') else audio_file
-        subtitle_path = subtitle_file.name if hasattr(subtitle_file, 'name') else subtitle_file
+        # Validate and get subtitle file
+        subtitle_path, subtitle_error = validate_and_get_file(
+            subtitle_file, subtitle_url, 'subtitle', temp_dir
+        )
+        if subtitle_error:
+            return None, subtitle_error
         
-        # Create output file in temp directory
+        # Create output file
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        output_path = os.path.join(tempfile.gettempdir(), f"stitched_{timestamp}.mp4")
+        output_path = os.path.join(temp_dir, f"stitched_{timestamp}.mp4")
+        
+        # Build status message
+        status_msg = "📥 Processing files:\n"
+        status_msg += f"  • Video: {'Downloaded from URL' if video_url else 'Uploaded file'}\n"
+        status_msg += f"  • Audio: {'Downloaded from URL' if audio_url else 'Uploaded file'}\n"
+        status_msg += f"  • Subtitle: {'Downloaded from URL' if subtitle_url else 'Uploaded file'}\n"
+        status_msg += "\n🎬 Stitching video..."
         
         # FFmpeg command
         cmd = [
@@ -53,12 +151,16 @@ def stitch_media(video_file, audio_file, subtitle_file, crf_quality=23):
         # Check if output file was created
         if os.path.exists(output_path):
             file_size = os.path.getsize(output_path) / (1024 * 1024)  # Size in MB
-            return output_path, f"✅ Video stitched successfully! (Size: {file_size:.2f} MB)"
+            success_msg = f"✅ Video stitched successfully!\n\n"
+            success_msg += f"📊 Output size: {file_size:.2f} MB\n"
+            success_msg += f"🎨 Quality: CRF {crf_quality}\n"
+            success_msg += status_msg.split("🎬")[0]  # Include source info
+            return output_path, success_msg
         else:
             return None, "❌ Output file was not created"
         
     except subprocess.CalledProcessError as e:
-        error_msg = f"❌ FFmpeg error:\n{e.stderr[-500:]}"  # Show last 500 chars of error
+        error_msg = f"❌ FFmpeg error:\n{e.stderr[-500:]}"
         return None, error_msg
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
@@ -69,34 +171,59 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
         """
         # 🎬 Video Audio Subtitle Stitcher
         
-        **Upload your files and stitch them together - No local installation needed!**
+        **Stitch video, audio, and subtitles together with FFmpeg**
         
-        This app works entirely in your browser. Just upload, click stitch, and download your result.
+        📤 Upload files directly **OR** 🌐 provide URLs to download them
+        
+        ⚠️ **Important:** For each file, use either upload OR URL, not both!
         """
     )
 
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 📤 Upload Files")
+            gr.Markdown("### 📹 Video Input")
+            with gr.Group():
+                video_input = gr.File(
+                    label="Upload Video File",
+                    file_types=[".mp4", ".mov", ".avi", ".mkv"],
+                    type="filepath"
+                )
+                gr.Markdown("**OR**")
+                video_url_input = gr.Textbox(
+                    label="Video URL",
+                    placeholder="https://example.com/video.mp4",
+                    lines=1
+                )
             
-            video_input = gr.File(
-                label="📹 Video File",
-                file_types=[".mp4", ".mov", ".avi", ".mkv"],
-                type="filepath"
-            )
-            audio_input = gr.File(
-                label="🎵 Audio File",
-                file_types=[".wav", ".mp3", ".aac", ".m4a"],
-                type="filepath"
-            )
-            subtitle_input = gr.File(
-                label="📝 Subtitle File (.srt)",
-                file_types=[".srt"],
-                type="filepath"
-            )
+            gr.Markdown("### 🎵 Audio Input")
+            with gr.Group():
+                audio_input = gr.File(
+                    label="Upload Audio File",
+                    file_types=[".wav", ".mp3", ".aac", ".m4a"],
+                    type="filepath"
+                )
+                gr.Markdown("**OR**")
+                audio_url_input = gr.Textbox(
+                    label="Audio URL",
+                    placeholder="https://example.com/audio.wav",
+                    lines=1
+                )
             
-            gr.Markdown("### ⚙️ Settings")
+            gr.Markdown("### 📝 Subtitle Input")
+            with gr.Group():
+                subtitle_input = gr.File(
+                    label="Upload Subtitle File (.srt)",
+                    file_types=[".srt"],
+                    type="filepath"
+                )
+                gr.Markdown("**OR**")
+                subtitle_url_input = gr.Textbox(
+                    label="Subtitle URL",
+                    placeholder="https://example.com/subtitles.srt",
+                    lines=1
+                )
             
+            gr.Markdown("### ⚙️ Settings")
             crf_input = gr.Slider(
                 minimum=18,
                 maximum=28,
@@ -107,61 +234,83 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
             )
             
             stitch_btn = gr.Button("🎬 Stitch Video", variant="primary", size="lg")
-            
-            gr.Markdown(
-                """
-                **💡 Tips:**
-                - CRF 18-20: Excellent quality
-                - CRF 23: Balanced (recommended)
-                - CRF 26-28: Smaller file size
-                """
-            )
         
         with gr.Column():
-            gr.Markdown("### 📥 Output")
+            gr.Markdown("### 📊 Status & Output")
             
             status_output = gr.Textbox(
                 label="Status",
-                placeholder="Upload files and click 'Stitch Video' to begin...",
-                lines=3
+                placeholder="Provide inputs and click 'Stitch Video' to begin...",
+                lines=8
             )
             video_output = gr.Video(
-                label="Result",
+                label="Result Video",
                 autoplay=False
             )
             
             gr.Markdown(
                 """
-                **Download:** Right-click the video preview and "Save video as..."
-                or use the download button in the video player.
+                **💾 Download:** Click the download button on the video player
+                or right-click and "Save video as..."
+                """
+            )
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(
+                """
+                ### 📖 Instructions:
+                
+                **For each file (video, audio, subtitle):**
+                1. **Either** upload a file from your computer
+                2. **OR** paste a URL to download it
+                3. ⚠️ **Don't use both!** Choose one method per file
+                
+                ### 💡 Quality Settings:
+                - **CRF 18-20:** Excellent quality (larger files)
+                - **CRF 23:** Balanced (recommended) ⭐
+                - **CRF 26-28:** Good quality (smaller files)
+                """
+            )
+        
+        with gr.Column():
+            gr.Markdown(
+                """
+                ### 🎯 Example URLs:
+                You can use direct links to files:
+                - Video: `.mp4`, `.mov`, `.avi`, `.mkv`
+                - Audio: `.wav`, `.mp3`, `.aac`, `.m4a`
+                - Subtitle: `.srt`
+                
+                ### 🔧 Technical Details:
+                - **Video codec:** H.264 (libx264)
+                - **Audio codec:** AAC
+                - **Output length:** Matches shortest stream
+                - **Subtitles:** Burned into video
                 """
             )
 
     gr.Markdown(
         """
         ---
-        ### 📖 How it works:
-        1. **Upload** your video, audio, and subtitle files
-        2. **Adjust** quality settings if needed
-        3. **Click** "Stitch Video" button
-        4. **Wait** for processing (may take a few moments)
-        5. **Preview** and download your result!
-        
-        ### 🎯 Technical Details:
-        - Video codec: H.264 (libx264)
-        - Audio codec: AAC
-        - Output length: Matches shortest stream (video or audio)
-        - Subtitles: Burned into video
-        
-        ### ☁️ Cloud Deployment Ready:
-        This app can be deployed to Hugging Face Spaces, Google Colab, or any cloud platform!
+        ### ⚡ Features:
+        ✅ Upload files or fetch from URLs  
+        ✅ Automatic validation (no mixing methods)  
+        ✅ Progress tracking  
+        ✅ Instant preview  
+        ✅ Cloud deployment ready  
         """
     )
 
     # Connect the button to the function
     stitch_btn.click(
         fn=stitch_media,
-        inputs=[video_input, audio_input, subtitle_input, crf_input],
+        inputs=[
+            video_input, video_url_input,
+            audio_input, audio_url_input,
+            subtitle_input, subtitle_url_input,
+            crf_input
+        ],
         outputs=[video_output, status_output]
     )