Upload 4 files

README.md

@@ -1,7 +1,7 @@
 ---
-title: Image Processing Studio
-emoji: 🎨
-colorFrom: blue
+title: AI Video Ad Generator
+emoji: 🎬
+colorFrom: indigo
 colorTo: purple
 sdk: gradio
 sdk_version: 4.44.0
@@ -10,34 +10,82 @@ pinned: false
 license: mit
 ---
 
-# Image Processing Studio
+# 🎬 AI Video Ad Generator
 
-A fast and simple image processing app built with Gradio. Apply various effects to your images:
+Create professional video advertisements with AI-generated images and custom text overlays in seconds!
 
-- **Grayscale** - Convert to black and white
-- **Blur** - Apply Gaussian blur
-- **Sharpen** - Enhance image sharpness
-- **Brightness** - Adjust brightness levels
-- **Contrast** - Modify contrast
-- **Sepia** - Apply vintage sepia tone
+## ✨ Features
 
-## How to Use
+### 🎨 AI Image Generation
+- Generate high-quality images using Stable Diffusion XL
+- Perfect for product ads, social media posts, and marketing materials
+- Simple prompt-based generation
 
-1. Upload an image
-2. Select an effect
-3. Adjust the intensity slider
-4. Click "Apply Effect"
+### 🎥 Video Ad Creation
+- Upload multiple images or use AI-generated ones
+- Add custom text overlays for each slide
+- Multiple transition effects (Fade, Slide, Zoom)
+- Multiple output formats:
+  - 1920x1080 (Full HD)
+  - 1280x720 (HD)
+  - 1080x1920 (Instagram Story)
+  - 1080x1080 (Instagram Square)
 
-## Local Development
+## 🚀 How to Use
 
