unified-video-framework 1.4.411 → 1.4.413

package/packages/web/src/drm/systems/PlayReadyDRM.ts

@@ -0,0 +1,131 @@
+/**
+ * PlayReady DRM Implementation
+ * Implements PlayReady DRM for Edge and IE
+ */
+
+import { BaseDRM } from './BaseDRM';
+import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
+import { DRMType } from '@unified-video/core';
+import { DRMErrorHandler } from '../utils/DRMErrorHandler';
+
+export class PlayReadyDRM extends BaseDRM {
+  async initialize(): Promise<void> {
+    this.log('Initializing PlayReady DRM...');
+
+    // PlayReady is primarily configured through HLS.js and dash.js
+    // Basic EME setup for validation
+    try {
+      const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+        this.getKeySystem(),
+        this.getKeySystemConfiguration()
+      );
+
+      this.log('PlayReady key system access granted');
+      this.mediaKeys = await keySystemAccess.createMediaKeys();
+
+      // For HLS.js and dash.js, they handle the actual EME setup
+      // We just validate that the system is available
+
+    } catch (error: any) {
+      // Try fallback key system
+      try {
+        const fallbackKeySystem = KEY_SYSTEMS[DRMType.PLAYREADY][1];
+        const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+          fallbackKeySystem,
+          this.getKeySystemConfiguration()
+        );
+
+        this.log('PlayReady fallback key system access granted');
+        this.mediaKeys = await keySystemAccess.createMediaKeys();
+      } catch (fallbackError: any) {
+        this.log('PlayReady initialization failed:', fallbackError);
+        throw DRMErrorHandler.createError(
+          DRMErrorCode.KEY_SYSTEM_ACCESS_DENIED,
+          'Failed to access PlayReady DRM system',
+          true,
+          fallbackError
+        );
+      }
+    }
+
+    this.log('PlayReady DRM initialized');
+  }
+
+  getKeySystem(): string {
+    return KEY_SYSTEMS[DRMType.PLAYREADY][0];
+  }
+
+  getHLSConfig(): any {
+    this.log('Generating HLS.js config for PlayReady');
+
+    return {
+      emeEnabled: true,
+      drmSystems: {
+        [this.getKeySystem()]: {
+          licenseUrl: this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl,
+          customData: this.config.customData || this.config.playreadyOptions?.customData,
+        },
+        // Add fallback key system
+        [KEY_SYSTEMS[DRMType.PLAYREADY][1]]: {
+          licenseUrl: this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl,
+          customData: this.config.customData || this.config.playreadyOptions?.customData,
+        },
+      },
+      requestMediaKeySystemAccessFunc: navigator.requestMediaKeySystemAccess.bind(navigator),
+    };
+  }
+
+  getDashProtectionData(): any {
+    this.log('Generating dash.js protection data for PlayReady');
+
+    const licenseUrl = this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl;
+
+    const protectionData: any = {
+      [this.getKeySystem()]: {
+        serverURL: licenseUrl,
+      },
+      // Add fallback key system
+      [KEY_SYSTEMS[DRMType.PLAYREADY][1]]: {
+        serverURL: licenseUrl,
+      },
+    };
+
+    // Add custom headers if provided
+    if (this.config.headers && Object.keys(this.config.headers).length > 0) {
+      protectionData[this.getKeySystem()].httpRequestHeaders = this.config.headers;
+      protectionData[KEY_SYSTEMS[DRMType.PLAYREADY][1]].httpRequestHeaders = this.config.headers;
+    }
+
+    // Add custom data if provided
+    const customData = this.config.customData || this.config.playreadyOptions?.customData;
+    if (customData) {
+      protectionData[this.getKeySystem()].customData = customData;
+      protectionData[KEY_SYSTEMS[DRMType.PLAYREADY][1]].customData = customData;
+    }
+
+    return protectionData;
+  }
+
+  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
+    return [{
+      initDataTypes: ['cenc'],
+      audioCapabilities: [{
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        robustness: 'SW_SECURE_CRYPTO',
+      }],
+      videoCapabilities: [
+        {
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+        {
+          contentType: 'video/mp4; codecs="avc1.4d401f"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+      ],
+      distinctiveIdentifier: 'not-allowed',
+      persistentState: 'not-allowed',
+      sessionTypes: ['temporary'],
+    }];
+  }
+}

package/packages/web/src/drm/systems/WidevineDRM.ts

@@ -0,0 +1,105 @@
+/**
+ * Widevine DRM Implementation
+ * Implements Widevine DRM for Chrome, Firefox, Edge, Android
+ */
+
+import { BaseDRM } from './BaseDRM';
+import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
+import { DRMType } from '@unified-video/core';
+import { DRMErrorHandler } from '../utils/DRMErrorHandler';
+
+export class WidevineDRM extends BaseDRM {
+  async initialize(): Promise<void> {
+    this.log('Initializing Widevine DRM...');
+
+    // Widevine is primarily configured through HLS.js and dash.js
+    // Basic EME setup for validation
+    try {
+      const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+        this.getKeySystem(),
+        this.getKeySystemConfiguration()
+      );
+
+      this.log('Widevine key system access granted');
+      this.mediaKeys = await keySystemAccess.createMediaKeys();
+
+      // For HLS.js and dash.js, they handle the actual EME setup
+      // We just validate that the system is available
+
+    } catch (error: any) {
+      this.log('Widevine initialization failed:', error);
+      throw DRMErrorHandler.createError(
+        DRMErrorCode.KEY_SYSTEM_ACCESS_DENIED,
+        'Failed to access Widevine DRM system',
+        true,
+        error
+      );
+    }
+
+    this.log('Widevine DRM initialized');
+  }
+
+  getKeySystem(): string {
+    return KEY_SYSTEMS[DRMType.WIDEVINE][0];
+  }
+
+  getHLSConfig(): any {
+    this.log('Generating HLS.js config for Widevine');
+
+    return {
+      emeEnabled: true,
+      drmSystems: {
+        [this.getKeySystem()]: {
+          licenseUrl: this.config.licenseUrl || this.config.widevineOptions?.licenseUrl,
+          serverCertificate: this.config.widevineOptions?.serverCertificate,
+        },
+      },
+      requestMediaKeySystemAccessFunc: navigator.requestMediaKeySystemAccess.bind(navigator),
+    };
+  }
+
+  getDashProtectionData(): any {
+    this.log('Generating dash.js protection data for Widevine');
+
+    const protectionData: any = {
+      [this.getKeySystem()]: {
+        serverURL: this.config.licenseUrl || this.config.widevineOptions?.licenseUrl,
+      },
+    };
+
+    // Add custom headers if provided
+    if (this.config.headers && Object.keys(this.config.headers).length > 0) {
+      protectionData[this.getKeySystem()].httpRequestHeaders = this.config.headers;
+    }
+
+    // Add server certificate if provided
+    if (this.config.widevineOptions?.serverCertificate) {
+      protectionData[this.getKeySystem()].serverCertificate = this.config.widevineOptions.serverCertificate;
+    }
+
+    return protectionData;
+  }
+
+  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
+    return [{
+      initDataTypes: ['cenc'],
+      audioCapabilities: [{
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        robustness: 'SW_SECURE_CRYPTO',
+      }],
+      videoCapabilities: [
+        {
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+        {
+          contentType: 'video/mp4; codecs="avc1.4d401f"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+      ],
+      distinctiveIdentifier: 'not-allowed',
+      persistentState: 'not-allowed',
+      sessionTypes: ['temporary'],
+    }];
+  }
+}

package/packages/web/src/drm/types/BunnyNetTypes.ts

@@ -0,0 +1,35 @@
+/**
+ * Bunny.net DRM Type Definitions
+ * Type definitions specific to Bunny.net MediaCage DRM integration
+ */
+
+import { DRMType } from '@unified-video/core';
+
+export interface BunnyNetConfig {
+  libraryId: string;
+  videoId: string;
+  drmType?: DRMType;
+}
+
+export interface BunnyNetEndpoints {
+  widevine: string;
+  fairplayCert: string;
+  fairplayLicense: string;
+  playready: string;
+}
+
+export const BUNNY_NET_BASE_URL = 'https://video.bunnycdn.com';
+
+export const BUNNY_NET_ENDPOINTS = {
+  WIDEVINE_LICENSE: (libraryId: string, videoId: string) =>
+    `${BUNNY_NET_BASE_URL}/WidevineLicense/${libraryId}/${videoId}`,
+
+  FAIRPLAY_CERTIFICATE: (libraryId: string) =>
+    `${BUNNY_NET_BASE_URL}/FairPlay/${libraryId}/certificate`,
+
+  FAIRPLAY_LICENSE: (libraryId: string, videoId: string) =>
+    `${BUNNY_NET_BASE_URL}/FairPlay/${libraryId}/license/?videoId=${videoId}`,
+
+  PLAYREADY_LICENSE: (libraryId: string, videoId: string) =>
+    `${BUNNY_NET_BASE_URL}/PlayReadyLicense/${libraryId}/${videoId}`,
+};

package/packages/web/src/drm/types/DRMTypes.ts

@@ -0,0 +1,91 @@
+/**
+ * DRM Type Definitions
+ * Core type definitions and enums for DRM functionality
+ */
+
+import { DRMConfig, DRMType } from '@unified-video/core';
+
+// Extended DRM configuration for internal use
+export interface ExtendedDRMConfig extends DRMConfig {
+  // Provider-specific settings
+  provider?: 'bunny' | 'generic' | string;
+
+  // Library/Video IDs for Bunny.net
+  libraryId?: string;
+  videoId?: string;
+
+  // Advanced options
+  retryConfig?: {
+    maxRetries: number;
+    retryDelay: number;
+  };
+
+  // Debugging
+  debug?: boolean;
+}
+
+// Browser DRM capabilities
+export interface DRMCapabilities {
+  widevine: boolean;
+  fairplay: boolean;
+  playready: boolean;
+  supportedType: DRMType | null;
+}
+
+// License request/response types
+export interface LicenseRequest {
+  url: string;
+  method: 'POST' | 'GET';
+  headers: Record<string, string>;
+  body: ArrayBuffer | string;
+  responseType: 'arraybuffer' | 'text' | 'json';
+}
+
+export interface LicenseResponse {
+  license: ArrayBuffer;
+  metadata?: any;
+}
+
+// EME event types
+export interface EMEMessageEvent {
+  messageType: string;
+  message: ArrayBuffer;
+}
+
+// DRM initialization result
+export interface DRMInitResult {
+  success: boolean;
+  drmType: DRMType;
+  keySystem: string;
+  error?: DRMError;
+}
+
+// DRM-specific errors
+export interface DRMError {
+  code: DRMErrorCode;
+  message: string;
+  fatal: boolean;
+  details?: any;
+  systemError?: any;
+}
+
+export enum DRMErrorCode {
+  UNSUPPORTED_BROWSER = 'DRM_UNSUPPORTED_BROWSER',
+  CERTIFICATE_LOAD_FAILED = 'DRM_CERTIFICATE_LOAD_FAILED',
+  LICENSE_REQUEST_FAILED = 'DRM_LICENSE_REQUEST_FAILED',
+  KEY_SYSTEM_ACCESS_DENIED = 'DRM_KEY_SYSTEM_ACCESS_DENIED',
+  MEDIA_KEYS_CREATION_FAILED = 'DRM_MEDIA_KEYS_CREATION_FAILED',
+  SESSION_CREATION_FAILED = 'DRM_SESSION_CREATION_FAILED',
+  LICENSE_INVALID = 'DRM_LICENSE_INVALID',
+  CONFIGURATION_ERROR = 'DRM_CONFIGURATION_ERROR',
+  NETWORK_ERROR = 'DRM_NETWORK_ERROR',
+  TIMEOUT = 'DRM_TIMEOUT',
+}
+
+// Key system mappings
+export const KEY_SYSTEMS: Record<DRMType, string[]> = {
+  [DRMType.WIDEVINE]: ['com.widevine.alpha'],
+  [DRMType.PLAYREADY]: ['com.microsoft.playready', 'com.microsoft.playready.recommendation'],
+  [DRMType.FAIRPLAY]: ['com.apple.fps.1_0', 'com.apple.fps'],
+  [DRMType.CLEARKEY]: ['webkit-org.w3.clearkey', 'org.w3.clearkey'],
+};

package/packages/web/src/drm/utils/BrowserDetector.ts

@@ -0,0 +1,232 @@
+/**
+ * Browser DRM Detector
+ * Detects browser capabilities and determines optimal DRM system
+ */
+
+import { DRMType } from '@unified-video/core';
+import { DRMCapabilities, KEY_SYSTEMS } from '../types/DRMTypes';
+
+export class BrowserDetector {
+  private static instance: BrowserDetector;
+  private capabilities: DRMCapabilities | null = null;
+
+  private constructor() {}
+
+  static getInstance(): BrowserDetector {
+    if (!BrowserDetector.instance) {
+      BrowserDetector.instance = new BrowserDetector();
+    }
+    return BrowserDetector.instance;
+  }
+
+  /**
+   * Detect DRM capabilities of current browser
+   */
+  async detectCapabilities(): Promise<DRMCapabilities> {
+    if (this.capabilities) {
+      return this.capabilities;
+    }
+
+    const capabilities: DRMCapabilities = {
+      widevine: false,
+      fairplay: false,
+      playready: false,
+      supportedType: null,
+    };
+
+    // Check for FairPlay (Safari/iOS) - highest priority on Apple devices
+    if (this.isSafari() || this.isWebKitBased()) {
+      capabilities.fairplay = await this.checkFairPlaySupport();
+      if (capabilities.fairplay) {
+        capabilities.supportedType = DRMType.FAIRPLAY;
+      }
+    }
+
+    // Check for Widevine (Chrome, Firefox, Edge)
+    if (!capabilities.supportedType) {
+      capabilities.widevine = await this.checkWidevineSupport();
+      if (capabilities.widevine) {
+        capabilities.supportedType = DRMType.WIDEVINE;
+      }
+    }
+
+    // Check for PlayReady (Edge, IE)
+    if (!capabilities.supportedType && this.isEdge()) {
+      capabilities.playready = await this.checkPlayReadySupport();
+      if (capabilities.playready) {
+        capabilities.supportedType = DRMType.PLAYREADY;
+      }
+    }
+
+    this.capabilities = capabilities;
+    return capabilities;
+  }
+
+  /**
+   * Get recommended DRM type for current browser
+   */
+  async getRecommendedDRMType(): Promise<DRMType | null> {
+    const caps = await this.detectCapabilities();
+    return caps.supportedType;
+  }
+
+  /**
+   * Check if specific DRM type is supported
+   */
+  async isDRMTypeSupported(drmType: DRMType): Promise<boolean> {
+    const caps = await this.detectCapabilities();
+    switch (drmType) {
+      case DRMType.WIDEVINE:
+        return caps.widevine;
+      case DRMType.FAIRPLAY:
+        return caps.fairplay;
+      case DRMType.PLAYREADY:
+        return caps.playready;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Check if browser is Safari
+   */
+  private isSafari(): boolean {
+    const ua = navigator.userAgent.toLowerCase();
+    return ua.includes('safari') && !ua.includes('chrome') && !ua.includes('chromium');
+  }
+
+  /**
+   * Check if browser is WebKit-based
+   */
+  private isWebKitBased(): boolean {
+    return 'WebKitMediaKeys' in window;
+  }
+
+  /**
+   * Check if browser is Edge
+   */
+  private isEdge(): boolean {
+    const ua = navigator.userAgent.toLowerCase();
+    return ua.includes('edg/');
+  }
+
+  /**
+   * Check FairPlay support
+   */
+  private async checkFairPlaySupport(): Promise<boolean> {
+    try {
+      // Check for WebKit-specific FairPlay API
+      if ('WebKitMediaKeys' in window) {
+        return true;
+      }
+
+      // Check via EME API
+      if (navigator.requestMediaKeySystemAccess) {
+        const config: MediaKeySystemConfiguration[] = [{
+          initDataTypes: ['sinf', 'skd'],
+          videoCapabilities: [{ contentType: 'application/vnd.apple.mpegurl' }],
+        }];
+
+        for (const keySystem of KEY_SYSTEMS[DRMType.FAIRPLAY]) {
+          try {
+            await navigator.requestMediaKeySystemAccess(keySystem, config);
+            return true;
+          } catch (e) {
+            // Try next key system
+            continue;
+          }
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check Widevine support
+   */
+  private async checkWidevineSupport(): Promise<boolean> {
+    try {
+      if (!navigator.requestMediaKeySystemAccess) {
+        return false;
+      }
+
+      const config: MediaKeySystemConfiguration[] = [{
+        initDataTypes: ['cenc'],
+        videoCapabilities: [{
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+        }],
+      }];
+
+      for (const keySystem of KEY_SYSTEMS[DRMType.WIDEVINE]) {
+        try {
+          await navigator.requestMediaKeySystemAccess(keySystem, config);
+          return true;
+        } catch (e) {
+          // Try next key system
+          continue;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check PlayReady support
+   */
+  private async checkPlayReadySupport(): Promise<boolean> {
+    try {
+      if (!navigator.requestMediaKeySystemAccess) {
+        return false;
+      }
+
+      const config: MediaKeySystemConfiguration[] = [{
+        initDataTypes: ['cenc'],
+        videoCapabilities: [{
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+        }],
+      }];
+
+      for (const keySystem of KEY_SYSTEMS[DRMType.PLAYREADY]) {
+        try {
+          await navigator.requestMediaKeySystemAccess(keySystem, config);
+          return true;
+        } catch (e) {
+          // Try next key system
+          continue;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get user-friendly browser name
+   */
+  getBrowserName(): string {
+    const ua = navigator.userAgent.toLowerCase();
+
+    if (ua.includes('edg/')) return 'Edge';
+    if (ua.includes('chrome') || ua.includes('chromium')) return 'Chrome';
+    if (ua.includes('firefox')) return 'Firefox';
+    if (ua.includes('safari')) return 'Safari';
+    if (ua.includes('opera') || ua.includes('opr/')) return 'Opera';
+
+    return 'Unknown';
+  }
+
+  /**
+   * Reset cached capabilities (useful for testing)
+   */
+  resetCapabilities(): void {
+    this.capabilities = null;
+  }
+}

package/packages/web/src/drm/utils/CertificateManager.ts

@@ -0,0 +1,86 @@
+/**
+ * Certificate Manager
+ * Manages FairPlay DRM certificates with in-memory caching
+ */
+
+export class CertificateManager {
+  private static instance: CertificateManager;
+  private cache: Map<string, ArrayBuffer>;
+  private maxCacheSize: number = 10; // Max number of certificates to cache
+
+  private constructor() {
+    this.cache = new Map();
+  }
+
+  static getInstance(): CertificateManager {
+    if (!CertificateManager.instance) {
+      CertificateManager.instance = new CertificateManager();
+    }
+    return CertificateManager.instance;
+  }
+
+  /**
+   * Get certificate from cache
+   */
+  getCertificate(url: string): ArrayBuffer | null {
+    return this.cache.get(url) || null;
+  }
+
+  /**
+   * Store certificate in cache
+   */
+  setCertificate(url: string, certificate: ArrayBuffer): void {
+    // Implement LRU eviction if cache is full
+    if (this.cache.size >= this.maxCacheSize && !this.cache.has(url)) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+
+    this.cache.set(url, certificate);
+  }
+
+  /**
+   * Check if certificate is cached
+   */
+  hasCertificate(url: string): boolean {
+    return this.cache.has(url);
+  }
+
+  /**
+   * Clear all cached certificates
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Remove specific certificate from cache
+   */
+  removeCertificate(url: string): boolean {
+    return this.cache.delete(url);
+  }
+
+  /**
+   * Get cache size
+   */
+  getCacheSize(): number {
+    return this.cache.size;
+  }
+
+  /**
+   * Set max cache size
+   */
+  setMaxCacheSize(size: number): void {
+    this.maxCacheSize = size;
+
+    // Evict old entries if current size exceeds new max
+    while (this.cache.size > this.maxCacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+  }
+}