Spaces:
Sleeping
Sleeping
| import os | |
| import subprocess | |
| import shutil | |
| import gradio as gr | |
| def check_video_size(video_path, max_size_mb=1000): | |
| size_mb = os.path.getsize(video_path) / (1024 * 1024) | |
| if size_mb > max_size_mb: | |
| raise gr.Error(f"Video is too large ({size_mb:.1f} MB). Max {max_size_mb} MB allowed.") | |
| def split_video_into_chunks(video_path, chunk_duration=6, output_dir="video_chunks"): | |
| # Clear previous chunks if directory exists, then recreate | |
| if os.path.exists(output_dir): | |
| shutil.rmtree(output_dir) | |
| os.makedirs(output_dir, exist_ok=True) | |
| # Get video duration using FFprobe | |
| cmd_duration = [ | |
| "ffprobe", "-v", "error", "-show_entries", "format=duration", | |
| "-of", "default=noprint_wrappers=1:nokey=1", video_path | |
| ] | |
| try: | |
| res = subprocess.run(cmd_duration, capture_output=True, text=True, check=True) | |
| duration = float(res.stdout.strip()) | |
| except Exception as e: | |
| raise gr.Error(f"Failed to read video duration via FFprobe: {str(e)}") | |
| num_chunks = int(duration // chunk_duration) | |
| if num_chunks == 0: | |
| raise gr.Error("Video duration is shorter than the requested chunk length.") | |
| chunk_files = [] | |
| for i in range(num_chunks): | |
| start_time = i * chunk_duration | |
| output_file = os.path.join(output_dir, f"chunk_{i+1}.mp4") | |
| # Fast seek before input file | |
| command = [ | |
| "ffmpeg", "-y", | |
| "-ss", str(start_time), | |
| "-i", video_path, | |
| "-t", str(chunk_duration), | |
| "-c", "copy", | |
| output_file | |
| ] | |
| try: | |
| subprocess.run(command, capture_output=True, check=True) | |
| chunk_files.append(output_file) | |
| except subprocess.CalledProcessError as e: | |
| print(f"Error producing chunk {i+1}: {e.stderr.decode()}") | |
| return chunk_files | |
| def gradio_interface(video, chunk_duration, progress=gr.Progress(track_tqdm=True)): | |
| if video is None: | |
| raise gr.Error("Please upload a valid video file.") | |
| progress(0.1, desc="Checking video size...") | |
| check_video_size(video, max_size_mb=1000) | |
| progress(0.3, desc="Splitting video into chunks...") | |
| chunk_files = split_video_into_chunks(video, chunk_duration=chunk_duration) | |
| progress(1.0, desc="Done!") | |
| return chunk_files | |
| # Build interface using Blocks for full API compatibility in Gradio 5 | |
| with gr.Blocks(title="Video Splitter") as demo: | |
| gr.Markdown("# Video Splitter with Custom Chunk Duration") | |
| gr.Markdown("Upload a video (max 1 GB) and choose chunk duration in seconds.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| video_input = gr.Video(label="Upload Video") | |
| slider_input = gr.Slider(minimum=1, maximum=60, value=6, step=1, label="Chunk Duration (seconds)") | |
| submit_btn = gr.Button("Split Video", variant="primary") | |
| with gr.Column(): | |
| files_output = gr.Files(label="Download Chunks") | |
| submit_btn.click( | |
| fn=gradio_interface, | |
| inputs=[video_input, slider_input], | |
| outputs=files_output, | |
| api_name="predict" # Guarantees explicit API route registration | |
| ) | |
| if __name__ == "__main__": | |
| demo.queue().launch(max_file_size="1000MB") |