-```bash
-pip install -r requirements.txt
-python app.py
-```
+### Step 1: Generate Images (Optional)
+1. Get your Hugging Face API token from [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+2. Enter the token and describe your desired image
+3. Click "Generate Image"
+4. Download or use directly in video creation
 
-## Deploy to Hugging Face Spaces
+### Step 2: Create Video Ad
+1. Upload your images (or use generated ones)
+2. Add text for each slide (one line per slide)
+3. Choose duration, transition effect, and output size
+4. Click "Create Video Ad"
+5. Download your video!
 
-1. Create a new Space on [Hugging Face](https://huggingface.co/new-space)
-2. Choose Gradio as SDK
-3. Upload these files: `app.py`, `requirements.txt`, `README.md`
-4. Your Space will automatically build and deploy!
+## 📋 Example Prompts
+
+- "Modern smartphone on wooden desk, professional photography, 4K"
+- "Delicious pizza with fresh ingredients, food photography, top view"
+- "Luxury car in city at sunset, cinematic lighting"
+- "Happy family using laptop at home, lifestyle photography"
+
+## 🛠️ Technical Details
+
+- **AI Model**: Stable Diffusion XL Base 1.0
+- **Video Processing**: OpenCV + PIL
+- **Formats**: MP4 (H.264)
+- **FPS**: 30
+- **Transitions**: Smooth interpolation
+
+## 📝 Requirements
+
+- Hugging Face API token (free tier available)
+- Images in JPG, PNG format
+- Recommended: 3-5 images for best results
+
+## 🎯 Use Cases
+
+- Social media ads
+- Product promotions
+- Event announcements
+- Brand storytelling
+- Instagram/Facebook content
+- YouTube intros
+
+## 🔒 Privacy
+
+- No data is stored permanently
+- Videos are generated on-demand
+- Your API token is never saved
+
+## 📄 License
+
+MIT License - Feel free to use and modify!
+
+---
+
+Made with ❤️ using Gradio and Hugging Face

app.py

@@ -1,87 +1,302 @@
 import gradio as gr
+import cv2
 import numpy as np
-from PIL import Image, ImageEnhance, ImageFilter
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
+import requests
+import io
+import os
+from datetime import datetime
+import json
 
-def process_image(image, operation, intensity):
-    """Process image with various operations"""
+# Hugging Face API configuration
+HF_API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+
+def generate_ai_image(prompt, hf_token):
+    """Generate image using Hugging Face Stable Diffusion"""
+    if not hf_token:
+        return None, "❌ Please provide your Hugging Face API token"
+    
+    headers = {"Authorization": f"Bearer {hf_token}"}
+    payload = {"inputs": prompt}
+    
+    try:
+        response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=60)
+        if response.status_code == 200:
+            image = Image.open(io.BytesIO(response.content))
+            return image, "✅ Image generated successfully!"
+        else:
+            return None, f"❌ Error: {response.status_code} - {response.text}"
+    except Exception as e:
+        return None, f"❌ Error generating image: {str(e)}"
+
+def add_text_to_image(image, text, position, font_size, text_color, bg_opacity):
+    """Add text overlay to image"""
     if image is None:
         return None
     
-    img = Image.fromarray(image)
+    img = image.copy()
+    draw = ImageDraw.Draw(img, 'RGBA')
     
-    if operation == "Grayscale":
-        img = img.convert("L").convert("RGB")
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
+    except:
+        font = ImageFont.load_default()
     
-    elif operation == "Blur":
-        img = img.filter(ImageFilter.GaussianBlur(radius=intensity))
+    # Get text size
+    bbox = draw.textbbox((0, 0), text, font=font)
+    text_width = bbox[2] - bbox[0]
+    text_height = bbox[3] - bbox[1]
     
-    elif operation == "Sharpen":
-        enhancer = ImageEnhance.Sharpness(img)
-        img = enhancer.enhance(1 + intensity/10)
+    # Calculate position
+    img_width, img_height = img.size
+    if position == "Top":
+        x = (img_width - text_width) // 2
+        y = 50
+    elif position == "Center":
+        x = (img_width - text_width) // 2
+        y = (img_height - text_height) // 2
+    else:  # Bottom
+        x = (img_width - text_width) // 2
+        y = img_height - text_height - 50
     
-    elif operation == "Brightness":
-        enhancer = ImageEnhance.Brightness(img)
-        img = enhancer.enhance(1 + intensity/10)
+    # Draw background rectangle
+    padding = 20
+    bg_color = (0, 0, 0, int(255 * bg_opacity))
+    draw.rectangle(
+        [x - padding, y - padding, x + text_width + padding, y + text_height + padding],
+        fill=bg_color
+    )
+    
+    # Draw text
+    color_map = {
+        "White": (255, 255, 255),
+        "Black": (0, 0, 0),
+        "Red": (255, 0, 0),
+        "Blue": (0, 100, 255),
+        "Yellow": (255, 255, 0)
+    }
+    draw.text((x, y), text, font=font, fill=color_map.get(text_color, (255, 255, 255)))
+    
+    return img
+
+def create_video_ad(images, texts, duration_per_slide, transition_type, output_size, hf_token):
+    """Create video ad from images with text overlays"""
+    if not images or len(images) == 0:
+        return None, "❌ Please provide at least one image"
+    
+    # Parse output size
+    size_map = {
+        "1920x1080 (Full HD)": (1920, 1080),
+        "1280x720 (HD)": (1280, 720),
+        "1080x1920 (Instagram Story)": (1080, 1920),
+        "1080x1080 (Instagram Square)": (1080, 1080)
+    }
+    width, height = size_map[output_size]
+    
+    # Video settings
+    fps = 30
+    frames_per_slide = int(duration_per_slide * fps)
+    transition_frames = 15  # 0.5 seconds
+    
+    # Create video writer
+    output_path = f"/tmp/video_ad_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    total_slides = len(images)
+    
+    # Split texts by newline
+    text_list = [t.strip() for t in texts.split('\n') if t.strip()]
+    
+    for idx, img_input in enumerate(images):
+        # Handle both file paths and PIL images
+        if isinstance(img_input, str):
+            img = Image.open(img_input).convert('RGB')
+        else:
+            img = img_input.convert('RGB')
+        
+        # Resize image
+        img = img.resize((width, height), Image.Resampling.LANCZOS)
+        
+        # Add text overlay if available
+        if idx < len(text_list) and text_list[idx]:
+            overlay = Image.new('RGBA', img.size, (0, 0, 0, 0))
+            draw = ImageDraw.Draw(overlay)
+            
+            try:
+                font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 60)
+            except:
+                font = ImageFont.load_default()
+            
+            # Draw text in center
+            text = text_list[idx]
+            bbox = draw.textbbox((0, 0), text, font=font)
+            text_width = bbox[2] - bbox[0]
+            text_height = bbox[3] - bbox[1]
+            x = (width - text_width) // 2
+            y = (height - text_height) // 2
+            
+            # Background
+            padding = 30
+            draw.rectangle(
+                [x - padding, y - padding, x + text_width + padding, y + text_height + padding],
+                fill=(0, 0, 0, 180)
+            )
+            draw.text((x, y), text, font=font, fill=(255, 255, 255))
+            
+            img = Image.alpha_composite(img.convert('RGBA'), overlay).convert('RGB')
+        
+        # Write main frames
+        for _ in range(frames_per_slide - transition_frames):
+            frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+            out.write(frame)
+        
+        # Add transition
+        if idx < total_slides - 1:
+            next_img_input = images[idx + 1]
+            if isinstance(next_img_input, str):
+                next_img = Image.open(next_img_input).convert('RGB')
+            else:
+                next_img = next_img_input.convert('RGB')
+            next_img = next_img.resize((width, height), Image.Resampling.LANCZOS)
+            
+            for t in range(transition_frames):
+                alpha = t / transition_frames
+                
+                if transition_type == "Fade":
+                    blended = Image.blend(img, next_img, alpha)
+                elif transition_type == "Slide Left":
+                    offset = int(width * alpha)
+                    blended = Image.new('RGB', (width, height))
+                    blended.paste(img, (-offset, 0))
+                    blended.paste(next_img, (width - offset, 0))
+                elif transition_type == "Zoom In":
+                    scale = 1 + alpha * 0.3
+                    scaled = img.resize((int(width * scale), int(height * scale)), Image.Resampling.LANCZOS)
+                    x_offset = (scaled.width - width) // 2
+                    y_offset = (scaled.height - height) // 2
+                    cropped = scaled.crop((x_offset, y_offset, x_offset + width, y_offset + height))
+                    blended = Image.blend(cropped, next_img, alpha * 0.5)
+                else:
+                    blended = next_img
+                
+                frame = cv2.cvtColor(np.array(blended), cv2.COLOR_RGB2BGR)
+                out.write(frame)
     
