Diseño de Sistemas: Plataforma de Video Streaming

// Pipeline de subida y procesamiento

interface VideoUpload {
  id: string;
  userId: string;
  originalFileName: string;
  originalUrl: string;     // Ubicación en S3 del archivo subido
  status: "uploading" | "processing" | "ready" | "failed";
  metadata: VideoMetadata;
  createdAt: Date;
}

interface VideoMetadata {
  title: string;
  description: string;
  tags: string[];
  duration: number;        // segundos
  resolution: string;      // "1920x1080"
  codec: string;
  frameRate: number;
  fileSize: number;        // bytes
}

interface ProcessedVideo {
  videoId: string;
  variants: VideoVariant[];
  thumbnails: string[];
  manifest: string;        // URL del manifiesto HLS/DASH
}

interface VideoVariant {
  resolution: string;      // "1080p", "720p", "480p", "360p"
  bitrate: number;         // kbps
  codec: string;
  segmentUrls: string[];   // URLs de segmentos de video
}

// Flujo de subida
class VideoUploadService {
  async initiateUpload(userId: string, metadata: Partial<VideoMetadata>): Promise<UploadSession> {
    // Generar una URL pre-firmada de S3 para subida directa
    // El cliente sube directamente a S3 (evita nuestros servidores)
    const uploadId = generateId();
    const s3Key = `uploads/${userId}/${uploadId}/original`;

    const presignedUrl = await this.s3.getSignedUrl("putObject", {
      Bucket: "video-uploads",
      Key: s3Key,
      Expires: 3600, // 1 hora
      ContentType: "video/*",
    });

    // Crear registro de subida
    await this.db.videoUploads.insert({
      id: uploadId,
      userId,
      status: "uploading",
      originalUrl: `s3://video-uploads/${s3Key}`,
      metadata,
    });

    return {
      uploadId,
      presignedUrl,
      // Para archivos grandes, usar subida multipart
      multipartUrls: await this.generateMultipartUrls(s3Key),
    };
  }

  // Activado por notificación de evento S3 cuando se completa la subida
  async onUploadComplete(uploadId: string): Promise<void> {
    await this.db.videoUploads.update(uploadId, { status: "processing" });

    // Enviar al pipeline de procesamiento
    await this.messageQueue.publish("video-processing", {
      uploadId,
      stages: ["validate", "transcode", "thumbnail", "manifest"],
    });
  }
}

// Pipeline de transcodificación (ejecuta en workers con GPU)
class TranscodingService {
  private profiles = [
    { name: "1080p", width: 1920, height: 1080, bitrate: 5000 },
    { name: "720p",  width: 1280, height: 720,  bitrate: 2500 },
    { name: "480p",  width: 854,  height: 480,  bitrate: 1200 },
    { name: "360p",  width: 640,  height: 360,  bitrate: 700 },
  ];

  async transcodeVideo(uploadId: string, sourceUrl: string): Promise<VideoVariant[]> {
    const variants: VideoVariant[] = [];

    // Obtener info del video fuente
    const sourceInfo = await this.probe(sourceUrl);

    // Solo transcodificar a resoluciones <= resolución fuente
    const applicableProfiles = this.profiles.filter(
      (p) => p.height <= sourceInfo.height
    );

    // Procesar cada perfil (puede paralelizarse entre workers)
    for (const profile of applicableProfiles) {
      const segments = await this.transcodeToProfile(sourceUrl, profile);
      variants.push({
        resolution: profile.name,
        bitrate: profile.bitrate,
        codec: "h264", // o h265/AV1 para mejor compresión
        segmentUrls: segments,
      });
    }

    return variants;
  }

  // Cada video se divide en segmentos pequeños (2-10 segundos)
  // Esto permite cambio de bitrate adaptativo en los límites de segmento
  private async transcodeToProfile(
    sourceUrl: string,
    profile: TranscodeProfile
  ): Promise<string[]> {
    // Usando FFmpeg internamente:
    // ffmpeg -i input.mp4 \
    //   -vf scale=1280:720 \
    //   -b:v 2500k \
    //   -hls_time 6 \
    //   -hls_segment_filename "segment_%03d.ts" \
    //   output.m3u8

    const outputDir = `processed/${profile.name}/`;
    const segmentDuration = 6; // segundos

    return this.ffmpeg.transcode({
      input: sourceUrl,
      output: outputDir,
      width: profile.width,
      height: profile.height,
      bitrate: profile.bitrate,
      segmentDuration,
      format: "hls", // HTTP Live Streaming
    });
  }
}

