1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// ================================================================
// WHY TRANSCODING IS COMPUTATIONALLY EXPENSIVE
// ================================================================
 
// Video encoding is essentially a massive optimization problem:
// "Find the minimum bits to represent this video with acceptable quality"
 
// For each frame, the encoder must:
// 1. Analyze motion between frames (motion estimation) - O(n²) per block
// 2. Decide block partitioning (quad-tree in HEVC) - exponential choices
// 3. Apply transform coding (DCT/wavelet) - O(n log n) per block
// 4. Optimize quantization decisions - rate-distortion optimization
// 5. Apply entropy coding (CABAC/CAVLC) - sequential, hard to parallelize
 
// Approximate CPU cycles per encoded frame at 1080p:
// 
// Codec       | CPU Cycles/Frame | Encode Speed (software) | Compression
// ------------|------------------|-------------------------|-------------
// H.264       | ~50 billion      | 30-60 fps              | Baseline
// H.265/HEVC  | ~150 billion     | 5-15 fps               | 30-50% better
// VP9         | ~120 billion     | 8-20 fps               | 30-40% better
// AV1         | ~500 billion     | 0.5-2 fps              | 50-60% better
 
// At 30 fps, 1080p, that's:
// H.264: 50B × 30 = 1.5 trillion cycles/second
// AV1: 500B × 30 = 15 trillion cycles/second
 
// A high-end CPU might deliver 200 billion cycles/second
// → H.264 software encoding is roughly 7-10x realtime
// → AV1 software encoding is roughly 75-100x realtime
 
// This is why:
// 1. Hardware encoders (NVENC, QuickSync) are common for fast encoding
// 2. Distributed encoding is mandatory at scale
// 3. Newer codecs (AV1) require careful cost-benefit analysis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

interface EncodingProfile {
  resolution: { width: number; height: number };
  videoBitrate: { min: number; max: number; target: number };
  audioBitrate: number;
  frameRate: { source: boolean; max: number };
  keyframeInterval: number;  // seconds
  codec: 'h264' | 'h265' | 'vp9' | 'av1';
  profile: string;
  level?: string;
}
 
interface EncodingLadder {
  name: string;
  profiles: EncodingProfile[];
}
 
// Standard ladder for most content
const STANDARD_LADDER: EncodingLadder = {
  name: 'standard',
  profiles: [
    // 4K variants (if source supports)
    {
      resolution: { width: 3840, height: 2160 },
      videoBitrate: { min: 15000, max: 45000, target: 25000 },
      audioBitrate: 192,
      frameRate: { source: true, max: 60 },
      keyframeInterval: 2,
      codec: 'vp9',
      profile: 'profile0',
    },
    // 1080p variants
    {
      resolution: { width: 1920, height: 1080 },
      videoBitrate: { min: 3000, max: 8000, target: 5000 },
      audioBitrate: 128,
      frameRate: { source: true, max: 60 },
      keyframeInterval: 2,
      codec: 'h264',
      profile: 'high',
      level: '4.1',
    },
    {
      resolution: { width: 1920, height: 1080 },
      videoBitrate: { min: 2500, max: 6000, target: 4000 },
      audioBitrate: 128,
      frameRate: { source: true, max: 60 },
      keyframeInterval: 2,
      codec: 'vp9',
      profile: 'profile0',
    },
    // 720p variants
    {
      resolution: { width: 1280, height: 720 },
      videoBitrate: { min: 1500, max: 5000, target: 2500 },
      audioBitrate: 128,
      frameRate: { source: true, max: 60 },
      keyframeInterval: 2,
      codec: 'h264',
      profile: 'main',
    },
    // ... lower resolutions
  ],
};
 
