Upload 4 files

README.md

@@ -1,12 +1,122 @@
----
-title: Burning
-emoji: 📈
-colorFrom: purple
-colorTo: pink
-sdk: gradio
-sdk_version: 6.5.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎬 Video Subtitle Burner & Uploader
+
+A Gradio application that burns subtitles into videos and uploads them to abyss.to
+
+## Features
+
+- ✅ Download videos from Google Drive or direct URLs
+- ✅ Burn SRT subtitles into video
+- ✅ Upload processed video to abyss.to (hydrax.net)
+- ✅ Simple web interface
+- ✅ Progress tracking
+
+## How to Deploy on Hugging Face Spaces
+
+### Method 1: Web Interface
+
+1. Go to https://huggingface.co/spaces
+2. Click **"Create new Space"**
+3. Fill in details:
+   - **Space name**: `subtitle-burner` (or your choice)
+   - **License**: Apache 2.0
+   - **Select SDK**: Gradio
+   - **Hardware**: CPU Basic (Free tier works!)
+4. Click **"Create Space"**
+5. Upload these files:
+   - `app.py`
+   - `requirements.txt`
+   - `README.md`
+6. Go to **Settings** → **Variables and secrets**
+7. Add **packages_txt** file with content:
+   ```
+   ffmpeg
+   ```
+8. Wait for the build to complete (~2-5 minutes)
+9. Your app will be live! 🎉
+
+### Method 2: Git Upload
+
+```bash
+# Clone your space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/subtitle-burner
+cd subtitle-burner
+
+# Copy files
+cp app.py requirements.txt README.md ./
+
+# Create packages.txt for FFmpeg
+echo "ffmpeg" > packages.txt
+
+# Commit and push
+git add .
+git commit -m "Initial commit"
+git push
+```
+
+## Usage
+
+1. **Video URL**: Paste your Google Drive link or direct video URL
+   - Google Drive: `https://drive.google.com/file/d/FILE_ID/view`
+   - Direct: Any `.mp4` URL
+
+2. **Subtitle Content**: Paste your SRT subtitle file content
+   ```
+   1
+   00:00:01,000 --> 00:00:04,000
+   මේ උදාහරණ subtitle එකක්
+   
+   2
+   00:00:04,500 --> 00:00:08,000
+   This is an example subtitle
+   ```
+
+3. Click **Process & Upload**
+
+4. Wait for processing (may take a few minutes depending on video size)
+
+5. Get the abyss.to upload response with your video link!
+
+## Technical Details
+
+- **FFmpeg**: Used for burning subtitles
+- **Gradio**: Web interface framework
+- **gdown**: Google Drive file downloads
+- **requests**: HTTP operations and uploading
+
+## Files
+
+- `app.py`: Main application code
+- `requirements.txt`: Python dependencies
+- `packages.txt`: System packages (FFmpeg)
+- `README.md`: Documentation
+
+## Important Notes
+
+⚠️ **FFmpeg Required**: Make sure to create `packages.txt` with `ffmpeg` for Hugging Face Spaces
+
+⚠️ **File Size Limits**: Hugging Face free tier has storage limits. Large videos may fail.
+
+⚠️ **Processing Time**: Video processing can take time. Be patient!
+
+## Troubleshooting
+
+### Error: FFmpeg not found
+- Make sure `packages.txt` contains `ffmpeg`
+- Rebuild the space
+
+### Error: Download failed
+- Check if the Google Drive link is publicly accessible
+- Verify the direct URL is correct
+
+### Error: Upload to abyss.to failed
+- Check your internet connection
+- Verify the abyss.to upload URL is correct
+- Check file size limits
+
+## License
+
+Apache 2.0
+
+## Credits
+
+Built with Gradio, FFmpeg, and Python 🐍

app.py

