Documentation Index
Fetch the complete documentation index at: https://docs.haus25.live/llms.txt
Use this file to discover all available pages before exploring further.
The video compression pipeline optimizes live streams for permanent storage while maintaining quality suitable for replay and NFT preservation. Using FFmpeg, it processes HLS segments into web-compatible MP4 chunks with efficient encoding settings.
Compression Strategy
Quality vs. Size Optimization
The system balances three key factors:
- Visual Quality: Preserve performance details for NFT value
- File Size: Minimize Filecoin storage costs
- Compatibility: Ensure broad browser and device support
Target Specifications:
- Container: MP4 with
faststart flag for web streaming
- Video Codec: H.264 (libx264) for universal compatibility
- Audio Codec: AAC at 128kbps for clear speech/music
- Resolution: Maintain source resolution (typically 1080p)
- Frame Rate: Preserve original frame rate (usually 30fps)
Encoding Presets: Three quality levels - High (CRF 23, medium preset, 2000k bitrate), Medium (CRF 26, fast preset, 1000k bitrate), Low (CRF 30, faster preset, 500k bitrate).
FFmpeg Pipeline
Segment Concatenation
Input Processing: createVideoChunk function combines 10-second HLS segments into 60-second chunks using FFmpeg concat demuxer with libx264 video, AAC audio, CRF 26, and faststart flag.
Quality Control
Constant Rate Factor (CRF):
CRF provides consistent visual quality across different content types:
- CRF 18-23: Near-lossless, suitable for archival
- CRF 23-28: High quality, good for distribution
- CRF 28-32: Medium quality, smaller files
- CRF 32+: Low quality, minimal bandwidth
Hardware Acceleration
GPU Encoding (when available):
const hwAccelOptions = {
nvidia: ['-c:v', 'h264_nvenc', '-preset', 'fast'],
intel: ['-c:v', 'h264_vaapi', '-vaapi_device', '/dev/dri/renderD128'],
amd: ['-c:v', 'h264_amf'],
apple: ['-c:v', 'h264_videotoolbox']
}
function getHardwareEncoder(): string[] {
const platform = process.platform
const hasNvidia = checkNvidiaGPU()
const hasIntelGPU = checkIntelGPU()
if (hasNvidia) return hwAccelOptions.nvidia
if (platform === 'darwin') return hwAccelOptions.apple
if (hasIntelGPU) return hwAccelOptions.intel
return [] // Fallback to software encoding
}
CPU Optimization
Multi-threading:
function calculateOptimalThreads(): number {
const cpuCores = os.cpus().length
const memoryGB = os.totalmem() / (1024 * 1024 * 1024)
// Reserve cores for other processes
const maxThreads = Math.max(1, cpuCores - 2)
// Memory constraint: ~1GB per thread for 1080p
const memoryLimitedThreads = Math.floor(memoryGB / 1.5)
return Math.min(maxThreads, memoryLimitedThreads, 8)
}
// Apply to FFmpeg command
const threads = calculateOptimalThreads()
ffmpegArgs.push('-threads', threads.toString())
Memory Management
Streaming Processing:
// Process video in streaming mode to handle large files
const streamingOptions = [
'-f', 'mp4',
'-movflags', 'frag_keyframe+empty_moov+faststart',
'-reset_timestamps', '1',
'-avoid_negative_ts', 'make_zero'
]
Quality Analysis
Content-Aware Compression
Motion Detection:
async function analyzeMotion(segmentPath: string): Promise<number> {
const analysis = await execFFmpeg([
'-i', segmentPath,
'-vf', 'select=gt(scene\\,0.3)',
'-f', 'null',
'-'
])
// Parse motion vectors from output
const motionScore = parseMotionAnalysis(analysis.stderr)
return Math.min(1.0, motionScore / 100)
}
Size Optimization
File Size Targets
Storage Cost Considerations:
const storageCostTargets = {
// Target file sizes for different durations (60s chunks)
maxSizes: {
'1080p': 25 * 1024 * 1024, // 25MB for 60s
'720p': 15 * 1024 * 1024, // 15MB for 60s
'480p': 8 * 1024 * 1024 // 8MB for 60s
},
// Filecoin cost per GB/year
storageCostPerGB: 0.10,
// Target: <$1 storage cost per hour of content
targetCostPerHour: 1.00
}
- Storage - How compressed chunks integrate with Filecoin storage
- SRS - Source video streams for compression pipeline
- Retrieval - How compressed content is delivered to users
