unified-video-framework 1.4.425 → 1.4.427

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

@@ -1,317 +0,0 @@
-/**
- * FairPlay DRM Implementation
- * Implements FairPlay DRM for Safari/iOS using WebKit EME APIs
- */
-
-import { BaseDRM } from './BaseDRM';
-import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
-import type { DRMType } from '@unified-video/core';
-import { CertificateManager } from '../utils/CertificateManager';
-import { DRMErrorHandler } from '../utils/DRMErrorHandler';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-
-// WebKit-specific types
-declare global {
-  interface HTMLVideoElement {
-    webkitSetMediaKeys?: (mediaKeys: any) => void;
-    webkitKeys?: any;
-  }
-
-  interface Window {
-    WebKitMediaKeys?: any;
-  }
-}
-
-export class FairPlayDRM extends BaseDRM {
-  private certificateManager: CertificateManager;
-  private serverCertificate: ArrayBuffer | null = null;
-  private encryptedEventHandler: ((event: any) => Promise<void>) | null = null;
-  private needKeyEventHandler: ((event: any) => Promise<void>) | null = null;
-
-  constructor(videoElement: HTMLVideoElement, config: any, debug: boolean = false) {
-    super(videoElement, config, debug);
-    this.certificateManager = CertificateManager.getInstance();
-  }
-
-  async initialize(): Promise<void> {
-    this.log('Initializing FairPlay DRM...');
-
-    // Load server certificate
-    await this.loadCertificate();
-
-    // Set up encrypted event listeners
-    this.setupEncryptedEventListeners();
-
-    this.log('FairPlay DRM initialized');
-  }
-
-  getKeySystem(): string {
-    return KEY_SYSTEMS[DRMTypeEnum.FAIRPLAY][0];
-  }
-
-  getHLSConfig(): any {
-    this.log('Generating HLS.js config for FairPlay');
-
-    const certificateUrl = this.config.certificateUrl || this.config.fairplayOptions?.certificateUrl;
-    const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
-
-    return {
-      emeEnabled: true,
-      drmSystems: {
-        [this.getKeySystem()]: {
-          licenseUrl: licenseUrl,
-          serverCertificateUrl: certificateUrl,
-          serverCertificate: this.serverCertificate,
-        },
-      },
-      requestMediaKeySystemAccessFunc: this.createMediaKeySystemAccess.bind(this),
-      xhrSetup: (xhr: XMLHttpRequest, url: string) => {
-        if (url === licenseUrl || url === certificateUrl) {
-          this.log(`[LicenseXHR] (FairPlay) Requesting resource from: ${url}`);
-
-          if (this.config.headers) {
-            Object.keys(this.config.headers).forEach(key => {
-              xhr.setRequestHeader(key, this.config.headers![key]);
-            });
-          }
-        }
-      }
-    };
-  }
-
-  getDashProtectionData(): any {
-    this.log('Generating dash.js protection data for FairPlay');
-
-    const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
-
-    return {
-      [this.getKeySystem()]: {
-        serverURL: licenseUrl,
-        serverCertificate: this.serverCertificate,
-      },
-    };
-  }
-
-  async destroy(): Promise<void> {
-    // Remove event listeners
-    if (this.encryptedEventHandler) {
-      this.videoElement.removeEventListener('encrypted', this.encryptedEventHandler as any);
-      this.encryptedEventHandler = null;
-    }
-
-    if (this.needKeyEventHandler) {
-      this.videoElement.removeEventListener('webkitneedkey', this.needKeyEventHandler as any);
-      this.needKeyEventHandler = null;
-    }
-
-    await super.destroy();
-  }
-
-  private async loadCertificate(): Promise<void> {
-    const certificateUrl = this.config.certificateUrl || this.config.fairplayOptions?.certificateUrl;
-
-    if (!certificateUrl) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.CONFIGURATION_ERROR,
-        'FairPlay certificate URL not provided',
-        true
-      );
-    }
-
-    this.log('Loading FairPlay certificate from:', certificateUrl);
-
-    // Check cache first
-    const cached = this.certificateManager.getCertificate(certificateUrl);
-    if (cached) {
-      this.log('Using cached certificate');
-      this.serverCertificate = cached;
-      return;
-    }
-
-    // Fetch certificate
-    try {
-      const response = await fetch(certificateUrl);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-
-      this.serverCertificate = await response.arrayBuffer();
-
-      // Cache for future use
-      this.certificateManager.setCertificate(certificateUrl, this.serverCertificate);
-
-      this.log('FairPlay certificate loaded, size:', this.serverCertificate.byteLength, 'bytes');
-    } catch (error: any) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.CERTIFICATE_LOAD_FAILED,
-        `Failed to load FairPlay certificate: ${error.message}`,
-        true,
-        error
-      );
-    }
-  }
-
-  private setupEncryptedEventListeners(): void {
-    // Modern EME encrypted event
-    this.encryptedEventHandler = this.onEncrypted.bind(this);
-    this.videoElement.addEventListener('encrypted', this.encryptedEventHandler as any);
-
-    // Legacy WebKit needkey event
-    this.needKeyEventHandler = this.onWebKitNeedKey.bind(this);
-    this.videoElement.addEventListener('webkitneedkey', this.needKeyEventHandler as any);
-
-    this.log('FairPlay encrypted event listeners set up');
-  }
-
-  private async onEncrypted(event: any): Promise<void> {
-    this.log('Encrypted event received:', event);
-
-    try {
-      const initData = event.initData;
-      const initDataType = event.initDataType;
-
-      await this.createSession(initData, initDataType);
-    } catch (error) {
-      this.log('Error handling encrypted event:', error);
-      throw error;
-    }
-  }
-
-  private async onWebKitNeedKey(event: any): Promise<void> {
-    this.log('WebKit needkey event received');
-
-    try {
-      const initData = event.initData;
-      await this.createSession(initData, 'skd');
-    } catch (error) {
-      this.log('Error handling webkitneedkey event:', error);
-      throw error;
-    }
-  }
-
-  private async createSession(initData: ArrayBuffer, initDataType: string): Promise<void> {
-    // Create media keys if not already created
-    if (!this.mediaKeys) {
-      try {
-        const keySystemAccess = await navigator.requestMediaKeySystemAccess(
-          this.getKeySystem(),
-          this.getKeySystemConfiguration()
-        );
-        this.mediaKeys = await keySystemAccess.createMediaKeys();
-        await this.videoElement.setMediaKeys(this.mediaKeys);
-
-        this.log('FairPlay MediaKeys created and set');
-      } catch (error: any) {
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.MEDIA_KEYS_CREATION_FAILED,
-          `Failed to create FairPlay MediaKeys: ${error.message}`,
-          true,
-          error
-        );
-      }
-    }
-
-    // Create session
-    try {
-      this.keySession = this.mediaKeys.createSession();
-      this.log('FairPlay session created');
-
-      // Handle license request
-      this.keySession.addEventListener('message', async (event: any) => {
-        await this.onMessage(event);
-      });
-
-      // Generate license request
-      await this.keySession.generateRequest(initDataType, initData);
-    } catch (error: any) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.SESSION_CREATION_FAILED,
-        `Failed to create FairPlay session: ${error.message}`,
-        true,
-        error
-      );
-    }
-  }
-
-  private async onMessage(event: any): Promise<void> {
-    this.log('FairPlay message event:', event.messageType);
-
-    try {
-      const message = event.message;
-
-      // Convert message to base64 for FairPlay license request
-      const messageBase64 = this.arrayBufferToBase64(message);
-
-      const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
-      if (!licenseUrl) {
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.CONFIGURATION_ERROR,
-          'FairPlay license URL not provided',
-          true
-        );
-      }
-
-      // Request license from server
-      const license = await this.licenseHandler.requestLicense({
-        url: licenseUrl,
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/octet-stream',
-          ...this.config.headers,
-        },
-        body: message,
-        responseType: 'arraybuffer',
-      });
-
-      // Update session with license (CKC - Content Key Context)
-      await this.keySession!.update(license.license);
-
-      this.log('FairPlay license applied successfully');
-    } catch (error: any) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.LICENSE_REQUEST_FAILED,
-        `Failed to process FairPlay license: ${error.message}`,
-        true,
-        error
-      );
-    }
-  }
-
-  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
-    return [{
-      initDataTypes: ['sinf', 'skd'],
-      audioCapabilities: [{
-        contentType: 'audio/mp4; codecs="mp4a.40.2"',
-      }],
-      videoCapabilities: [
-        {
-          contentType: 'application/vnd.apple.mpegurl',
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-        {
-          contentType: 'video/mp4; codecs="avc1.42E01E"',
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-      ],
-      distinctiveIdentifier: 'not-allowed',
-      persistentState: 'not-allowed',
-      sessionTypes: ['temporary'],
-    }];
-  }
-
-  private async createMediaKeySystemAccess(): Promise<MediaKeySystemAccess> {
-    return navigator.requestMediaKeySystemAccess(
-      this.getKeySystem(),
-      this.getKeySystemConfiguration()
-    );
-  }
-
-  private arrayBufferToBase64(buffer: ArrayBuffer): string {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-}

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

@@ -1,156 +0,0 @@
-/**
- * PlayReady DRM Implementation
- * Implements PlayReady DRM for Edge and IE
- */
-
-import { BaseDRM } from './BaseDRM';
-import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
-import type { DRMType } from '@unified-video/core';
-import { DRMErrorHandler } from '../utils/DRMErrorHandler';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-
-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[DRMTypeEnum.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[DRMTypeEnum.PLAYREADY][0];
-  }
-
-  getHLSConfig(): any {
-    this.log('Generating HLS.js config for PlayReady');
-
-    const licenseUrl = this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl;
-
-    return {
-      emeEnabled: true,
-      drmSystems: {
-        [this.getKeySystem()]: {
-          licenseUrl: licenseUrl,
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-        [KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][1]]: {
-          licenseUrl: licenseUrl,
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-      },
-      requestMediaKeySystemAccessFunc: navigator.requestMediaKeySystemAccess.bind(navigator),
-      licenseXhrSetup: (xhr: XMLHttpRequest, url: string) => {
-        this.log(`[LicenseXHR] (PlayReady) Requesting license from: ${url}`);
-
-        if (this.config.headers) {
-          Object.keys(this.config.headers).forEach(key => {
-            xhr.setRequestHeader(key, this.config.headers![key]);
-          });
-        }
-
-        xhr.addEventListener('readystatechange', () => {
-          if (xhr.readyState === 4) {
-            if (xhr.status >= 200 && xhr.status < 300) {
-              this.log(`[LicenseXHR] PlayReady license received (Status: ${xhr.status}, Size: ${xhr.response?.byteLength || 0} bytes)`);
-            } else {
-              this.log(`[LicenseXHR] ❌ PlayReady license request failed! (Status: ${xhr.status}, URL: ${url})`);
-
-              if (xhr.responseType === '' || xhr.responseType === 'text') {
-                this.log(`[LicenseXHR] Response Body: ${xhr.responseText}`);
-              }
-            }
-          }
-        });
-      }
-    };
-  }
-
-  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[DRMTypeEnum.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[DRMTypeEnum.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[DRMTypeEnum.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

@@ -1,133 +0,0 @@
-/**
- * Widevine DRM Implementation
- * Implements Widevine DRM for Chrome, Firefox, Edge, Android
- */
-
-import { BaseDRM } from './BaseDRM';
-import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
-import type { DRMType } from '@unified-video/core';
-import { DRMErrorHandler } from '../utils/DRMErrorHandler';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-
-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[DRMTypeEnum.WIDEVINE][0];
-  }
-
-  getHLSConfig(): any {
-    this.log('Generating HLS.js config for Widevine');
-
-    const licenseUrl = this.config.licenseUrl || this.config.widevineOptions?.licenseUrl;
-
-    return {
-      emeEnabled: true,
-      drmSystems: {
-        [this.getKeySystem()]: {
-          licenseUrl: licenseUrl,
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-      },
-      requestMediaKeySystemAccessFunc: navigator.requestMediaKeySystemAccess.bind(navigator),
-      licenseXhrSetup: (xhr: XMLHttpRequest, url: string) => {
-        this.log(`[LicenseXHR] Requesting license from: ${url}`);
-
-        // Add custom headers if provided
-        if (this.config.headers) {
-          Object.keys(this.config.headers).forEach(key => {
-            xhr.setRequestHeader(key, this.config.headers![key]);
-          });
-        }
-
-        xhr.addEventListener('readystatechange', () => {
-          if (xhr.readyState === 4) {
-            if (xhr.status >= 200 && xhr.status < 300) {
-              this.log(`[LicenseXHR] License received successfully (Status: ${xhr.status}, Size: ${xhr.response?.byteLength || 0} bytes)`);
-            } else {
-              this.log(`[LicenseXHR] ❌ License request failed! (Status: ${xhr.status}, URL: ${url})`);
-
-              // Only try to read responseText if the response is actually text
-              if (xhr.responseType === '' || xhr.responseType === 'text') {
-                this.log(`[LicenseXHR] Response Body: ${xhr.responseText}`);
-              }
-            }
-          }
-        });
-      }
-    };
-  }
-
-  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

@@ -1,35 +0,0 @@
-/**
- * Bunny.net DRM Type Definitions
- * Type definitions specific to Bunny.net MediaCage DRM integration
- */
-
-import type { 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}`,
-};