// Per-title encoding: optimize ladder per video
function generateOptimizedLadder(
  sourceInfo: MediaInfo,
  contentAnalysis: ContentAnalysis
): EncodingLadder {
  const ladder: EncodingProfile[] = [];
  
  // Don't upscale: max resolution is source resolution
  const maxResolution = {
    width: sourceInfo.width,
    height: sourceInfo.height,
  };
  
  // Analyze content complexity for bitrate optimization
  const complexity = contentAnalysis.motionComplexity; // 0-1 scale
  const isAnimation = contentAnalysis.isAnimated;
  const hasFilmGrain = contentAnalysis.hasFilmGrain;
  
  for (const template of STANDARD_LADDER.profiles) {
    // Skip resolutions higher than source
    if (template.resolution.height > maxResolution.height) continue;
    
    // Adjust bitrate based on content characteristics
    let bitrateMultiplier = 1.0;
    
    if (complexity < 0.3) {
      // Low motion content (talking head, slides) needs less bitrate
      bitrateMultiplier = 0.7;
    } else if (complexity > 0.8) {
      // High motion content (sports, action) needs more bitrate
      bitrateMultiplier = 1.3;
    }
    
    if (isAnimation) {
      // Animation typically compresses better
      bitrateMultiplier *= 0.8;
    }
    
    if (hasFilmGrain) {
      // Film grain is hard to compress, increase bitrate
      bitrateMultiplier *= 1.2;
    }
    
    ladder.push({
      ...template,
      videoBitrate: {
        min: template.videoBitrate.min * bitrateMultiplier,
        max: template.videoBitrate.max * bitrateMultiplier,
        target: template.videoBitrate.target * bitrateMultiplier,
      },
    });
  }
  
  return { name: 'per-title', profiles: ladder };
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

┌─────────────────────────────────────────────────────────────────────────────────┐
│                      DISTRIBUTED TRANSCODING PIPELINE                            │
└─────────────────────────────────────────────────────────────────────────────────┘
 
╔═════════════════╗
║  Processing     ║     ┌─────────────────────────────────────────────────────────┐
║  Request Queue  ╠════▶│              ORCHESTRATOR SERVICE                       │
╚═════════════════╝     │  • Job planning & splitting                             │
                        │  • Segment scheduling                                    │
                        │  • Progress aggregation                                  │
                        │  • Failure handling                                      │
                        └─────────────────────────────────────────────────────────┘
                                              │
                                              │ Create encoding jobs
                                              ▼
                        ┌─────────────────────────────────────────────────────────┐
                        │                   JOB DATABASE                           │
                        │  • Video-level jobs                                      │
                        │  • Segment-level tasks                                   │
                        │  • Rendition tracking                                    │
                        └─────────────────────────────────────────────────────────┘
                                              │
                        ┌─────────────────────┼─────────────────────┐
                        ▼                     ▼                     ▼
               ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
               │  Segment    │       │  Segment    │       │  Segment    │
               │  Queue #1   │       │  Queue #2   │       │  Queue #N   │
               │  (Priority) │       │  (Normal)   │       │  (Batch)    │
               └──────┬──────┘       └──────┬──────┘       └──────┬──────┘
                      │                     │                     │
     ┌────────────────┼─────────────────────┼─────────────────────┼─────────────┐
     ▼                ▼                     ▼                     ▼             ▼
┌─────────┐     ┌─────────┐           ┌─────────┐           ┌─────────┐   ┌─────────┐
│ Worker  │     │ Worker  │    ...    │ Worker  │    ...    │ Worker  │   │ Worker  │
│ Node 1  │     │ Node 2  │           │ Node N  │           │ GPU 1   │   │ GPU M   │
│ (CPU)   │     │ (CPU)   │           │ (CPU)   │           │(NVENC)  │   │(NVENC)  │
└────┬────┘     └────┬────┘           └────┬────┘           └────┬────┘   └────┬────┘
     │               │                     │                     │             │
     └───────────────┴─────────────────────┴─────────────────────┴─────────────┘
                                              │
                                              ▼
                        ┌─────────────────────────────────────────────────────────┐
                        │              SEGMENT STORAGE (Temporary)                 │
                        │  • Encoded segments per rendition                        │
                        │  • Intermediate files                                    │
                        └─────────────────────────────────────────────────────────┘
                                              │
                                              │ All segments complete
                                              ▼
                        ┌─────────────────────────────────────────────────────────┐
                        │                 PACKAGER SERVICE                         │
                        │  • Concatenate segments                                  │
                        │  • Generate manifests (HLS, DASH)                        │
                        │  • DRM encryption                                        │
                        └─────────────────────────────────────────────────────────┘
                                              │
                                              ▼
                        ┌─────────────────────────────────────────────────────────┐
                        │              FINAL STORAGE (Permanent)                   │
                        │  • Origin storage for CDN                                │
                        │  • Multi-region replication                              │
                        └─────────────────────────────────────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

interface SegmentTask {
  videoId: string;
  renditionId: string;
  segmentIndex: number;
  
  // Source specification
  source: {
    location: StorageLocation;
    startTime: number;     // seconds
    duration: number;      // seconds
    keyframeAligned: boolean;
  };
  
  // Encoding specification
  encoding: EncodingProfile;
  
  // Output specification
  output: {
    location: StorageLocation;
    format: 'ts' | 'fmp4' | 'webm';
  };
}
 
// Orchestrator: split video into segments
async function planSegmentedEncoding(
  videoId: string,
  sourceInfo: MediaInfo,
  ladder: EncodingLadder
): Promise<SegmentTask[]> {
  const tasks: SegmentTask[] = [];
  
  // Target segment duration (in seconds)
  const TARGET_SEGMENT_DURATION = 4; // 4-second segments common for HLS/DASH
  
  // Find keyframe positions for segment boundaries
  const keyframes = await extractKeyframePositions(sourceInfo.location);
  
  // Align segments to keyframes for seamless concatenation
  const segmentBoundaries = alignToKeyframes(
    keyframes,
    sourceInfo.duration,
    TARGET_SEGMENT_DURATION
  );
  
  // Create tasks for each segment × rendition combination
  for (const profile of ladder.profiles) {
    const renditionId = generateRenditionId(videoId, profile);
    
    for (let i = 0; i < segmentBoundaries.length - 1; i++) {
      const startTime = segmentBoundaries[i];
      const endTime = segmentBoundaries[i + 1];
      
      tasks.push({
        videoId,
        renditionId,
        segmentIndex: i,
        source: {
          location: sourceInfo.location,
          startTime,
          duration: endTime - startTime,
          keyframeAligned: true,
        },
        encoding: profile,
        output: {
          location: generateSegmentOutputPath(videoId, renditionId, i),
          format: 'fmp4', // Fragmented MP4 for DASH compatibility
        },
      });
    }
  }
  
  return tasks;
}
 
// Worker: encode a single segment
async function encodeSegment(task: SegmentTask): Promise<SegmentResult> {
  const startTime = Date.now();
  
  try {
    // 1. Download source segment (only the needed portion)
    const sourceSegment = await downloadRange(
      task.source.location,
      task.source.startTime,
      task.source.duration
    );
    
    // 2. Build FFmpeg command
    const ffmpegArgs = buildEncodingCommand(task, sourceSegment);
    
    // 3. Execute encoding
    const encodedData = await executeFFmpeg(ffmpegArgs);
    
    // 4. Upload encoded segment
    const uploadResult = await uploadSegment(task.output.location, encodedData);
    
    // 5. Calculate quality metrics
    const qualityMetrics = await calculateQualityMetrics(
      sourceSegment,
      encodedData,
      task.encoding
    );
    
    return {
      success: true,
      videoId: task.videoId,
      renditionId: task.renditionId,
      segmentIndex: task.segmentIndex,
      outputLocation: task.output.location,
      sizeBytes: encodedData.byteLength,
      encodingDuration: Date.now() - startTime,
      qualityMetrics,
    };
    
  } catch (error) {
    return {
      success: false,
      videoId: task.videoId,
      renditionId: task.renditionId,
      segmentIndex: task.segmentIndex,
      error: error.message,
    };
  }
}
 
function buildEncodingCommand(
  task: SegmentTask,
  inputPath: string
): string[] {
  const args: string[] = ['-y']; // Overwrite output
  
  // Input
  args.push('-ss', task.source.startTime.toString());
  args.push('-t', task.source.duration.toString());
  args.push('-i', inputPath);
  
  // Video encoding
  if (task.encoding.codec === 'h264') {
    args.push('-c:v', 'libx264');
    args.push('-preset', 'medium'); // Balance speed/quality
    args.push('-profile:v', task.encoding.profile);
    if (task.encoding.level) args.push('-level', task.encoding.level);
    args.push('-b:v', `${task.encoding.videoBitrate.target}k`);
    args.push('-maxrate', `${task.encoding.videoBitrate.max}k`);
    args.push('-bufsize', `${task.encoding.videoBitrate.max * 2}k`);
  } else if (task.encoding.codec === 'vp9') {
    args.push('-c:v', 'libvpx-vp9');
    args.push('-b:v', `${task.encoding.videoBitrate.target}k`);
    args.push('-minrate', `${task.encoding.videoBitrate.min}k`);
    args.push('-maxrate', `${task.encoding.videoBitrate.max}k`);
    args.push('-quality', 'good');
    args.push('-speed', '2'); // 0-8, lower is slower/better
  } else if (task.encoding.codec === 'av1') {
    args.push('-c:v', 'libaom-av1');
    args.push('-b:v', `${task.encoding.videoBitrate.target}k`);
    args.push('-cpu-used', '4'); // 0-8, higher is faster
    args.push('-row-mt', '1'); // Enable row-based multithreading
  }
  
  // Resolution scaling
  args.push('-vf', `scale=${task.encoding.resolution.width}:${task.encoding.resolution.height}`);
  
  // Keyframe interval
  const gop = task.encoding.keyframeInterval * 
    (task.encoding.frameRate.source ? 30 : task.encoding.frameRate.max);
  args.push('-g', gop.toString());
  args.push('-keyint_min', gop.toString());
  
  // Audio encoding
  args.push('-c:a', 'aac');
  args.push('-b:a', `${task.encoding.audioBitrate}k`);
  
  // Output format
  if (task.output.format === 'fmp4') {
    args.push('-f', 'mp4');
    args.push('-movflags', 'frag_keyframe+empty_moov+default_base_moof');
  }
  
  return args;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// Worker process lifecycle
class EncodingWorker {
  private running = false;
  private currentTask: SegmentTask | null = null;
  
  async start(): Promise<void> {
    this.running = true;
    
    // Register with orchestrator
    await this.registerWorker();
    
    // Main work loop
    while (this.running) {
      try {
        // 1. Pull task from queue (with long-polling)
        const task = await this.pullTask({
          timeout: 30_000,
          visibilityTimeout: 300_000, // 5 minutes to complete
        });
        
        if (!task) continue;
        
        this.currentTask = task;
        
        // 2. Send heartbeats during processing
        const heartbeatInterval = setInterval(() => {
          this.sendHeartbeat(task.id);
        }, 30_000);
        
        try {
          // 3. Execute encoding
          const result = await encodeSegment(task);
          
          // 4. Report completion
          await this.reportCompletion(task.id, result);
          
        } finally {
          clearInterval(heartbeatInterval);
          this.currentTask = null;
        }
        
      } catch (error) {
        // Log and continue - individual task failures
        // shouldn't crash the worker
        this.reportError(error);
        await sleep(1000);
      }
    }
  }
  
  async pullTask(options: PullOptions): Promise<SegmentTask | null> {
    // Determine which queues this worker can process
    const queues = this.getEligibleQueues();
    
    // Fair-weighted polling across queues
    // (priority queues polled more frequently)
    for (const queue of queues) {
      const task = await queue.receive({
        maxMessages: 1,
        waitTime: options.timeout / queues.length,
        visibilityTimeout: options.visibilityTimeout,
      });
      
      if (task) {
        return task;
      }
    }
    
    return null;
  }
  
  private getEligibleQueues(): Queue[] {
    const queues: Queue[] = [];
    
    // All workers can handle normal priority
    queues.push(normalPriorityQueue);
    
    // Check if this worker has GPU
    if (this.hasGPU) {
      queues.push(gpuQueue);
    }
    
    // High-capability workers handle complex codecs
    if (this.cpuCores >= 64) {
      queues.push(av1Queue);
    }
    
    return queues;
  }
  
  // Graceful shutdown
  async stop(): Promise<void> {
    this.running = false;
    
    // Wait for current task to complete
    if (this.currentTask) {
      await this.waitForTaskCompletion(60_000); // 60s grace period
    }
    
    await this.deregisterWorker();
  }
}
 
// Auto-scaling configuration
interface ScalingConfig {
  minWorkers: number;
  maxWorkers: number;
  targetQueueDepth: number;       // Target messages in queue
  scaleUpThreshold: number;       // Queue depth to trigger scale-up
  scaleDownThreshold: number;     // Queue depth to trigger scale-down
  scaleUpCooldown: number;        // Seconds between scale-up events
  scaleDownCooldown: number;      // Seconds between scale-down events
  scaleUpStep: number;            // Workers to add per scale event
  scaleDownStep: number;          // Workers to remove per scale event
}
 
const CPU_SCALING: ScalingConfig = {
  minWorkers: 100,
  maxWorkers: 5000,
  targetQueueDepth: 1000,
  scaleUpThreshold: 2000,
  scaleDownThreshold: 200,
  scaleUpCooldown: 60,
  scaleDownCooldown: 300,
  scaleUpStep: 50,
  scaleDownStep: 10,
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

interface QualityMetrics {
  vmaf: {
    mean: number;        // Average VMAF score (0-100)
    min: number;         // Minimum frame VMAF
    percentile5: number; // 5th percentile (catches brief quality dips)
    harmonic: number;    // Harmonic mean (penalizes low outliers)
  };
  
  psnr: {
    mean: number;
    min: number;
  };
  
  ssim: {
    mean: number;
    min: number;
  };
  
  bitrate: {
    average: number;     // kbps
    max: number;
    variance: number;
  };
  
  encoding: {
    speed: number;       // Realtime multiplier (1.0 = realtime)
    cpuTime: number;     // Total CPU seconds consumed
    peakMemory: number;  // Peak memory usage in MB
  };
}
 
async function calculateQualityMetrics(
  source: Buffer,
  encoded: Buffer,
  profile: EncodingProfile
): Promise<QualityMetrics> {
  // Extract frames from both videos
  const sourceFrames = await extractFrames(source, { every: 1 }); // Every second
  const encodedFrames = await extractFrames(encoded, { every: 1 });
  
  // Ensure frame counts match
  if (sourceFrames.length !== encodedFrames.length) {
    throw new Error('Frame count mismatch');
  }
  
  // Calculate per-frame VMAF
  const vmafScores: number[] = [];
  for (let i = 0; i < sourceFrames.length; i++) {
    const score = await calculateVMAF(sourceFrames[i], encodedFrames[i]);
    vmafScores.push(score);
  }
  
  // Calculate per-frame PSNR and SSIM
  const psnrScores = await calculatePSNRBatch(sourceFrames, encodedFrames);
  const ssimScores = await calculateSSIMBatch(sourceFrames, encodedFrames);
  
  // Get bitrate information
  const bitrateInfo = await analyzeBitrate(encoded);
  
  return {
    vmaf: {
      mean: average(vmafScores),
      min: Math.min(...vmafScores),
      percentile5: percentile(vmafScores, 5),
      harmonic: harmonicMean(vmafScores),
    },
    psnr: {
      mean: average(psnrScores),
      min: Math.min(...psnrScores),
    },
    ssim: {
      mean: average(ssimScores),
      min: Math.min(...ssimScores),
    },
    bitrate: bitrateInfo,
    encoding: {
      speed: (encoded.duration / encodingTime),
      cpuTime: encodingCpuTime,
      peakMemory: peakMemoryMB,
    },
  };
}
 
// Quality thresholds for automated rejection
interface QualityThresholds {
  vmafMin: number;           // Reject if mean VMAF below this
  vmafP5Min: number;         // Reject if 5th percentile below this
  bitrateOvershoot: number;  // Reject if bitrate exceeds target by this %
}
 
const QUALITY_THRESHOLDS: Record<string, QualityThresholds> = {
  'h264-1080p': {
    vmafMin: 80,
    vmafP5Min: 70,
    bitrateOvershoot: 50,
  },
  'vp9-1080p': {
    vmafMin: 82,
    vmafP5Min: 72,
    bitrateOvershoot: 40,
  },
  'av1-1080p': {
    vmafMin: 85,
    vmafP5Min: 75,
    bitrateOvershoot: 30,
  },
};
 
function validateQuality(
  metrics: QualityMetrics,
  profile: EncodingProfile
): QualityValidationResult {
  const key = `${profile.codec}-${profile.resolution.height}p`;
  const thresholds = QUALITY_THRESHOLDS[key] || QUALITY_THRESHOLDS['h264-1080p'];
  
  const issues: QualityIssue[] = [];
  
  if (metrics.vmaf.mean < thresholds.vmafMin) {
    issues.push({
      type: 'LOW_VMAF_MEAN',
      actual: metrics.vmaf.mean,
      threshold: thresholds.vmafMin,
      severity: 'error',
    });
  }
  
  if (metrics.vmaf.percentile5 < thresholds.vmafP5Min) {
    issues.push({
      type: 'LOW_VMAF_P5',
      actual: metrics.vmaf.percentile5,
      threshold: thresholds.vmafP5Min,
      severity: 'error',
    });
  }
  
  const targetBitrate = profile.videoBitrate.target;
  const overshootPct = ((metrics.bitrate.average - targetBitrate) / targetBitrate) * 100;
  if (overshootPct > thresholds.bitrateOvershoot) {
    issues.push({
      type: 'BITRATE_OVERSHOOT',
      actual: overshootPct,
      threshold: thresholds.bitrateOvershoot,
      severity: 'warning',
    });
  }
  
  return {
    passed: issues.filter(i => i.severity === 'error').length === 0,
    issues,
    metrics,
  };
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// Progressive encoding: make video available faster, optimize later
interface EncodingPhase {
  name: string;
  priority: number;
  renditions: EncodingProfile[];
}
 
const PROGRESSIVE_PHASES: EncodingPhase[] = [
  {
    name: 'immediate',
    priority: 1,
    renditions: [
      // SD quality available within minutes
      { resolution: { width: 640, height: 360 }, codec: 'h264', ... },
      { resolution: { width: 854, height: 480 }, codec: 'h264', ... },
    ],
  },
  {
    name: 'standard',
    priority: 2,
    renditions: [
      // HD quality available within 15 minutes
      { resolution: { width: 1280, height: 720 }, codec: 'h264', ... },
      { resolution: { width: 1920, height: 1080 }, codec: 'h264', ... },
    ],
  },
  {
    name: 'premium',
    priority: 3,
    renditions: [
      // 4K and VP9/AV1 variants background processed
      { resolution: { width: 3840, height: 2160 }, codec: 'vp9', ... },
      { resolution: { width: 1920, height: 1080 }, codec: 'av1', ... },
    ],
  },
];
 
// Content-aware rendition selection
function selectRenditions(
  sourceInfo: MediaInfo,
  channelMetrics: ChannelMetrics,
  contentAnalysis: ContentAnalysis
): EncodingProfile[] {
  const renditions: EncodingProfile[] = [];
  const sourceHeight = sourceInfo.height;
  
  // Always include fallback renditions
  renditions.push(...FALLBACK_RENDITIONS);
  
  // Don't upscale: cap at source resolution
  const maxHeight = sourceHeight;
  
  // For small channels, skip 4K initially (can generate on-demand)
  if (channelMetrics.averageViews < 1000 && sourceHeight >= 2160) {
    // Skip 4K for now, mark for on-demand generation
  } else {
    renditions.push(...getRenditionsUpTo(maxHeight));
  }
  
  // For static/low-motion content, fewer bitrate variants needed
  if (contentAnalysis.motionComplexity < 0.3) {
    // Use single bitrate per resolution instead of CRF/VBR range
  }
  
  // Skip AV1 for short-lived content (news, livestream archives)
  // The encoding cost doesn't pay back in CDN savings
  if (contentAnalysis.expectedViewWindow < Duration.days(7)) {
    renditions = renditions.filter(r => r.codec !== 'av1');
  }
  
  return renditions;
}
 
// On-demand transcoding for long-tail content
async function transcodeOnDemand(
  videoId: string,
  requestedFormat: VideoFormat
): Promise<void> {
  // Check if format already exists
  const existing = await getRendition(videoId, requestedFormat);
  if (existing) return;
  
  // Check if on-demand transcoding is allowed for this content
  const video = await getVideo(videoId);
  if (!video.allowOnDemandTranscode) {
    throw new NotAvailableError('Format not available');
  }
  
  // Queue high-priority transcoding
  await enqueueTranscoding({
    videoId,
    renditions: [requestedFormat],
    priority: 'high',
    reason: 'on-demand',
  });
  
  // Return 202 Accepted - format will be available soon
  throw new TranscodingInProgressError(estimateCompletionTime(video, requestedFormat));
}