@farazirfan/costar-server-executor 1.7.37 → 1.7.39

package/skills/longform-video-generation/references/advanced_techniques.md

@@ -0,0 +1,474 @@
+# Advanced Techniques for Veo 3 Video Generation
+
+Advanced workflows and techniques for creating professional-quality long-form videos.
+
+## Custom Transitions
+
+### Crossfade Transitions with FFmpeg
+
+```python
+def add_crossfade_transitions(video_paths, output_path, fade_duration=0.5):
+    """Add smooth crossfade between clips."""
+    
+    if len(video_paths) < 2:
+        return video_paths[0]
+    
+    # Build filter complex
+    inputs = []
+    filters = []
+    
+    for i, path in enumerate(video_paths):
+        inputs.extend(['-i', path])
+    
+    # Create xfade filters
+    current = '[0:v]'
+    for i in range(len(video_paths) - 1):
+        next_input = f'[{i+1}:v]'
+        output = f'[v{i}]' if i < len(video_paths) - 2 else '[vout]'
+        
+        # Calculate offset
+        probe = ffmpeg.probe(video_paths[i])
+        duration = float(probe['streams'][0]['duration'])
+        offset = duration - fade_duration
+        
+        filters.append(
+            f'{current}{next_input}xfade=transition=fade:'
+            f'duration={fade_duration}:offset={offset}{output}'
+        )
+        current = output
+    
+    # Execute
+    cmd = ['ffmpeg'] + inputs + [
+        '-filter_complex', ';'.join(filters),
+        '-map', '[vout]',
+        '-y', output_path
+    ]
+    
+    subprocess.run(cmd, check=True)
+    return output_path
+```
+
+### Other Transition Types
+
+FFmpeg xfade supports many transitions:
+- `fade` - Simple crossfade
+- `wipeleft`, `wiperight`, `wipeup`, `wipedown` - Directional wipes
+- `slideleft`, `slideright` - Slide transitions
+- `dissolve` - Dissolve effect
+- `pixelize` - Pixelation transition
+
+## Batch Processing
+
+### Process Multiple Projects
+
+```python
+def batch_generate_projects(projects):
+    """Generate multiple video projects in sequence."""
+    
+    results = []
+    
+    for project in projects:
+        try:
+            video_path = generate_longform_video(
+                scenes=project['scenes'],
+                output_filename=f"{project['name']}.mp4",
+                use_frame_chaining=True
+            )
+            
+            results.append({
+                'name': project['name'],
+                'status': 'success',
+                'path': video_path
+            })
+            
+        except Exception as e:
+            results.append({
+                'name': project['name'],
+                'status': 'failed',
+                'error': str(e)
+            })
+    
+    return results
+
+# Usage
+projects = [
+    {
+        'name': 'product_demo_1',
+        'scenes': [...]
+    },
+    {
+        'name': 'product_demo_2',
+        'scenes': [...]
+    }
+]
+
+results = batch_generate_projects(projects)
+```
+
+### Parallel Processing (with Rate Limiting)
+
+```python
+import concurrent.futures
+import time
+from threading import Lock
+
+rate_limit_lock = Lock()
+last_request_time = 0
+MIN_REQUEST_INTERVAL = 6  # seconds (10 requests per minute)
+
+def rate_limited_generate(scene, scene_num):
+    """Generate with rate limiting."""
+    global last_request_time
+    
+    with rate_limit_lock:
+        current_time = time.time()
+        elapsed = current_time - last_request_time
+        
+        if elapsed < MIN_REQUEST_INTERVAL:
+            time.sleep(MIN_REQUEST_INTERVAL - elapsed)
+        
+        last_request_time = time.time()
+    
+    # Generate video
+    return generate_single_video(scene, scene_num)
+
+def parallel_generate(scenes, max_workers=2):
+    """Generate multiple scenes in parallel with rate limiting."""
+    
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [
+            executor.submit(rate_limited_generate, scene, i)
+            for i, scene in enumerate(scenes)
+        ]
+        
+        results = [f.result() for f in concurrent.futures.as_completed(futures)]
+    
+    return results
+```
+
+## Character Consistency Patterns
+
+### Using Character Templates
+
+```python
+class CharacterTemplate:
+    """Template for maintaining character consistency."""
+    
+    def __init__(self, name, age, appearance, clothing, style):
+        self.name = name
+        self.age = age
+        self.appearance = appearance
+        self.clothing = clothing
+        self.style = style
+    
+    def get_description(self):
+        """Get full character description."""
+        return (
+            f"{self.name}, {self.age}, "
+            f"{self.appearance}, "
+            f"wearing {self.clothing}"
+        )
+    
+    def create_scene_prompt(self, action):
+        """Create scene prompt with character."""
+        return f"{self.get_description()}, {self.style}. {action}"
+
+# Usage
+character = CharacterTemplate(
+    name="Sarah",
+    age="25 years old",
+    appearance="shoulder-length dark hair, warm brown eyes",
+    clothing="red leather jacket and blue jeans",
+    style="cinematic lighting, 35mm lens, golden hour"
+)
+
+scenes = [
+    character.create_scene_prompt("Walking through park"),
+    character.create_scene_prompt("Sitting on bench"),
+    character.create_scene_prompt("Looking at phone")
+]
+```
+
+### Style Anchoring
+
+```python
+class StyleAnchor:
+    """Maintain consistent visual style across scenes."""
+    
+    def __init__(self):
+        self.lighting = None
+        self.camera = None
+        self.color_grade = None
+        self.mood = None
+    
+    def set_style(self, lighting, camera, color_grade, mood):
+        self.lighting = lighting
+        self.camera = camera
+        self.color_grade = color_grade
+        self.mood = mood
+    
+    def apply_to_prompt(self, base_prompt):
+        """Apply style to any prompt."""
+        style_str = ", ".join([
+            self.lighting,
+            self.camera,
+            self.color_grade,
+            self.mood
+        ])
+        return f"{base_prompt}, {style_str}"
+
+# Usage
+style = StyleAnchor()
+style.set_style(
+    lighting="soft natural light",
+    camera="handheld 35mm",
+    color_grade="warm tones",
+    mood="nostalgic atmosphere"
+)
+
+prompt = "Woman walking through field"
+styled_prompt = style.apply_to_prompt(prompt)
+# Result: "Woman walking through field, soft natural light, handheld 35mm, warm tones, nostalgic atmosphere"
+```
+
+## Quality Control
+
+### Automatic Quality Checks
+
+```python
+def check_video_quality(video_path):
+    """Check video for quality issues."""
+    
+    issues = []
+    
+    # Check duration
+    probe = ffmpeg.probe(video_path)
+    duration = float(probe['streams'][0]['duration'])
+    
+    if duration < 7:
+        issues.append("Video too short (< 7s)")
+    
+    # Check resolution
+    width = probe['streams'][0]['width']
+    height = probe['streams'][0]['height']
+    
+    if width < 1280:
+        issues.append(f"Low resolution: {width}x{height}")
+    
+    # Check for audio
+    audio_streams = [s for s in probe['streams'] if s['codec_type'] == 'audio']
+    if not audio_streams:
+        issues.append("No audio track found")
+    
+    # Check file size
+    file_size = os.path.getsize(video_path)
+    if file_size < 100000:  # < 100KB
+        issues.append("File suspiciously small")
+    
+    return issues
+
+# Usage
+issues = check_video_quality("scene_001.mp4")
+if issues:
+    print(f"⚠️  Quality issues: {issues}")
+    # Regenerate or adjust
+```
+
+### Frame Similarity Check
+
+```python
+import cv2
+import numpy as np
+
+def check_frame_continuity(video1_path, video2_path):
+    """Check if last frame of video1 matches first frame of video2."""
+    
+    # Extract frames
+    cap1 = cv2.VideoCapture(video1_path)
+    cap1.set(cv2.CAP_PROP_POS_AVI_RATIO, 1)  # Go to end
+    ret1, frame1 = cap1.read()
+    
+    cap2 = cv2.VideoCapture(video2_path)
+    ret2, frame2 = cap2.read()
+    
+    if not (ret1 and ret2):
+        return False
+    
+    # Calculate similarity (structural similarity)
+    gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+    
+    # Resize to same size if needed
+    if gray1.shape != gray2.shape:
+        gray2 = cv2.resize(gray2, (gray1.shape[1], gray1.shape[0]))
+    
+    # Calculate MSE (Mean Squared Error)
+    mse = np.mean((gray1 - gray2) ** 2)
+    
+    # Low MSE means high similarity
+    return mse < 1000  # Threshold may need tuning
+```
+
+## Cost Optimization
+
+### Preview Mode (Lower Cost Testing)
+
+```python
+def generate_preview(scenes, output_filename="preview.mp4"):
+    """Generate preview with every Nth scene only."""
+    
+    # Sample scenes (e.g., every 3rd scene)
+    preview_scenes = scenes[::3]
+    
+    print(f"📊 Generating preview with {len(preview_scenes)}/{len(scenes)} scenes")
+    
+    return generate_longform_video(
+        scenes=preview_scenes,
+        output_filename=output_filename,
+        use_frame_chaining=False  # Faster, lower quality
+    )
+```
+
+### Caching Strategy
+
+```python
+import hashlib
+import pickle
+
+def get_cache_key(prompt, reference_image=None):
+    """Generate cache key for a scene."""
+    data = f"{prompt}:{reference_image or ''}"
+    return hashlib.md5(data.encode()).hexdigest()
+
+def cache_video(key, video_path, cache_dir="./cache"):
+    """Cache a generated video."""
+    os.makedirs(cache_dir, exist_ok=True)
+    cache_path = os.path.join(cache_dir, f"{key}.mp4")
+    subprocess.run(["cp", video_path, cache_path], check=True)
+
+def get_cached_video(key, cache_dir="./cache"):
+    """Retrieve cached video if exists."""
+    cache_path = os.path.join(cache_dir, f"{key}.mp4")
+    return cache_path if os.path.exists(cache_path) else None
+
+# Usage in generation workflow
+def generate_with_cache(prompt, reference_image=None):
+    key = get_cache_key(prompt, reference_image)
+    
+    # Check cache
+    cached = get_cached_video(key)
+    if cached:
+        print(f"✅ Using cached video for: {prompt[:50]}...")
+        return cached
+    
+    # Generate
+    video = generate_single_video(prompt, reference_image)
+    
+    # Cache result
+    cache_video(key, video)
+    
+    return video
+```
+
+## Integration with Other Tools
+
+### Export to Editing Software
+
+```python
+def export_edl(scenes, output_path="timeline.edl"):
+    """Export Edit Decision List for professional editing software."""
+    
+    with open(output_path, 'w') as f:
+        f.write("TITLE: Veo 3 Generated Sequence\n")
+        f.write("FCM: NON-DROP FRAME\n\n")
+        
+        timecode = 0
+        
+        for i, scene in enumerate(scenes):
+            source_in = "00:00:00:00"
+            source_out = "00:00:08:00"  # 8 seconds
+            
+            rec_in = f"{timecode//3600:02d}:{(timecode%3600)//60:02d}:{timecode%60:02d}:00"
+            timecode += 8
+            rec_out = f"{timecode//3600:02d}:{(timecode%3600)//60:02d}:{timecode%60:02d}:00"
+            
+            f.write(f"{i+1:03d}  scene_{i+1:03d}  V     C        "
+                   f"{source_in} {source_out} {rec_in} {rec_out}\n")
+```
+
+### Add Subtitles/Captions
+
+```python
+def add_subtitles(video_path, subtitle_text, output_path):
+    """Burn subtitles into video."""
+    
+    # Create SRT file
+    srt_path = video_path.replace('.mp4', '.srt')
+    with open(srt_path, 'w') as f:
+        f.write("1\n")
+        f.write("00:00:00,000 --> 00:00:08,000\n")
+        f.write(f"{subtitle_text}\n")
+    
+    # Burn into video
+    subprocess.run([
+        'ffmpeg',
+        '-i', video_path,
+        '-vf', f"subtitles={srt_path}",
+        '-y', output_path
+    ], check=True)
+```
+
+## Production Workflow Template
+
+```python
+class VideoProduction:
+    """Complete production workflow manager."""
+    
+    def __init__(self, project_name):
+        self.project_name = project_name
+        self.scenes = []
+        self.character = None
+        self.style = None
+    
+    def set_character(self, description):
+        self.character = description
+    
+    def set_style(self, style):
+        self.style = style
+    
+    def add_scene(self, action):
+        prompt = f"{self.character}, {self.style}. {action}"
+        self.scenes.append(prompt)
+    
+    def generate_preview(self):
+        """Generate low-cost preview."""
+        preview_scenes = self.scenes[::3]
+        return generate_longform_video(
+            preview_scenes,
+            f"{self.project_name}_preview.mp4"
+        )
+    
+    def generate_final(self):
+        """Generate final high-quality video."""
+        return generate_longform_video(
+            self.scenes,
+            f"{self.project_name}_final.mp4",
+            use_frame_chaining=True,
+            add_transitions=True
+        )
+
+# Usage
+project = VideoProduction("corporate_intro")
+project.set_character("Professional woman in business attire")
+project.set_style("corporate, clean lighting, modern")
+
+project.add_scene("Walking into office building")
+project.add_scene("Greeting receptionist")
+project.add_scene("Entering conference room")
+
+# Test with preview
+preview = project.generate_preview()
+
+# If approved, generate final
+final = project.generate_final()
+```