@zenvor/hls.js 1.0.0

package/src/utils/logger.ts

@@ -0,0 +1,120 @@
+export interface ILogFunction {
+  (message?: any, ...optionalParams: any[]): void;
+}
+
+export interface ILogger {
+  trace: ILogFunction;
+  debug: ILogFunction;
+  log: ILogFunction;
+  warn: ILogFunction;
+  info: ILogFunction;
+  error: ILogFunction;
+}
+
+export class Logger implements ILogger {
+  trace: ILogFunction;
+  debug: ILogFunction;
+  log: ILogFunction;
+  warn: ILogFunction;
+  info: ILogFunction;
+  error: ILogFunction;
+
+  constructor(label: string, logger: ILogger) {
+    const lb = `[${label}]:`;
+    this.trace = noop;
+    this.debug = logger.debug.bind(null, lb);
+    this.log = logger.log.bind(null, lb);
+    this.warn = logger.warn.bind(null, lb);
+    this.info = logger.info.bind(null, lb);
+    this.error = logger.error.bind(null, lb);
+  }
+}
+
+const noop: ILogFunction = function () {};
+
+const fakeLogger: ILogger = {
+  trace: noop,
+  debug: noop,
+  log: noop,
+  warn: noop,
+  info: noop,
+  error: noop,
+};
+
+function createLogger() {
+  return Object.assign({}, fakeLogger);
+}
+
+// let lastCallTime;
+// function formatMsgWithTimeInfo(type, msg) {
+//   const now = Date.now();
+//   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
+//   lastCallTime = now;
+//   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
+//   return msg;
+// }
+
+function consolePrintFn(type: string, id: string | undefined): ILogFunction {
+  const func: ILogFunction = self.console[type];
+  return func
+    ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`)
+    : noop;
+}
+
+function getLoggerFn(
+  key: string,
+  debugConfig: boolean | Partial<ILogger>,
+  id?: string,
+): ILogFunction {
+  return debugConfig[key]
+    ? debugConfig[key].bind(debugConfig)
+    : consolePrintFn(key, id);
+}
+
+const exportedLogger: ILogger = createLogger();
+
+export function enableLogs(
+  debugConfig: boolean | ILogger,
+  context: string,
+  id?: string | undefined,
+): ILogger {
+  // check that console is available
+  const newLogger = createLogger();
+  if (
+    (typeof console === 'object' && debugConfig === true) ||
+    typeof debugConfig === 'object'
+  ) {
+    const keys: (keyof ILogger)[] = [
+      // Remove out from list here to hard-disable a log-level
+      // 'trace',
+      'debug',
+      'log',
+      'info',
+      'warn',
+      'error',
+    ];
+    keys.forEach((key) => {
+      newLogger[key] = getLoggerFn(key, debugConfig, id);
+    });
+    // Some browsers don't allow to use bind on console object anyway
+    // fallback to default if needed
+    try {
+      newLogger.log(
+        `Debug logs enabled for "${context}" in hls.js version ${__VERSION__}`,
+      );
+    } catch (e) {
+      /* log fn threw an exception. All logger methods are no-ops. */
+      return createLogger();
+    }
+    // global exported logger uses the same functions as new logger without `id`
+    keys.forEach((key) => {
+      exportedLogger[key] = getLoggerFn(key, debugConfig);
+    });
+  } else {
+    // Reset global exported logger
+    Object.assign(exportedLogger, newLogger);
+  }
+  return newLogger;
+}
+
+export const logger: ILogger = exportedLogger;

package/src/utils/media-option-attributes.ts

@@ -0,0 +1,49 @@
+import type { Level } from '../types/level';
+import type { MediaAttributes, MediaPlaylist } from '../types/media-playlist';
+
+export function subtitleOptionsIdentical(
+  trackList1: MediaPlaylist[] | Level[],
+  trackList2: MediaPlaylist[],
+): boolean {
+  if (trackList1.length !== trackList2.length) {
+    return false;
+  }
+  for (let i = 0; i < trackList1.length; i++) {
+    if (
+      !mediaAttributesIdentical(
+        trackList1[i].attrs as MediaAttributes,
+        trackList2[i].attrs,
+      )
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function mediaAttributesIdentical(
+  attrs1: MediaAttributes,
+  attrs2: MediaAttributes,
+  customAttributes?: string[],
+): boolean {
+  // Media options with the same rendition ID must be bit identical
+  const stableRenditionId = attrs1['STABLE-RENDITION-ID'];
+  if (stableRenditionId && !customAttributes) {
+    return stableRenditionId === attrs2['STABLE-RENDITION-ID'];
+  }
+  // When rendition ID is not present, compare attributes
+  return !(
+    customAttributes || [
+      'LANGUAGE',
+      'NAME',
+      'CHARACTERISTICS',
+      'AUTOSELECT',
+      'DEFAULT',
+      'FORCED',
+      'ASSOC-LANGUAGE',
+    ]
+  ).some(
+    (subtitleAttribute) =>
+      attrs1[subtitleAttribute] !== attrs2[subtitleAttribute],
+  );
+}

package/src/utils/mediacapabilities-helper.ts

@@ -0,0 +1,301 @@
+import {
+  fillInMissingAV01Params,
+  getCodecsForMimeType,
+  mimeTypeForCodec,
+  userAgentHevcSupportIsInaccurate,
+} from './codecs';
+import { isHEVC } from './mp4-tools';
+import type { AudioTracksByGroup } from './rendition-helper';
+import type { Level, VideoRange } from '../types/level';
+import type { AudioSelectionOption } from '../types/media-playlist';
+
+export type MediaDecodingInfo = {
+  supported: boolean;
+  configurations: readonly MediaDecodingConfiguration[];
+  decodingInfoResults: readonly MediaCapabilitiesDecodingInfo[];
+  error?: Error;
+};
+
+// @ts-ignore
+const supportedResult: MediaCapabilitiesDecodingInfo = {
+  supported: true,
+  powerEfficient: true,
+  smooth: true,
+  // keySystemAccess: null,
+};
+
+// @ts-ignore
+const unsupportedResult: MediaCapabilitiesDecodingInfo = {
+  supported: false,
+  smooth: false,
+  powerEfficient: false,
+  // keySystemAccess: null,
+};
+
+export const SUPPORTED_INFO_DEFAULT: MediaDecodingInfo = {
+  supported: true,
+  configurations: [] as MediaDecodingConfiguration[],
+  decodingInfoResults: [supportedResult],
+} as const;
+
+export function getUnsupportedResult(
+  error: Error,
+  configurations: MediaDecodingConfiguration[],
+): MediaDecodingInfo {
+  return {
+    supported: false,
+    configurations,
+    decodingInfoResults: [unsupportedResult],
+    error,
+  };
+}
+
+export function requiresMediaCapabilitiesDecodingInfo(
+  level: Level,
+  audioTracksByGroup: AudioTracksByGroup,
+  currentVideoRange: VideoRange | undefined,
+  currentFrameRate: number,
+  currentBw: number,
+  audioPreference: AudioSelectionOption | undefined,
+): boolean {
+  // Only test support when configuration is exceeds minimum options
+  const videoCodecs = level.videoCodec;
+  const audioGroups = level.audioCodec ? level.audioGroups : null;
+  const audioCodecPreference = audioPreference?.audioCodec;
+  const channelsPreference = audioPreference?.channels;
+  const maxChannels = channelsPreference
+    ? parseInt(channelsPreference)
+    : audioCodecPreference
+      ? Infinity
+      : 2;
+  let audioChannels: Record<string, number> | null = null;
+  if (audioGroups?.length) {
+    try {
+      if (audioGroups.length === 1 && audioGroups[0]) {
+        audioChannels = audioTracksByGroup.groups[audioGroups[0]].channels;
+      } else {
+        audioChannels = audioGroups.reduce(
+          (acc, groupId) => {
+            if (groupId) {
+              const audioTrackGroup = audioTracksByGroup.groups[groupId];
+              if (!audioTrackGroup) {
+                throw new Error(`Audio track group ${groupId} not found`);
+              }
+              // Sum all channel key values
+              Object.keys(audioTrackGroup.channels).forEach((key) => {
+                acc[key] = (acc[key] || 0) + audioTrackGroup.channels[key];
+              });
+            }
+            return acc;
+          },
+          { 2: 0 },
+        );
+      }
+    } catch (error) {
+      return true;
+    }
+  }
+  return (
+    (videoCodecs !== undefined &&
+      // Force media capabilities check for HEVC to avoid failure on Windows
+      (videoCodecs.split(',').some((videoCodec) => isHEVC(videoCodec)) ||
+        (level.width > 1920 && level.height > 1088) ||
+        (level.height > 1920 && level.width > 1088) ||
+        level.frameRate > Math.max(currentFrameRate, 30) ||
+        (level.videoRange !== 'SDR' &&
+          level.videoRange !== currentVideoRange) ||
+        level.bitrate > Math.max(currentBw, 8e6))) ||
+    (!!audioChannels &&
+      Number.isFinite(maxChannels) &&
+      Object.keys(audioChannels).some(
+        (channels) => parseInt(channels) > maxChannels,
+      ))
+  );
+}
+
+export function getMediaDecodingInfoPromise(
+  level: Level,
+  audioTracksByGroup: AudioTracksByGroup,
+  mediaCapabilities: MediaCapabilities | undefined,
+  cache: Record<
+    string,
+    Promise<MediaCapabilitiesDecodingInfo> | undefined
+  > = {},
+): Promise<MediaDecodingInfo> {
+  const videoCodecs = level.videoCodec;
+  if ((!videoCodecs && !level.audioCodec) || !mediaCapabilities) {
+    return Promise.resolve(SUPPORTED_INFO_DEFAULT);
+  }
+
+  const configurations: MediaDecodingConfiguration[] = [];
+
+  const videoDecodeList = makeVideoConfigurations(level);
+  const videoCount = videoDecodeList.length;
+  const audioDecodeList = makeAudioConfigurations(
+    level,
+    audioTracksByGroup,
+    videoCount > 0,
+  );
+  const audioCount = audioDecodeList.length;
+  for (let i = videoCount || 1 * audioCount || 1; i--; ) {
+    const configuration: MediaDecodingConfiguration = {
+      type: 'media-source',
+    };
+    if (videoCount) {
+      configuration.video = videoDecodeList[i % videoCount];
+    }
+    if (audioCount) {
+      configuration.audio = audioDecodeList[i % audioCount];
+      const audioBitrate = configuration.audio.bitrate;
+      if (configuration.video && audioBitrate) {
+        configuration.video.bitrate -= audioBitrate;
+      }
+    }
+    configurations.push(configuration);
+  }
+
+  if (videoCodecs) {
+    // Override Windows Firefox HEVC MediaCapabilities result (https://github.com/video-dev/hls.js/issues/7046)
+    const ua = navigator.userAgent;
+    if (
+      videoCodecs.split(',').some((videoCodec) => isHEVC(videoCodec)) &&
+      userAgentHevcSupportIsInaccurate()
+    ) {
+      return Promise.resolve(
+        getUnsupportedResult(
+          new Error(
+            `Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent string: (${ua})`,
+          ),
+          configurations,
+        ),
+      );
+    }
+  }
+
+  return Promise.all(
+    configurations.map((configuration) => {
+      // Cache MediaCapabilities promises
+      const decodingInfoKey = getMediaDecodingInfoKey(configuration);
+      return (
+        cache[decodingInfoKey] ||
+        (cache[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration))
+      );
+    }),
+  )
+    .then((decodingInfoResults) => ({
+      supported: !decodingInfoResults.some((info) => !info.supported),
+      configurations,
+      decodingInfoResults,
+    }))
+    .catch((error) => ({
+      supported: false,
+      configurations,
+      decodingInfoResults: [] as MediaCapabilitiesDecodingInfo[],
+      error,
+    }));
+}
+
+function makeVideoConfigurations(level: Level): VideoConfiguration[] {
+  const videoCodecs = level.videoCodec?.split(',');
+  const bitrate = getVariantDecodingBitrate(level);
+  const width = level.width || 640;
+  const height = level.height || 480;
+  // Assume a framerate of 30fps since MediaCapabilities will not accept Level default of 0.
+  const framerate = level.frameRate || 30;
+  const videoRange = level.videoRange.toLowerCase() as 'sdr' | 'pq' | 'hlg';
+  return videoCodecs
+    ? videoCodecs.map((videoCodec: string) => {
+        const videoConfiguration: VideoConfiguration = {
+          contentType: mimeTypeForCodec(
+            fillInMissingAV01Params(videoCodec),
+            'video',
+          ),
+          width,
+          height,
+          bitrate,
+          framerate,
+        };
+        if (videoRange !== 'sdr') {
+          videoConfiguration.transferFunction = videoRange as TransferFunction;
+        }
+        return videoConfiguration;
+      })
+    : [];
+}
+
+function makeAudioConfigurations(
+  level: Level,
+  audioTracksByGroup: AudioTracksByGroup,
+  hasVideo: boolean,
+): AudioConfiguration[] {
+  const audioCodecs = level.audioCodec?.split(',');
+  const combinedBitrate = getVariantDecodingBitrate(level);
+  if (audioCodecs && level.audioGroups) {
+    return level.audioGroups.reduce((configurations, audioGroupId) => {
+      const tracks = audioGroupId
+        ? audioTracksByGroup.groups[audioGroupId]?.tracks
+        : null;
+      if (tracks) {
+        return tracks.reduce((configs, audioTrack) => {
+          if (audioTrack.groupId === audioGroupId) {
+            const channelsNumber = parseFloat(audioTrack.channels || '');
+            audioCodecs.forEach((audioCodec) => {
+              const audioConfiguration: AudioConfiguration = {
+                contentType: mimeTypeForCodec(audioCodec, 'audio'),
+                bitrate: hasVideo
+                  ? estimatedAudioBitrate(audioCodec, combinedBitrate)
+                  : combinedBitrate,
+              };
+              if (channelsNumber) {
+                audioConfiguration.channels = '' + channelsNumber;
+              }
+              configs.push(audioConfiguration);
+            });
+          }
+          return configs;
+        }, configurations);
+      }
+      return configurations;
+    }, [] as AudioConfiguration[]);
+  }
+  return [];
+}
+
+export function estimatedAudioBitrate(
+  audioCodec: string | undefined,
+  levelBitrate: number,
+): number {
+  if (levelBitrate <= 1) {
+    return 1;
+  }
+  let audioBitrate = 128000;
+  if (audioCodec === 'ec-3') {
+    audioBitrate = 768000;
+  } else if (audioCodec === 'ac-3') {
+    audioBitrate = 640000;
+  }
+  return Math.min(levelBitrate / 2, audioBitrate); // Don't exceed some % of level bitrate
+}
+
+function getVariantDecodingBitrate(level: Level): number {
+  return (
+    Math.ceil(Math.max(level.bitrate * 0.9, level.averageBitrate) / 1000) *
+      1000 || 1
+  );
+}
+
+function getMediaDecodingInfoKey(config: MediaDecodingConfiguration): string {
+  let key = '';
+  const { audio, video } = config;
+  if (video) {
+    const codec = getCodecsForMimeType(video.contentType);
+    key += `${codec}_r${video.height}x${video.width}f${Math.ceil(video.framerate)}${
+      video.transferFunction || 'sd'
+    }_${Math.ceil(video.bitrate / 1e5)}`;
+  }
+  if (audio) {
+    const codec = getCodecsForMimeType(audio.contentType);
+    key += `${video ? '_' : ''}${codec}_c${audio.channels}`;
+  }
+  return key;
+}

package/src/utils/mediakeys-helper.ts

@@ -0,0 +1,210 @@
+import { optionalSelf } from './global';
+import { changeEndianness } from './keysystem-util';
+import { base64Decode } from './numeric-encoding-utils';
+import type { DRMSystemOptions, EMEControllerConfig } from '../config';
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMediaKeySystemAccess
+ */
+export const enum KeySystems {
+  CLEARKEY = 'org.w3.clearkey',
+  FAIRPLAY = 'com.apple.fps',
+  PLAYREADY = 'com.microsoft.playready',
+  WIDEVINE = 'com.widevine.alpha',
+}
+
+// Playlist #EXT-X-KEY KEYFORMAT values
+export const enum KeySystemFormats {
+  CLEARKEY = 'org.w3.clearkey',
+  FAIRPLAY = 'com.apple.streamingkeydelivery',
+  PLAYREADY = 'com.microsoft.playready',
+  WIDEVINE = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
+}
+
+export function keySystemFormatToKeySystemDomain(
+  format: KeySystemFormats,
+): KeySystems | undefined {
+  switch (format) {
+    case KeySystemFormats.FAIRPLAY:
+      return KeySystems.FAIRPLAY;
+    case KeySystemFormats.PLAYREADY:
+      return KeySystems.PLAYREADY;
+    case KeySystemFormats.WIDEVINE:
+      return KeySystems.WIDEVINE;
+    case KeySystemFormats.CLEARKEY:
+      return KeySystems.CLEARKEY;
+  }
+}
+
+// System IDs for which we can extract a key ID from "encrypted" event PSSH
+export const enum KeySystemIds {
+  CENC = '1077efecc0b24d02ace33c1e52e2fb4b',
+  CLEARKEY = 'e2719d58a985b3c9781ab030af78d30e',
+  FAIRPLAY = '94ce86fb07ff4f43adb893d2fa968ca2',
+  PLAYREADY = '9a04f07998404286ab92e65be0885f95',
+  WIDEVINE = 'edef8ba979d64acea3c827dcd51d21ed',
+}
+
+export function keySystemIdToKeySystemDomain(
+  systemId: KeySystemIds,
+): KeySystems | undefined {
+  if (systemId === KeySystemIds.WIDEVINE) {
+    return KeySystems.WIDEVINE;
+  } else if (systemId === KeySystemIds.PLAYREADY) {
+    return KeySystems.PLAYREADY;
+  } else if (
+    systemId === KeySystemIds.CENC ||
+    systemId === KeySystemIds.CLEARKEY
+  ) {
+    return KeySystems.CLEARKEY;
+  }
+}
+
+export function keySystemDomainToKeySystemFormat(
+  keySystem: KeySystems,
+): KeySystemFormats | undefined {
+  switch (keySystem) {
+    case KeySystems.FAIRPLAY:
+      return KeySystemFormats.FAIRPLAY;
+    case KeySystems.PLAYREADY:
+      return KeySystemFormats.PLAYREADY;
+    case KeySystems.WIDEVINE:
+      return KeySystemFormats.WIDEVINE;
+    case KeySystems.CLEARKEY:
+      return KeySystemFormats.CLEARKEY;
+  }
+}
+
+export function getKeySystemsForConfig(
+  config: EMEControllerConfig,
+): KeySystems[] {
+  const { drmSystems, widevineLicenseUrl } = config;
+  const keySystemsToAttempt: KeySystems[] = drmSystems
+    ? [
+        KeySystems.FAIRPLAY,
+        KeySystems.WIDEVINE,
+        KeySystems.PLAYREADY,
+        KeySystems.CLEARKEY,
+      ].filter((keySystem) => !!drmSystems[keySystem])
+    : [];
+  if (!keySystemsToAttempt[KeySystems.WIDEVINE] && widevineLicenseUrl) {
+    keySystemsToAttempt.push(KeySystems.WIDEVINE);
+  }
+  return keySystemsToAttempt;
+}
+
+export type MediaKeyFunc = (
+  keySystem: KeySystems,
+  supportedConfigurations: MediaKeySystemConfiguration[],
+) => Promise<MediaKeySystemAccess>;
+
+export const requestMediaKeySystemAccess = (function (): MediaKeyFunc | null {
+  if (optionalSelf?.navigator?.requestMediaKeySystemAccess) {
+    return self.navigator.requestMediaKeySystemAccess.bind(self.navigator);
+  } else {
+    return null;
+  }
+})();
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaKeySystemConfiguration
+ */
+export function getSupportedMediaKeySystemConfigurations(
+  keySystem: KeySystems,
+  audioCodecs: string[],
+  videoCodecs: string[],
+  drmSystemOptions: DRMSystemOptions,
+): MediaKeySystemConfiguration[] {
+  let initDataTypes: string[];
+  switch (keySystem) {
+    case KeySystems.FAIRPLAY:
+      initDataTypes = ['cenc', 'sinf'];
+      break;
+    case KeySystems.WIDEVINE:
+    case KeySystems.PLAYREADY:
+      initDataTypes = ['cenc'];
+      break;
+    case KeySystems.CLEARKEY:
+      initDataTypes = ['cenc', 'keyids'];
+      break;
+    default:
+      throw new Error(`Unknown key-system: ${keySystem}`);
+  }
+  return createMediaKeySystemConfigurations(
+    initDataTypes,
+    audioCodecs,
+    videoCodecs,
+    drmSystemOptions,
+  );
+}
+
+function createMediaKeySystemConfigurations(
+  initDataTypes: string[],
+  audioCodecs: string[],
+  videoCodecs: string[],
+  drmSystemOptions: DRMSystemOptions,
+): MediaKeySystemConfiguration[] {
+  const baseConfig: MediaKeySystemConfiguration = {
+    initDataTypes: initDataTypes,
+    persistentState: drmSystemOptions.persistentState || 'optional',
+    distinctiveIdentifier: drmSystemOptions.distinctiveIdentifier || 'optional',
+    sessionTypes: drmSystemOptions.sessionTypes || [
+      drmSystemOptions.sessionType || 'temporary',
+    ],
+    audioCapabilities: audioCodecs.map((codec) => ({
+      contentType: `audio/mp4; codecs=${codec}`,
+      robustness: drmSystemOptions.audioRobustness || '',
+      encryptionScheme: drmSystemOptions.audioEncryptionScheme || null,
+    })),
+    videoCapabilities: videoCodecs.map((codec) => ({
+      contentType: `video/mp4; codecs=${codec}`,
+      robustness: drmSystemOptions.videoRobustness || '',
+      encryptionScheme: drmSystemOptions.videoEncryptionScheme || null,
+    })),
+  };
+
+  return [baseConfig];
+}
+
+export function isPersistentSessionType(
+  drmSystemOptions: DRMSystemOptions | undefined,
+): boolean {
+  return (
+    !!drmSystemOptions &&
+    (drmSystemOptions.sessionType === 'persistent-license' ||
+      !!drmSystemOptions.sessionTypes?.some(
+        (type) => type === 'persistent-license',
+      ))
+  );
+}
+
+export function parsePlayReadyWRM(keyBytes: Uint8Array<ArrayBuffer>) {
+  const keyBytesUtf16 = new Uint16Array(
+    keyBytes.buffer,
+    keyBytes.byteOffset,
+    keyBytes.byteLength / 2,
+  );
+  const keyByteStr = String.fromCharCode.apply(null, Array.from(keyBytesUtf16));
+
+  // Parse Playready WRMHeader XML
+  const xmlKeyBytes = keyByteStr.substring(
+    keyByteStr.indexOf('<'),
+    keyByteStr.length,
+  );
+  const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(xmlKeyBytes, 'text/xml');
+  const keyData = xmlDoc.getElementsByTagName('KID')[0];
+  if (keyData) {
+    const keyId = keyData.childNodes[0]
+      ? keyData.childNodes[0].nodeValue
+      : keyData.getAttribute('VALUE');
+    if (keyId) {
+      const keyIdArray = base64Decode(keyId).subarray(0, 16);
+      // KID value in PRO is a base64-encoded little endian GUID interpretation of UUID
+      // KID value in ‘tenc’ is a big endian UUID GUID interpretation of UUID
+      changeEndianness(keyIdArray);
+      return keyIdArray;
+    }
+  }
+  return null;
+}