Update app.py

app.py

@@ -1,154 +1,590 @@
 import gradio as gr
 import numpy as np
-import random
+import cv2
+import os
+import tempfile
+import time
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+from typing import Tuple, List
+import colorsys
 
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
+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)
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
+# Initialize generator
+generator = CPUVideoGenerator()
 
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
-
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
+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
             )
-
-            run_button = gr.Button("Run", scale=0, variant="primary")
-
-        result = gr.Image(label="Result", show_label=False)
-
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
+        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)}"
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+# 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"
             )
-
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
+            
+            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():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+                duration = gr.Slider(
+                    minimum=2, maximum=15, value=5, step=1,
+                    label="Duration (seconds)"
                 )
-
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+                fps = gr.Slider(
+                    minimum=12, maximum=30, value=24, step=1,
+                    label="FPS"
                 )
-
+            
             with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
+                width = gr.Slider(
+                    minimum=256, maximum=1024, value=512, step=64,
+                    label="Width"
                 )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
+                height = gr.Slider(
+                    minimum=256, maximum=1024, value=512, step=64,
+                    label="Height"
                 )
-
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
+            
+            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"],
         ],
-        outputs=[result, seed],
+        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()
+    demo.launch(share=True)