import gradio as gr import numpy as np import cv2 import os import tempfile import time from PIL import Image, ImageDraw, ImageFont import textwrap from typing import Tuple, List import colorsys class CPUVideoGenerator: def __init__(self): self.temp_dir = tempfile.mkdtemp() def generate_text_video(self, prompt: str, duration: int = 5, fps: int = 24, style: str = "typewriter", width: int = 512, height: int = 512) -> str: """Generate a video with animated text based on the prompt.""" # Create video writer output_path = os.path.join(self.temp_dir, f"video_{int(time.time())}.mp4") fourcc = cv2.VideoWriter_fourcc(*'mp4v') out = cv2.VideoWriter(output_path, fourcc, fps, (width, height)) total_frames = duration * fps try: if style == "typewriter": self._create_typewriter_animation(out, prompt, total_frames, width, height, fps) elif style == "fade": self._create_fade_animation(out, prompt, total_frames, width, height, fps) elif style == "slide": self._create_slide_animation(out, prompt, total_frames, width, height, fps) elif style == "glitch": self._create_glitch_animation(out, prompt, total_frames, width, height, fps) elif style == "wave": self._create_wave_animation(out, prompt, total_frames, width, height, fps) else: self._create_typewriter_animation(out, prompt, total_frames, width, height, fps) out.release() return output_path except Exception as e: out.release() raise e def _create_typewriter_animation(self, out, prompt: str, total_frames: int, width: int, height: int, fps: int): """Create a typewriter effect animation.""" # Create PIL image for text rendering img = Image.new('RGB', (width, height), color=(20, 20, 30)) draw = ImageDraw.Draw(img) # Calculate text metrics margin = 50 font_size = max(20, min(60, (width - 2 * margin) // 20)) font = self._get_font(font_size) # Wrap text lines = textwrap.wrap(prompt, width=30) line_height = font_size + 10 total_text_height = len(lines) * line_height start_y = (height - total_text_height) // 2 # Calculate characters per frame total_chars = sum(len(line) for line in lines) chars_per_frame = max(1, total_chars // (total_frames * 0.7)) # 70% of duration for typing char_count = 0 for frame_num in range(total_frames): # Clear background with gradient for y in range(height): color_val = 20 + int(10 * (y / height)) color = (color_val, color_val, color_val + 10) cv2.rectangle(img, (0, y), (width, y + 1), color, -1) # Draw typewriter text current_chars = min(char_count, total_chars) drawn_chars = 0 y_pos = start_y for line in lines: if drawn_chars >= current_chars: break line_end = min(len(line), current_chars - drawn_chars) if line_end > 0: # Draw text with shadow text = line[:line_end] draw.text((margin + 2, y_pos + 2), text, font=font, fill=(0, 0, 0)) draw.text((margin, y_pos), text, font=font, fill=(200, 200, 220)) # Draw cursor if drawn_chars + line_end < current_chars and frame_num % 10 < 5: text_width = font.getlength(text) draw.line([(margin + text_width, y_pos), (margin + text_width, y_pos + font_size)], fill=(255, 255, 100), width=2) drawn_chars += len(line) y_pos += line_height # Add blinking cursor at the end when typing is complete if char_count >= total_chars and frame_num % 20 < 10: last_line_y = start_y + (len(lines) - 1) * line_height last_line = lines[-1] text_width = font.getlength(last_line) draw.line([(margin + text_width, last_line_y), (margin + text_width, last_line_y + font_size)], fill=(255, 255, 100), width=2) # Convert PIL to OpenCV frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR) out.write(frame) if char_count < total_chars: char_count += chars_per_frame def _create_fade_animation(self, out, prompt: str, total_frames: int, width: int, height: int, fps: int): """Create a fade in/out animation.""" img = Image.new('RGB', (width, height), color=(30, 20, 40)) draw = ImageDraw.Draw(img) # Text setup margin = 50 font_size = max(20, min(50, (width - 2 * margin) // 15)) font = self._get_font(font_size) lines = textwrap.wrap(prompt, width=25) line_height = font_size + 15 total_text_height = len(lines) * line_height start_y = (height - total_text_height) // 2 for frame_num in range(total_frames): # Calculate fade alpha fade_progress = frame_num / total_frames if fade_progress < 0.3: # Fade in alpha = fade_progress / 0.3 elif fade_progress > 0.7: # Fade out alpha = (1.0 - fade_progress) / 0.3 else: # Full visibility alpha = 1.0 # Background with animated gradient for y in range(height): hue = (frame_num * 2 + y * 0.5) % 360 rgb = colorsys.hsv_to_rgb(hue / 360, 0.3, 0.2) color = tuple(int(c * 255) for c in rgb) cv2.rectangle(img, (0, y), (width, y + 1), color, -1) # Draw text with fade text_color = tuple(int(200 * alpha) for _ in range(3)) y_pos = start_y for line in lines: draw.text((margin, y_pos), line, font=font, fill=text_color) y_pos += line_height frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR) out.write(frame) def _create_slide_animation(self, out, prompt: str, total_frames: int, width: int, height: int, fps: int): """Create a sliding text animation.""" img = Image.new('RGB', (width, height), color=(40, 30, 50)) draw = ImageDraw.Draw(img) font_size = max(25, min(60, (width - 2 * 50) // 12)) font = self._get_font(font_size) lines = textwrap.wrap(prompt, width=20) line_height = font_size + 15 for frame_num in range(total_frames): # Animated background for y in range(height): intensity = 40 + int(20 * np.sin((frame_num + y) * 0.05)) color = (intensity, intensity - 10, intensity + 10) cv2.rectangle(img, (0, y), (width, y + 1), color, -1) # Calculate slide position slide_progress = (frame_num / total_frames) x_offset = int(width * (1 - 2 * abs(slide_progress - 0.5))) y_pos = (height - len(lines) * line_height) // 2 for line in lines: draw.text((x_offset, y_pos), line, font=font, fill=(220, 200, 180)) y_pos += line_height frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR) out.write(frame) def _create_glitch_animation(self, out, prompt: str, total_frames: int, width: int, height: int, fps: int): """Create a glitch-style animation.""" img = Image.new('RGB', (width, height), color=(10, 10, 20)) draw = ImageDraw.Draw(img) font_size = max(20, min(50, (width - 2 * 50) // 15)) font = self._get_font(font_size) lines = textwrap.wrap(prompt, width=25) line_height = font_size + 10 total_text_height = len(lines) * line_height start_y = (height - total_text_height) // 2 for frame_num in range(total_frames): # Glitch background np_img = np.random.randint(0, 30, (height, width, 3), dtype=np.uint8) img = Image.fromarray(np_img) draw = ImageDraw.Draw(img) # Add glitch lines if frame_num % 5 == 0: for _ in range(3): y = np.random.randint(0, height) color = (np.random.randint(0, 255), np.random.randint(0, 255), np.random.randint(0, 255)) cv2.rectangle(np_img, (0, y), (width, y + np.random.randint(1, 5)), color, -1) # Glitch text effect y_pos = start_y for line in lines: # Multiple text layers with offsets for glitch effect offsets = [(0, 0), (2, 0), (-2, 2), (1, -1)] colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255)] for (dx, dy), color in zip(offsets, colors): if frame_num % 2 == 0 or frame_num % 3 == 0: draw.text((50 + dx + np.random.randint(-2, 3), y_pos + dy + np.random.randint(-2, 3)), line, font=font, fill=color) y_pos += line_height frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR) frame = cv2.GaussianBlur(frame, (3, 3), 0) if frame_num % 10 == 0 else frame out.write(frame) def _create_wave_animation(self, out, prompt: str, total_frames: int, width: int, height: int, fps: int): """Create a wave text animation.""" img = Image.new('RGB', (width, height), color=(20, 40, 60)) draw = ImageDraw.Draw(img) font_size = max(25, min(55, (width - 2 * 50) // 12)) font = self._get_font(font_size) lines = textwrap.wrap(prompt, width=25) line_height = font_size + 15 for frame_num in range(total_frames): # Wave background for y in range(height): wave = np.sin((frame_num + y * 5) * 0.1) * 20 color_val = int(40 + wave) color = (color_val // 2, color_val, color_val + 20) cv2.rectangle(img, (0, y), (width, y + 1), color, -1) # Wave text y_pos = (height - len(lines) * line_height) // 2 for line_idx, line in enumerate(lines): for char_idx, char in enumerate(line): wave_offset = int(np.sin((frame_num * 0.1 + char_idx * 0.3 + line_idx)) * 10) x_pos = 50 + char_idx * (font_size * 0.6) y_offset = y_pos + line_idx * line_height + wave_offset # Rainbow colors hue = (frame_num * 2 + char_idx * 20 + line_idx * 50) % 360 rgb = colorsys.hsv_to_rgb(hue / 360, 0.8, 1.0) color = tuple(int(c * 255) for c in rgb) draw.text((x_pos, y_offset), char, font=font, fill=color) frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR) out.write(frame) def _get_font(self, size: int): """Get font, fallback to default if custom font not available.""" try: return ImageFont.truetype("arial.ttf", size) except: try: return ImageFont.truetype("/System/Library/Fonts/Arial.ttf", size) except: try: return ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", size) except: return ImageFont.load_default() def generate_pattern_video(self, pattern_type: str, duration: int = 5, fps: int = 24, width: int = 512, height: int = 512) -> str: """Generate abstract pattern videos.""" output_path = os.path.join(self.temp_dir, f"pattern_{int(time.time())}.mp4") fourcc = cv2.VideoWriter_fourcc(*'mp4v') out = cv2.VideoWriter(output_path, fourcc, fps, (width, height)) total_frames = duration * fps try: if pattern_type == "spiral": self._create_spiral_pattern(out, total_frames, width, height) elif pattern_type == "particles": self._create_particle_pattern(out, total_frames, width, height) elif pattern_type == "waves": self._create_wave_pattern(out, total_frames, width, height) elif pattern_type == "fractal": self._create_fractal_pattern(out, total_frames, width, height) else: self._create_spiral_pattern(out, total_frames, width, height) out.release() return output_path except Exception as e: out.release() raise e def _create_spiral_pattern(self, out, total_frames: int, width: int, height: int): """Create animated spiral pattern.""" center_x, center_y = width // 2, height // 2 for frame_num in range(total_frames): frame = np.zeros((height, width, 3), dtype=np.uint8) # Draw spiral max_radius = min(width, height) // 2 points = 500 for i in range(points): t = i * 0.1 radius = (i / points) * max_radius angle = t + frame_num * 0.05 x = int(center_x + radius * np.cos(angle)) y = int(center_y + radius * np.sin(angle)) if 0 <= x < width and 0 <= y < height: hue = (i * 2 + frame_num * 5) % 360 rgb = colorsys.hsv_to_rgb(hue / 360, 1.0, 1.0) color = tuple(int(c * 255) for c in rgb) cv2.circle(frame, (x, y), 3, color, -1) out.write(frame) def _create_particle_pattern(self, out, total_frames: int, width: int, height: int): """Create animated particle system.""" # Initialize particles num_particles = 100 particles = [] for _ in range(num_particles): particles.append({ 'x': np.random.randint(0, width), 'y': np.random.randint(0, height), 'vx': np.random.uniform(-2, 2), 'vy': np.random.uniform(-2, 2), 'size': np.random.randint(2, 8), 'hue': np.random.randint(0, 360) }) for frame_num in range(total_frames): frame = np.zeros((height, width, 3), dtype=np.uint8) # Update and draw particles for particle in particles: # Update position particle['x'] += particle['vx'] particle['y'] += particle['vy'] # Bounce off walls if particle['x'] <= 0 or particle['x'] >= width: particle['vx'] *= -1 if particle['y'] <= 0 or particle['y'] >= height: particle['vy'] *= -1 # Keep in bounds particle['x'] = np.clip(particle['x'], 0, width - 1) particle['y'] = np.clip(particle['y'], 0, height - 1) # Draw particle hue = (particle['hue'] + frame_num * 2) % 360 rgb = colorsys.hsv_to_rgb(hue / 360, 1.0, 1.0) color = tuple(int(c * 255) for c in rgb) cv2.circle(frame, (int(particle['x']), int(particle['y'])), particle['size'], color, -1) # Draw connections for other in particles: dist = np.sqrt((particle['x'] - other['x'])**2 + (particle['y'] - other['y'])**2) if dist < 100 and dist > 0: cv2.line(frame, (int(particle['x']), int(particle['y'])), (int(other['x']), int(other['y'])), (color[0]//3, color[1]//3, color[2]//3), 1) out.write(frame) def _create_wave_pattern(self, out, total_frames: int, width: int, height: int): """Create animated wave pattern.""" for frame_num in range(total_frames): frame = np.zeros((height, width, 3), dtype=np.uint8) # Create wave pattern for y in range(0, height, 5): for x in range(0, width, 5): # Calculate wave height wave1 = np.sin((x * 0.02 + frame_num * 0.05)) * 20 wave2 = np.cos((y * 0.02 + frame_num * 0.03)) * 20 wave3 = np.sin((x * 0.01 + y * 0.01 + frame_num * 0.02)) * 10 intensity = int(128 + wave1 + wave2 + wave3) intensity = np.clip(intensity, 0, 255) # Create color based on waves hue = (intensity + frame_num * 2) % 360 rgb = colorsys.hsv_to_rgb(hue / 360, 0.7, intensity / 255) color = tuple(int(c * 255) for c in rgb) cv2.rectangle(frame, (x, y), (x + 5, y + 5), color, -1) out.write(frame) def _create_fractal_pattern(self, out, total_frames: int, width: int, height: int): """Create animated fractal-like pattern.""" for frame_num in range(total_frames): frame = np.zeros((height, width, 3), dtype=np.uint8) # Create recursive pattern max_depth = 5 self._draw_fractal_tree(frame, width//2, height-50, -90, frame_num * 0.02, max_depth, 80) out.write(frame) def _draw_fractal_tree(self, frame, x, y, angle, time_offset, depth, length): """Recursively draw fractal tree.""" if depth == 0: return # Calculate end point end_x = x + int(length * np.cos(np.radians(angle))) end_y = y + int(length * np.sin(np.radians(angle))) # Color based on depth and time hue = (depth * 60 + time_offset * 50) % 360 rgb = colorsys.hsv_to_rgb(hue / 360, 0.8, 0.8) color = tuple(int(c * 255) for c in rgb) # Draw branch cv2.line(frame, (x, y), (end_x, end_y), color, max(1, depth//2)) # Recursive branches with animation angle_variation = 20 + 10 * np.sin(time_offset) self._draw_fractal_tree(frame, end_x, end_y, angle - angle_variation, time_offset, depth - 1, length * 0.7) self._draw_fractal_tree(frame, end_x, end_y, angle + angle_variation, time_offset, depth - 1, length * 0.7) # Initialize generator generator = CPUVideoGenerator() def generate_video(prompt: str, style: str, duration: int, fps: int, width: int, height: int, video_type: str) -> Tuple[str, str]: """Main video generation function.""" try: if video_type == "Text Animation": video_path = generator.generate_text_video( prompt, duration, fps, style, width, height ) else: # Pattern video_path = generator.generate_pattern_video( style, duration, fps, width, height ) return video_path, "✅ Video generated successfully!" except Exception as e: return None, f"❌ Error: {str(e)}" # Create Gradio interface with gr.Blocks(title="CPU Video Generator", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # 🎬 CPU Video Generator Built with [anycoder](https://huggingface.co/spaces/akhaliq/anycoder) Generate animated videos entirely on CPU! Choose from text animations or abstract patterns. """) with gr.Row(): with gr.Column(): gr.Markdown("### 📝 Input Settings") video_type = gr.Radio( choices=["Text Animation", "Pattern"], value="Text Animation", label="Video Type", info="Choose between text animations or abstract patterns" ) prompt = gr.Textbox( label="Text Prompt (for Text Animation)", placeholder="Enter your text here...", value="Welcome to CPU Video Generation!", lines=3 ) style = gr.Dropdown( choices=["typewriter", "fade", "slide", "glitch", "wave", "spiral", "particles", "waves", "fractal"], value="typewriter", label="Animation Style", info="Choose the animation style" ) with gr.Row(): duration = gr.Slider( minimum=2, maximum=15, value=5, step=1, label="Duration (seconds)" ) fps = gr.Slider( minimum=12, maximum=30, value=24, step=1, label="FPS" ) with gr.Row(): width = gr.Slider( minimum=256, maximum=1024, value=512, step=64, label="Width" ) height = gr.Slider( minimum=256, maximum=1024, value=512, step=64, label="Height" ) generate_btn = gr.Button("🎥 Generate Video", variant="primary", size="lg") with gr.Column(): gr.Markdown("### 📹 Output") video_output = gr.Video( label="Generated Video", autoplay=False, show_download_button=True ) status_output = gr.Textbox( label="Status", interactive=False ) # Examples gr.Markdown("### 💡 Examples") examples = gr.Examples( examples=[ ["Hello World! This is CPU video generation.", "typewriter", 5, 24, 512, 512, "Text Animation"], ["Amazing effects running on CPU only!", "wave", 7, 24, 640, 480, "Text Animation"], ["", "spiral", 5, 24, 512, 512, "Pattern"], ["", "particles", 8, 24, 640, 480, "Pattern"], ["Glitch art with CPU power!", "glitch", 6, 24, 512, 512, "Text Animation"], ["", "fractal", 10, 24, 512, 512, "Pattern"], ], inputs=[prompt, style, duration, fps, width, height, video_type], outputs=[video_output, status_output], fn=generate_video, cache_examples=False ) # Handle video type change def update_visibility(video_type): if video_type == "Text Animation": return gr.update(visible=True), gr.update(choices=["typewriter", "fade", "slide", "glitch", "wave"], value="typewriter") else: return gr.update(visible=False), gr.update(choices=["spiral", "particles", "waves", "fractal"], value="spiral") video_type.change( update_visibility, inputs=[video_type], outputs=[prompt, style] ) # Generate button click generate_btn.click( generate_video, inputs=[prompt, style, duration, fps, width, height, video_type], outputs=[video_output, status_output] ) if __name__ == "__main__": demo.launch(share=True)