Skip to main content

Export Formats Overview

Choose the export format that best fits your target platform and quality requirements:

🎬 Standard Formats

H.264 MP4, VP9 WebM - Universal compatibility

🎯 Professional Formats

ProRes MOV, PNG Sequence - Maximum quality

Standard Formats

Universal compatibility with excellent compression:
import { EncoderProfile } from '@videobgremover/sdk'

// High quality (default)
await comp.toFile('output.mp4', EncoderProfile.h264())

// Custom quality settings
await comp.toFile('hq.mp4', EncoderProfile.h264({ 
  crf: 18,        // Higher quality (lower CRF = better quality)
  preset: 'slow'  // Slower encoding, better compression
}))

// Fast encoding for testing
await comp.toFile('test.mp4', EncoderProfile.h264({ 
  crf: 28,           // Lower quality for speed
  preset: 'ultrafast' // Fastest encoding
}))

VP9 WebM

Excellent compression for web delivery:
// VP9 WebM (excellent compression)
await comp.toFile('output.webm', EncoderProfile.vp9())

// Custom VP9 settings
await comp.toFile('web.webm', EncoderProfile.vp9({ 
  crf: 32,      // Good quality for web
  preset: 'fast' // Reasonable encoding speed
}))

Professional Formats

ProRes 4444 MOV

Highest quality for professional editing:
// ProRes 4444 (highest quality, large files)
await comp.toFile('professional.mov', EncoderProfile.prores4444())

// Best for: Final Cut Pro, Premiere Pro, DaVinci Resolve

PNG Sequence

Frame-by-frame output for maximum quality:
// PNG sequence (one file per frame)
await comp.toFile('frames/frame_%04d.png', EncoderProfile.pngSequence())

// Custom frame rate
await comp.toFile('frames/frame_%04d.png', EncoderProfile.pngSequence({ 
  fps: 24  // 24 FPS output
}))

// Creates: frame_0001.png, frame_0002.png, frame_0003.png, ...

Quality Settings

Classic FFmpeg Parameters

The SDK uses standard FFmpeg encoder parameters for professional control:

CRF (Constant Rate Factor)

Controls quality vs file size trade-off (lower = higher quality):
CRFQualityUse CaseCode Implementation
12-18ExcellentProfessional work, archivalEncoderProfile.h264({ crf: 18 })
19-23HighGeneral purpose, good balanceEncoderProfile.h264({ crf: 23 })
24-28GoodWeb delivery, smaller filesEncoderProfile.h264({ crf: 28 })
29-35AcceptableVery small files, previewsEncoderProfile.h264({ crf: 32 })

Encoding Presets

Balance encoding speed vs compression efficiency:
PresetSpeedFile SizeUse CaseFFmpeg Args
ultrafastFastestLargestTesting, previews-preset ultrafast
fastFastLargeDevelopment-preset fast
mediumModerateModerateGeneral purpose-preset medium
slowSlowSmallFinal delivery-preset slow
veryslowSlowestSmallestArchival, maximum compression-preset veryslow

Codec Selection

Different codecs for different use cases:
  • H.264: Universal compatibility (-c:v libx264)
  • VP9: Web optimization (-c:v libvpx-vp9)
  • ProRes: Professional editing (-c:v prores_ks)
  • PNG: Frame sequences (-c:v png)

Pixel Formats

Control color space and transparency:
  • yuv420p: Standard video (no alpha)
  • yuva420p: Video with alpha channel
  • rgba: PNG sequences with transparency

Format Recommendations

Choose by Use Case

Use H.264 MP4 - Universal browser support
EncoderProfile.h264({ crf: 28, preset: 'fast' })
Alternative: VP9 WebM for better compression
Use H.264 MP4 - Platform compatibility
EncoderProfile.h264({ crf: 25, preset: 'medium' })
Consider platform-specific requirements (Instagram, TikTok, etc.)
Use ProRes 4444 MOV - Highest quality
EncoderProfile.prores4444()
Perfect for Final Cut Pro, Premiere Pro, DaVinci Resolve
Use PNG Sequence - Individual frames
EncoderProfile.pngSequence({ fps: 30 })
Perfect for GIF creation, frame-by-frame work