-    elif operation == "Contrast":
-        enhancer = ImageEnhance.Contrast(img)
-        img = enhancer.enhance(1 + intensity/10)
+    out.release()
     
-    elif operation == "Sepia":
-        img = img.convert("RGB")
-        pixels = np.array(img)
-        tr = 0.393 * pixels[:,:,0] + 0.769 * pixels[:,:,1] + 0.189 * pixels[:,:,2]
-        tg = 0.349 * pixels[:,:,0] + 0.686 * pixels[:,:,1] + 0.168 * pixels[:,:,2]
-        tb = 0.272 * pixels[:,:,0] + 0.534 * pixels[:,:,1] + 0.131 * pixels[:,:,2]
-        pixels[:,:,0] = np.clip(tr, 0, 255)
-        pixels[:,:,1] = np.clip(tg, 0, 255)
-        pixels[:,:,2] = np.clip(tb, 0, 255)
-        img = Image.fromarray(pixels.astype('uint8'))
+    # Get file size
+    file_size = os.path.getsize(output_path) / (1024 * 1024)  # MB
     
-    return np.array(img)
+    return output_path, f"✅ Video created! {total_slides} slides, {duration_per_slide}s each, {file_size:.2f} MB"
 
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Video Ad Generator") as demo:
     gr.Markdown("""
-    # 🎨 Image Processing Studio
-    Upload an image and apply various effects with adjustable intensity.
+    # 🎬 AI Video Ad Generator
+    Create professional video ads with AI-generated images and custom text overlays.
     """)
     
-    with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(label="Upload Image", type="numpy")
-            operation = gr.Radio(
-                choices=["Grayscale", "Blur", "Sharpen", "Brightness", "Contrast", "Sepia"],
-                value="Grayscale",
-                label="Effect"
-            )
-            intensity = gr.Slider(
-                minimum=0,
-                maximum=10,
-                value=5,
-                step=0.5,
-                label="Intensity"
-            )
-            process_btn = gr.Button("Apply Effect", variant="primary")
+    with gr.Tab("🎨 Generate Images"):
+        gr.Markdown("### Generate AI Images for Your Video Ad")
+        with gr.Row():
+            with gr.Column():
+                hf_token_gen = gr.Textbox(
+                    label="Hugging Face API Token",
+                    placeholder="hf_...",
+                    type="password",
+                    info="Get your token from https://huggingface.co/settings/tokens"
+                )
+                image_prompt = gr.Textbox(
+                    label="Image Prompt",
+                    placeholder="e.g., Modern smartphone on wooden desk, professional photography",
+                    lines=3
+                )
+                generate_btn = gr.Button("🎨 Generate Image", variant="primary", size="lg")
+            
+            with gr.Column():
+                generated_image = gr.Image(label="Generated Image", type="pil")
+                gen_status = gr.Textbox(label="Status", interactive=False)
         