@@ -0,0 +1,183 @@
+import gradio as gr
+import subprocess
+import requests
+import os
+import re
+from pathlib import Path
+import gdown
+
+def download_from_gdrive(url):
+    """Download file from Google Drive"""
+    try:
+        # Extract file ID from various Google Drive URL formats
+        file_id = None
+        if 'drive.google.com' in url:
+            if '/file/d/' in url:
+                file_id = url.split('/file/d/')[1].split('/')[0]
+            elif 'id=' in url:
+                file_id = url.split('id=')[1].split('&')[0]
+        
+        if file_id:
+            output = 'input_video.mp4'
+            gdown.download(f'https://drive.google.com/uc?id={file_id}', output, quiet=False)
+            return output
+        else:
+            return None
+    except Exception as e:
+        print(f"Error downloading from Google Drive: {e}")
+        return None
+
+def download_video(url):
+    """Download video from direct URL or Google Drive"""
+    try:
+        # Check if it's a Google Drive link
+        if 'drive.google.com' in url:
+            return download_from_gdrive(url)
+        
+        # Direct download
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        output_path = 'input_video.mp4'
+        with open(output_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        
+        return output_path
+    except Exception as e:
+        return f"Error downloading video: {str(e)}"
+
+def burn_subtitles(video_path, subtitle_file):
+    """Burn subtitles into video using FFmpeg"""
+    try:
+        output_path = 'output_with_subs.mp4'
+        
+        # Save subtitle file
+        subtitle_path = 'subtitles.srt'
+        with open(subtitle_path, 'w', encoding='utf-8') as f:
+            f.write(subtitle_file)
+        
+        # FFmpeg command to burn subtitles
+        cmd = [
+            'ffmpeg',
+            '-i', video_path,
+            '-vf', f"subtitles={subtitle_path}:force_style='FontSize=24,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,Outline=2'",
+            '-c:a', 'copy',
+            '-y',
+            output_path
+        ]
+        
+        subprocess.run(cmd, check=True, capture_output=True)
+        return output_path
+    except subprocess.CalledProcessError as e:
+        return f"Error burning subtitles: {e.stderr.decode()}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def upload_to_abyss(file_path):
+    """Upload file to abyss.to (hydrax.net)"""
+    try:
+        url = 'http://up.hydrax.net/af3a445e1825a2b8256fc918c6087381'
+        
+        file_name = os.path.basename(file_path)
+        file_type = 'video/mp4'
+        
+        with open(file_path, 'rb') as f:
+            files = {'file': (file_name, f, file_type)}
+            response = requests.post(url, files=files, timeout=300)
+        
+        return response.text
+    except Exception as e:
+        return f"Error uploading to abyss.to: {str(e)}"
+
+def process_video(video_url, subtitle_content, progress=gr.Progress()):
+    """Main processing function"""
+    try:
+        progress(0.1, desc="Downloading video...")
+        video_path = download_video(video_url)
+        
+        if isinstance(video_path, str) and video_path.startswith("Error"):
+            return video_path, None
+        
+        if not os.path.exists(video_path):
+            return "Error: Video download failed", None
+        
+        progress(0.4, desc="Burning subtitles...")
+        output_path = burn_subtitles(video_path, subtitle_content)
+        
+        if isinstance(output_path, str) and output_path.startswith("Error"):
+            return output_path, None
+        
+        progress(0.7, desc="Uploading to abyss.to...")
+        upload_response = upload_to_abyss(output_path)
+        
+        progress(1.0, desc="Complete!")
+        
+        # Cleanup
+        if os.path.exists(video_path):
+            os.remove(video_path)
+        if os.path.exists('subtitles.srt'):
+            os.remove('subtitles.srt')
+        
+        return f"✅ Upload successful!\n\nResponse from abyss.to:\n{upload_response}", output_path
+    
+    except Exception as e:
+        return f"Error: {str(e)}", None
+
+# Gradio Interface
+with gr.Blocks(title="Subtitle Burner & Uploader", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🎬 Video Subtitle Burner & Uploader
+    
+    Upload a video (via link) and subtitle file, burn subtitles into the video, and upload to abyss.to
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            video_url = gr.Textbox(
+                label="Video URL",
+                placeholder="Enter Google Drive link or direct video URL",
+                lines=2
+            )
+            
+            subtitle_file = gr.Textbox(
+                label="Subtitle Content (.srt)",
+                placeholder="Paste your SRT subtitle content here...",
+                lines=10
+            )
+            
+            process_btn = gr.Button("🚀 Process & Upload", variant="primary", size="lg")
+        
+        with gr.Column():
+            status_output = gr.Textbox(
+                label="Status",
+                lines=10,
+                interactive=False
+            )
+            
+            video_output = gr.Video(
+                label="Preview (with subtitles)",
+                interactive=False
+            )
+    
+    gr.Markdown("""
+    ### 📝 Instructions:
+    1. **Video URL**: Paste a Google Drive share link or direct video URL
+    2. **Subtitle Content**: Paste the contents of your .srt subtitle file
+    3. Click **Process & Upload** and wait
+    4. The video with burned subtitles will be uploaded to abyss.to
+    
+    ### 🔗 Supported formats:
+    - Google Drive: `https://drive.google.com/file/d/FILE_ID/view`
+    - Direct links: Any direct .mp4 URL
+    - Subtitles: Standard SRT format
+    """)
+    
+    process_btn.click(
+        fn=process_video,
+        inputs=[video_url, subtitle_file],
+        outputs=[status_output, video_output]
+    )
+
+if __name__ == "__main__":
+    app.launch()

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,4 @@
+gradio==4.16.0
+requests==2.31.0
+gdown==4.7.1
+ffmpeg-python==0.2.0