Video Composition

for slide in content_data['slides']:
    slide_num = slide['slide_number']
    
    # Find corresponding script entry
    slide_script = next(
        (s for s in script_data['slide_scripts'] 
         if s['slide_number'] == slide_num),
        None
    )
    
    # Calculate duration from timeline
    duration = slide_script['end_time'] - slide_script['start_time']
    print(f"Processing slide {slide_num}: {duration:.1f}s")

{
  "slide_scripts": [
    {
      "slide_number": 1,
      "narration_text": "Welcome to our presentation...",
      "start_time": 0.0,
      "end_time": 5.2,
      "duration": 5.2
    },
    {
      "slide_number": 2,
      "narration_text": "In this section we explore...",
      "start_time": 5.2,
      "end_time": 11.7,
      "duration": 6.5
    }
  ],
  "total_duration": 35.8
}

def create_slide_video(self, slide_path: str, duration: float) -> VideoFileClip:
    # Handle missing slides gracefully
    if not slide_path or not Path(slide_path).exists():
        print(f"⚠️ Slide path not found, creating blank slide")
        return ColorClip(size=(1920, 1080), color=(20, 20, 40), duration=duration)
    
    # Video files (animations)
    if slide_path.endswith(('.mp4', '.mov', '.avi')):
        video_clip = VideoFileClip(slide_path)
        
        # Adjust duration to match narration
        if video_clip.duration < duration:
            video_clip = video_clip.with_duration(duration)
        elif video_clip.duration > duration:
            video_clip = video_clip.subclipped(0, duration)
        
        return video_clip
    
    # Image files
    else:
        return ImageClip(slide_path, duration=duration)

def composite_animation_on_slide(self, slide_image_path: str, 
                                 animation_video_path: str, 
                                 duration: float) -> VideoFileClip:
    # Load base slide (static image)
    slide_clip = ImageClip(slide_image_path, duration=duration)
    
    # Load animation video
    animation_clip = VideoFileClip(animation_video_path)
    
    # STEP 1: Adjust animation duration
    if animation_clip.duration < duration:
        # Loop animation to fill slide duration
        num_loops = int(duration / animation_clip.duration) + 1
        looped_clips = [animation_clip] * num_loops
        animation_adjusted = concatenate_videoclips(looped_clips, method="compose")
        animation_adjusted = animation_adjusted.subclipped(0, duration)
    else:
        # Trim animation to slide duration
        animation_adjusted = animation_clip.subclipped(0, duration)
    
    # STEP 2: Resize and position animation
    animation_final = animation_adjusted.resized(new_size=(850, 700))
    animation_final = animation_final.with_position((1010, 250))
    
    # STEP 3: Composite layers
    composite = CompositeVideoClip(
        [slide_clip, animation_final],
        size=(1920, 1080)
    )
    
    return composite

print(f"🔗 Concatenating {len(slide_clips)} slide clips...")
final_video = concatenate_videoclips(slide_clips, method="compose")
print(f"Total video duration: {final_video.duration:.1f}s")

if audio_path and Path(audio_path).exists():
    print(f"🎵 Adding audio track...")
    audio = AudioFileClip(audio_path)
    print(f"Audio duration: {audio.duration:.1f}s")
    
    # Warn about synchronization issues
    if abs(final_video.duration - audio.duration) > 0.5:
        print(f"⚠️ Warning: Video duration ({final_video.duration:.1f}s) "
              f"doesn't match audio ({audio.duration:.1f}s)")
    
    final_video = final_video.with_audio(audio)

topic_name = self.sanitize_filename(content_data['topic'], max_length=30)
output_path = Config.FINAL_DIR / f"{topic_name}_final.mp4"

print(f"📹 Writing final video to: {output_path}")
print(f"Resolution: 1920x1080")
print(f"FPS: {Config.MANIM_FPS}")
print(f"Codec: libx264 + aac")

final_video.write_videofile(
    str(output_path),
    fps=Config.MANIM_FPS,        # 30 FPS default
    codec='libx264',             # H.264 video codec
    audio_codec='aac',           # AAC audio codec
    preset='medium',             # Encoding speed/quality balance
    bitrate='5000k',             # 5 Mbps video bitrate
    audio_bitrate='192k'         # 192 kbps audio bitrate
)

workspace/source/data/final/<topic_name>_final.mp4

print(f"🧹 Cleaning up video clips...")
for clip in slide_clips:
    clip.close()
final_video.close()
if audio_path and Path(audio_path).exists():
    audio.close()

print(f"✅ Final video saved: {output_path}")

if not slide_clips:
    raise ValueError("No slide clips were created")

if abs(final_video.duration - audio.duration) > 0.5:
    print(f"⚠️ Warning: Duration mismatch detected")

VIDEO_RESOLUTION = (1920, 1080)  # Full HD (default)
# VIDEO_RESOLUTION = (1280, 720)   # HD
# VIDEO_RESOLUTION = (3840, 2160)  # 4K

ColorClip(size=Config.VIDEO_RESOLUTION, ...)
CompositeVideoClip([...], size=Config.VIDEO_RESOLUTION)

# Default: Right side of slide
animation_final = animation_adjusted.resized(new_size=(850, 700))
animation_final = animation_final.with_position((1010, 250))

# Alternative: Centered
animation_final = animation_adjusted.resized(new_size=(1200, 800))
animation_final = animation_final.with_position(('center', 'center'))