-        with gr.Column():
-            output_image = gr.Image(label="Processed Image")
-    
-    gr.Examples(
-        examples=[
-            ["Grayscale", 5],
-            ["Blur", 3],
-            ["Sepia", 5],
-            ["Sharpen", 7],
-        ],
-        inputs=[operation, intensity],
-    )
+        generate_btn.click(
+            fn=generate_ai_image,
+            inputs=[image_prompt, hf_token_gen],
+            outputs=[generated_image, gen_status]
+        )
+        
+        gr.Examples(
+            examples=[
+                ["Modern luxury car on city street, cinematic lighting, 4K"],
+                ["Delicious pizza with fresh ingredients, food photography"],
+                ["Smartphone with glowing screen, tech advertisement"],
+                ["Happy family using laptop at home, lifestyle photography"],
+            ],
+            inputs=[image_prompt]
+        )
     
-    process_btn.click(
-        fn=process_image,
-        inputs=[input_image, operation, intensity],
-        outputs=output_image
-    )
+    with gr.Tab("🎥 Create Video Ad"):
+        gr.Markdown("### Upload Images and Create Your Video Ad")
+        
+        with gr.Row():
+            with gr.Column():
+                input_images = gr.File(
+                    label="Upload Images",
+                    file_count="multiple",
+                    file_types=["image"]
+                )
+                slide_texts = gr.Textbox(
+                    label="Text for Each Slide (one per line)",
+                    placeholder="Slide 1 Text\nSlide 2 Text\nSlide 3 Text",
+                    lines=5
+                )
+                duration = gr.Slider(
+                    minimum=1,
+                    maximum=10,
+                    value=3,
+                    step=0.5,
+                    label="Duration per Slide (seconds)"
+                )
+                transition = gr.Radio(
+                    choices=["Fade", "Slide Left", "Zoom In", "None"],
+                    value="Fade",
+                    label="Transition Effect"
+                )
+                video_size = gr.Radio(
+                    choices=[
+                        "1920x1080 (Full HD)",
+                        "1280x720 (HD)",
+                        "1080x1920 (Instagram Story)",
+                        "1080x1080 (Instagram Square)"
+                    ],
+                    value="1280x720 (HD)",
+                    label="Output Size"
+                )
+                hf_token_video = gr.Textbox(
+                    label="Hugging Face API Token (optional)",
+                    placeholder="hf_...",
+                    type="password"
+                )
+                create_btn = gr.Button("🎬 Create Video Ad", variant="primary", size="lg")
+            
+            with gr.Column():
+                output_video = gr.Video(label="Generated Video Ad")
+                video_status = gr.Textbox(label="Status", interactive=False)
+        
+        create_btn.click(
+            fn=create_video_ad,
+            inputs=[input_images, slide_texts, duration, transition, video_size, hf_token_video],
+            outputs=[output_video, video_status]
+        )
+    
+    gr.Markdown("""
+    ---
+    ### 📝 How to Use:
+    1. **Generate Images**: Enter your HuggingFace API token and describe the image you want
+    2. **Create Video**: Upload your images, add text for each slide, and customize settings
+    3. **Download**: Your video will be ready in seconds!
+    
+    💡 **Tip**: Get a free API token at [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+    """)
 
 if __name__ == "__main__":
     demo.launch()

gitignore

@@ -3,9 +3,44 @@ __pycache__/
 *$py.class
 *.so
 .Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
 env/
 venv/
-.venv/
-*.egg-info/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
 .DS_Store
+Thumbs.db
+
+# Gradio
 flagged/
+/tmp/
+
+# Logs
+*.log

requirements.txt

@@ -1,3 +1,5 @@
 gradio==4.44.0
+opencv-python-headless==4.8.1.78
 numpy==1.24.3
 Pillow==10.0.0
+requests==2.31.0