// Estructura de manifiesto HLS (simplificado)
// Master playlist (video.m3u8) - apunta a playlists variantes
const masterPlaylist = `
#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=5000000,RESOLUTION=1920x1080
1080p/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2500000,RESOLUTION=1280x720
720p/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1200000,RESOLUTION=854x480
480p/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=700000,RESOLUTION=640x360
360p/playlist.m3u8
`;

// Variant playlist (720p/playlist.m3u8) - lista segmentos
const variantPlaylist = `
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:6
#EXTINF:6.0,
segment_001.ts
#EXTINF:6.0,
segment_002.ts
#EXTINF:6.0,
segment_003.ts
#EXTINF:4.5,
segment_004.ts
#EXT-X-ENDLIST
`;

// El reproductor:
// 1. Descarga el master playlist
// 2. Selecciona una variante basada en el ancho de banda actual
// 3. Descarga segmentos de esa variante
// 4. Si el ancho de banda cambia, cambia a una variante diferente en el siguiente límite de segmento

class ThumbnailService {
  async generateThumbnails(
    videoUrl: string,
    videoId: string,
    duration: number
  ): Promise<string[]> {
    const thumbnails: string[] = [];

    // Generar miniaturas a intervalos regulares
    const intervals = this.calculateIntervals(duration);
    // ej., para un video de 60s: [0, 10, 20, 30, 40, 50]

    for (const timestamp of intervals) {
      // Extraer frame usando FFmpeg
      // ffmpeg -i input.mp4 -ss 10 -frames:v 1 -vf scale=320:180 thumb.jpg
      const thumbnailUrl = await this.extractFrame(videoUrl, timestamp, {
        width: 320,
        height: 180,
        format: "webp", // Más pequeño que JPEG
      });
      thumbnails.push(thumbnailUrl);
    }

    // Generar preview de video (miniatura animada / sprite sheet)
    const spriteSheet = await this.generateSpriteSheet(videoUrl, intervals);

    // Almacenar URLs de miniaturas en metadatos del video
    await this.db.videos.update(videoId, {
      thumbnails,
      defaultThumbnail: thumbnails[Math.floor(thumbnails.length / 3)],
      spriteSheet,
    });

    return thumbnails;
  }
}

// Estrategia de almacenamiento por niveles
class StorageTierManager {
  // Los videos se clasifican en niveles basados en frecuencia de visualización
  async tierVideo(videoId: string): Promise<void> {
    const stats = await this.getViewStats(videoId);
    const daysSinceUpload = this.daysSince(stats.uploadedAt);
    const recentViews = stats.viewsLast30Days;

    if (recentViews > 1000) {
      // Caliente: mantener todas las variantes en almacenamiento rápido + CDN
      await this.moveToTier(videoId, "hot"); // S3 Standard
    } else if (recentViews > 10) {
      // Tibio: mantener variantes populares, mover otras a almacenamiento más barato
      await this.moveToTier(videoId, "warm"); // S3 Infrequent Access
      // Solo mantener 720p y 360p en almacenamiento rápido
      await this.archiveVariants(videoId, ["1080p", "4k"]);
    } else if (daysSinceUpload > 365) {
      // Frío: archivar al almacenamiento más barato, transcodificar bajo demanda
      await this.moveToTier(videoId, "cold"); // S3 Glacier
      // Mantener solo 360p, re-transcodificar mayor resolución bajo demanda
    }
  }
}

// Optimización de costos de ancho de banda:
// 1. Usar codecs eficientes (AV1 > H.265 > H.264) para contenido popular
// 2. Servir miniaturas WebP/AVIF en lugar de JPEG (50% más pequeñas)
// 3. Estimación de ancho de banda del lado del cliente para evitar sobre-servir calidad
// 4. Limitar calidad máxima basada en tamaño de pantalla (no servir 4K a teléfonos)