Spaces:
Running
Running
| """ | |
| Upload → Shorts (Free, Phone-only) – Hugging Face Space App | |
| """ | |
| import os | |
| import tempfile | |
| from typing import List | |
| import gradio as gr | |
| from moviepy.editor import VideoFileClip | |
| def make_916(clip: VideoFileClip, target_h: int = 1920, target_w: int = 1080) -> VideoFileClip: | |
| """Resize + crop to 9:16 vertical format.""" | |
| resized = clip.resize(height=target_h) | |
| w, h = resized.size | |
| if w == target_w: | |
| return resized | |
| x1 = max(0, (w - target_w) // 2) | |
| x2 = x1 + target_w | |
| return resized.crop(x1=x1, y1=0, x2=x2, y2=target_h) | |
| def slice_evenly(duration: float, clip_len: float, n_clips: int) -> List[float]: | |
| """Get evenly spaced start times for subclips.""" | |
| starts = [] | |
| if duration <= 0 or clip_len <= 0 or n_clips <= 0: | |
| return starts | |
| last_valid = max(0.0, duration - clip_len) | |
| for i in range(n_clips): | |
| t = (last_valid * i) / max(1, n_clips - 1) | |
| starts.append(float(t)) | |
| return starts | |
| def video_to_shorts(video_path: str, clip_len: int, n_clips: int, fps: int, quality: str): | |
| temp_root = tempfile.mkdtemp(prefix="shorts_") | |
| outputs = [] | |
| error_msg = None | |
| try: | |
| base_name = os.path.splitext(os.path.basename(video_path))[0] | |
| with VideoFileClip(video_path) as vid: | |
| duration = float(vid.duration or 0) | |
| if duration <= 1: | |
| raise ValueError("Video too short or failed to load.") | |
| max_clips = max(1, int(duration // max(1, clip_len))) | |
| n_use = min(n_clips, max_clips) | |
| starts = slice_evenly(duration, clip_len, n_use) | |
| if quality == "High": | |
| bitrate = "5000k" | |
| elif quality == "Medium": | |
| bitrate = "3500k" | |
| else: | |
| bitrate = "2000k" | |
| for idx, st in enumerate(starts, start=1): | |
| sub = vid.subclip(st, min(st + clip_len, duration)) | |
| sub916 = make_916(sub) | |
| out_path = os.path.join(temp_root, f"{base_name}_short_{idx:02d}.mp4") | |
| sub916.write_videofile( | |
| out_path, | |
| codec="libx264", | |
| audio_codec="aac", | |
| fps=fps, | |
| bitrate=bitrate, | |
| threads=2, | |
| verbose=False, | |
| logger=None, | |
| ) | |
| outputs.append(out_path) | |
| if not outputs: | |
| error_msg = "No clips generated. Try shorter length or another video." | |
| except Exception as e: | |
| error_msg = f"Error: {str(e)}" | |
| if error_msg: | |
| return None, error_msg | |
| return outputs, None | |
| def run_app(): | |
| with gr.Blocks(title="Upload → Shorts (Free, Phone)") as demo: | |
| gr.Markdown( | |
| """ | |
| # 🎬 Upload → Shorts Converter | |
| Upload a long video and get vertical (9:16) Shorts. | |
| ✅ Works on phone (no PC needed). | |
| """ | |
| ) | |
| video_in = gr.File(label="Upload your video", type="filepath") | |
| clip_len = gr.Slider(10, 60, value=25, step=1, label="Clip length (sec)") | |
| n_clips = gr.Slider(1, 10, value=3, step=1, label="Number of clips") | |
| fps = gr.Slider(24, 60, value=30, step=1, label="FPS") | |
| quality = gr.Radio(["High", "Medium", "Low"], value="Medium", label="Quality") | |
| btn = gr.Button("🎥 Make Shorts") | |
| gallery = gr.Gallery(label="Your Shorts", columns=3) | |
| status = gr.Markdown() | |
| def submit(video_in, clip_len, n_clips, fps, quality): | |
| if not video_in: | |
| return [], "❌ Please upload a video first." | |
| files, err = video_to_shorts(video_in, int(clip_len), int(n_clips), int(fps), quality) | |
| if err: | |
| return [], f"❌ {err}" | |
| return files, f"✅ Done! {len(files)} short(s) generated." | |
| btn.click(submit, [video_in, clip_len, n_clips, fps, quality], [gallery, status]) | |
| return demo | |
| if __name__ == "__main__": | |
| app = run_app() | |
| app.launch() |