Multiple Export Example

Export the same composition in different formats:
// Create composition once
const comp = new Composition(background)
comp.add(video1, 'main').at(Anchor.CENTER)
comp.add(video2, 'pip').at(Anchor.TOP_RIGHT).size(SizeMode.CANVAS_PERCENT, { percent: 25 })

// Export in multiple formats
await comp.toFile('web_delivery.mp4', EncoderProfile.h264({ crf: 28 }))
await comp.toFile('high_quality.mp4', EncoderProfile.h264({ crf: 18, preset: 'slow' }))
await comp.toFile('web_optimized.webm', EncoderProfile.vp9({ crf: 32 }))
await comp.toFile('professional.mov', EncoderProfile.prores4444())
await comp.toFile('frames/frame_%04d.png', EncoderProfile.pngSequence())

Progress Tracking

Monitor export progress:
const progressCallback = (status: string) => {
  console.log(`Export status: ${status}`)
}

await comp.toFile('output.mp4', EncoderProfile.h264(), progressCallback)

Debugging

Dry Run

See the FFmpeg command without executing:
// See the FFmpeg command that would be executed
const command = comp.dryRun()
console.log('FFmpeg command:', command)

Verbose Output

See FFmpeg output in real-time:
// Show FFmpeg output for debugging
await comp.toFile('output.mp4', EncoderProfile.h264(), undefined, true) // verbose=true

File Size Comparison

Approximate file sizes for a 30-second 1080p composition:
FormatQualityFile SizeUse Case
H.264 CRF 18Excellent~50MBProfessional delivery
H.264 CRF 23High~25MBGeneral purpose
H.264 CRF 28Good~15MBWeb delivery
VP9 CRF 32Good~10MBWeb optimized
ProRes 4444Perfect~500MBProfessional editing
PNG SequencePerfect~200MBFrame-by-frame work

Platform-Specific Recommendations

Social Media Platforms

// Instagram feed/reels
await comp.toFile('instagram.mp4', EncoderProfile.h264({ 
  crf: 25, 
  preset: 'medium' 
}))

Web Applications

// Web player (balance of quality and size)
await comp.toFile('web_player.mp4', EncoderProfile.h264({ 
  crf: 26, 
  preset: 'medium' 
}))

// Background video (lower quality acceptable)
await comp.toFile('bg_video.mp4', EncoderProfile.h264({ 
  crf: 30, 
  preset: 'fast' 
}))

// Hero video (high quality)
await comp.toFile('hero.mp4', EncoderProfile.h264({ 
  crf: 22, 
  preset: 'slow' 
}))

Advanced Export Options

Implementation Details

The SDK implements classic FFmpeg parameters through the EncoderProfile class:
// See what arguments the encoder generates
const encoder = EncoderProfile.h264({ crf: 20 })
const args = encoder.args('output.mp4')
console.log('FFmpeg args:', args)

// Modify if needed (advanced)
// Note: Direct FFmpeg argument modification not exposed in current SDK

Batch Export

Export multiple versions efficiently:
const exports = [
  { name: 'preview.mp4', encoder: EncoderProfile.h264({ crf: 30, preset: 'ultrafast' }) },
  { name: 'final.mp4', encoder: EncoderProfile.h264({ crf: 20, preset: 'slow' }) },
  { name: 'web.webm', encoder: EncoderProfile.vp9({ crf: 28 }) }
]

for (const exp of exports) {
  console.log(`Exporting ${exp.name}...`)
  await comp.toFile(exp.name, exp.encoder)
}

Performance Tips

Optimize Export Speed

  • Use ultrafast preset for testing
  • Use lower resolution for previews
  • Export final quality only when composition is finalized

Optimize File Size

  • Use VP9 WebM for smallest files
  • Increase CRF value (lower quality) for smaller files
  • Use slow or veryslow preset for better compression

Memory Management

  • Export long compositions in segments
  • Use appropriate quality settings for your target
  • Clean up intermediate files

What’s Next?