Video Generation AI Tools

# Runway ML API example for video generation
import requests
import json
import time

class RunwayMLClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.runwayml.com/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def generate_video(self, prompt, duration=4, resolution="512x512"):
        payload = {
            "prompt": prompt,
            "duration": duration,
            "resolution": resolution,
            "model": "gen-2"
        }
        
        response = requests.post(
            f"{self.base_url}/video/generate",
            headers=self.headers,
            json=payload
        )
        
        if response.status_code == 202:
            task_id = response.json()["id"]
            return self.wait_for_completion(task_id)
        else:
            raise Exception(f"API Error: {response.status_code}")
    
    def wait_for_completion(self, task_id, timeout=300):
        start_time = time.time()
        while time.time() - start_time < timeout:
            response = requests.get(
                f"{self.base_url}/tasks/{task_id}",
                headers=self.headers
            )
            
            if response.status_code == 200:
                task_data = response.json()
                status = task_data["status"]
                
                if status == "completed":
                    return task_data["output"]["video_url"]
                elif status == "failed":
                    raise Exception("Video generation failed")
                else:
                    time.sleep(5)
            else:
                raise Exception(f"Task check failed: {response.status_code}")
        
        raise Exception("Video generation timeout")

# Usage example
client = RunwayMLClient("your_api_key_here")
video_url = client.generate_video(
    prompt="A astronaut riding a horse on Mars, cinematic style",
    duration=5,
    resolution="768x768"
)
print(f"Generated video: {video_url}")

# Stable Video Diffusion implementation
import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video
import PIL.Image

# Load the pipeline
pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

# Enable memory efficient attention
pipe.enable_model_cpu_offload()

# Load and prepare input image
image = load_image("https://example.com/input_image.jpg")
image = image.resize((1024, 576))

# Generate video
frames = pipe(
    image,
    decode_chunk_size=8,
    motion_bucket_id=127,
    noise_aug_strength=0.1,
    num_frames=25,
    num_inference_steps=25
).frames[0]

# Export video
export_to_video(frames, "generated_video.mp4", fps=7)

print("Video generated successfully!")

# Good video prompts examples
prompts = [
    # Cinematic style
    "A majestic eagle soaring over snow-capped mountains at sunrise, cinematic wide shot, slow motion, 4K resolution",
    
    # Character animation
    "A robot dancing in a futuristic nightclub, neon lights, dynamic camera movement, smooth animation",
    
    # Nature scene
    "Time-lapse of flowers blooming in a magical forest, ethereal lighting, dreamlike atmosphere",
    
    # Action sequence
    "A superhero landing dramatically on a skyscraper rooftop, rain effects, dramatic lighting, slow-motion impact"
]

// Pika Labs API integration for Discord bot
const axios = require('axios');

class PikaLabsAPI {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseURL = 'https://api.pika.art/v1';
    }

    async generateVideo(prompt, options = {}) {
        const payload = {
            prompt: prompt,
            model: options.model || '1.0',
            duration: options.duration || 3,
            size: options.size || '576x1024'
        };

        try {
            const response = await axios.post(
                `${this.baseURL}/generate`,
                payload,
                {
                    headers: {
                        'Authorization': `Bearer ${this.apiKey}`,
                        'Content-Type': 'application/json'
                    }
                }
            );

            return {
                taskId: response.data.id,
                status: response.data.status,
                estimatedTime: response.data.eta
            };
        } catch (error) {
            throw new Error(`Pika API Error: ${error.response?.data?.message || error.message}`);
        }
    }

    async checkStatus(taskId) {
        try {
            const response = await axios.get(
                `${this.baseURL}/tasks/${taskId}`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.apiKey}`
                    }
                }
            );

            return response.data;
        } catch (error) {
            throw new Error(`Status check failed: ${error.message}`);
        }
    }
}

// Usage example
const pika = new PikaLabsAPI('your_pika_api_key');
const result = await pika.generateVideo(
    'A cat playing piano in a jazz club, cinematic lighting'
);

console.log('Generation started:', result);

# Real-time video style transfer
import cv2
import numpy as np
import torch
from torchvision import transforms

class RealTimeVideoProcessor:
    def __init__(self, model_path):
        self.model = torch.load(model_path)
        self.model.eval()
        self.transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                               std=[0.229, 0.224, 0.225])
        ])
    
    def process_frame(self, frame):
        # Preprocess frame
        input_tensor = self.transform(frame).unsqueeze(0)
        
        # Apply style transfer
        with torch.no_grad():
            output_tensor = self.model(input_tensor)
        
        # Convert back to numpy
        output_frame = self.tensor_to_frame(output_tensor)
        return output_frame
    
    def tensor_to_frame(self, tensor):
        tensor = tensor.squeeze(0).cpu()
        tensor = tensor * torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
        tensor = tensor + torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
        tensor = tensor.clamp(0, 1)
        frame = (tensor.numpy().transpose(1, 2, 0) * 255).astype(np.uint8)
        return frame

# Initialize video capture
cap = cv2.VideoCapture(0)
processor = RealTimeVideoProcessor('style_transfer_model.pth')

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Process frame
    styled_frame = processor.process_frame(frame)
    
    # Display result
    cv2.imshow('Styled Video', styled_frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()