dasha 2.3.5 → 3.0.0

package/lib/manifest.js

@@ -1,260 +0,0 @@
-'use strict';
-
-const { parseXml } = require('./xml');
-const { processManifest } = require('./processor');
-const { getQualityLabel, getHeightByWidth, getClosest, sanitizeBaseUrl } = require('./utils');
-const { CONTENT_TYPE, KEY_SYSTEMS } = require('./constants');
-
-const isUrl = (value) => {
-  try {
-    return !!new URL(value);
-  } catch (e) {
-    return false;
-  }
-};
-
-class Manifest {
-  constructor(manifest) {
-    for (const key of Object.keys(manifest)) this[key] = manifest[key];
-  }
-
-  addBaseUrl(value) {
-    const sanitizedValue = sanitizeBaseUrl(value);
-    if (Array.isArray(this.baseUrls)) this.baseUrls.push(sanitizedValue);
-    else this.baseUrls = [sanitizedValue];
-  }
-
-  getVideoTrack(height) {
-    const isVideoAdaptationSet = (adaptationSet) =>
-      adaptationSet.contentType === CONTENT_TYPE.video ||
-      adaptationSet.mimeType?.includes('video') ||
-      adaptationSet.maxWidth ||
-      adaptationSet.maxHeight;
-    const adaptationSets = this.periods
-      .map((p) => p.adaptationSets)
-      .flat(1)
-      .filter(isVideoAdaptationSet);
-    const representations = adaptationSets.map((a) => a.representations).flat(2);
-
-    let suitableRepresentations = [];
-    if (height) {
-      const resolutions = representations.map((r) => ({
-        height: getHeightByWidth(r.width),
-        width: r.width,
-      }));
-      const heights = resolutions.map((r) => r.height);
-      const matchedHeight = height ? getClosest(height, heights) : Math.max(...heights);
-      const matchedResolution = resolutions.find((r) => r.height === matchedHeight);
-      const matchesInHeight = representations.filter((r) => matchedResolution.width === r.width);
-      const matchesInId = representations.filter((r) => r.id.includes(height.toString()));
-      suitableRepresentations = matchesInHeight?.length ? matchesInHeight : matchesInId;
-    }
-
-    const representation = this.findBestRepresentation(
-      suitableRepresentations.length ? suitableRepresentations : representations
-    );
-    const adaptationSet = adaptationSets.find((a) => a.representations.includes(representation));
-    let codec = 'x264';
-    if (representation.codecs.includes('hvc') || representation.codecs.includes('hev'))
-      codec = 'x265';
-    let bitDepth = '8bit';
-    if (representation.codecs.includes('.2.4.')) bitDepth = '10bit';
-    if (representation.codecs.includes('.4.16.')) bitDepth = '12bit';
-    return {
-      id: 0,
-      type: CONTENT_TYPE.video,
-      pssh: this.getWidevinePssh(adaptationSet),
-      licenseUrl: this.getWidevineLicenseUrl(adaptationSet),
-      segments: this.getSegments(adaptationSet, representation),
-      bitrate: Math.round(representation.bandwidth / 1000), // Kbps
-      size: Math.ceil((representation.bandwidth / 8e6) * this.mediaPresentationDuration), // MB
-      width: representation.width,
-      height: representation.height,
-      qualityLabel: getQualityLabel(representation.width),
-      hevc: representation.codecs.includes('hvc') || representation.codecs.includes('hev'),
-      codec,
-      codecs: representation.codecs,
-      bitDepth,
-    };
-  }
-
-  getAudioTracks(languages) {
-    const filterAudio = (adaptationSet) =>
-      (adaptationSet.contentType === CONTENT_TYPE.audio ||
-        adaptationSet.mimeType?.includes('audio') ||
-        adaptationSet.representations.some((r) => r.mimeType?.includes('audio'))) &&
-      !adaptationSet.maxWidth;
-    const filterLanguages = (adaptationSet) =>
-      languages?.length ? languages.some((lang) => adaptationSet.lang?.includes(lang)) : true;
-    const adaptationSets = this.periods
-      .map((p) => p.adaptationSets)
-      .flat(1)
-      .filter(filterAudio)
-      .filter(filterLanguages);
-
-    const tracks = [];
-    for (const adaptationSet of adaptationSets) {
-      const representation = this.findBestRepresentation(adaptationSet.representations);
-      let codec = '';
-      const track = {
-        id: tracks.length,
-        type: CONTENT_TYPE.audio,
-        label: adaptationSet.label,
-        language: adaptationSet.lang,
-        pssh: this.getWidevinePssh(adaptationSet),
-        licenseUrl: this.getWidevineLicenseUrl(adaptationSet),
-        segments: this.getSegments(adaptationSet, representation),
-        bitrate: Math.round(representation.bandwidth / 1000), // Kbps
-        size: Math.ceil((representation.bandwidth / 8e6) * this.mediaPresentationDuration), // MB
-        audioSamplingRate: representation.audioSamplingRate / 1000,
-        codecs: representation.codecs,
-      };
-      tracks.push(track);
-    }
-
-    return tracks;
-  }
-
-  getSubtitleTracks(languages) {
-    const isSubtitleAdaptationSet = (adaptationSet) =>
-      (adaptationSet.contentType === CONTENT_TYPE.text ||
-        adaptationSet.mimeType?.includes('text')) &&
-      !adaptationSet.maxWidth;
-    const adaptationSets = this.periods
-      .map((p) => p.adaptationSets)
-      .flat(1)
-      .filter(isSubtitleAdaptationSet);
-
-    const representations = adaptationSets.map((a) => a.representations).flat(2);
-    const matches = representations.filter((r) =>
-      languages?.length ? languages?.some((lang) => r.lang.includes(lang)) : true
-    );
-    const selectedRepresentations = matches?.length ? matches : representations;
-
-    const tracks = [];
-    for (const representation of selectedRepresentations) {
-      const adaptationSet = adaptationSets.find((a) => a.representations.includes(representation));
-      const baseUrl = this.baseUrls?.[0];
-      const representationBaseUrl = representation.baseUrls?.[0];
-      const url = isUrl(representationBaseUrl)
-        ? representationBaseUrl
-        : `${baseUrl || ''}${representationBaseUrl || ''}`;
-      const track = {
-        id: tracks.length,
-        type: CONTENT_TYPE.text,
-        label: adaptationSet.label,
-        language: adaptationSet.lang,
-        format: representation.mimeType?.split('/')[1] || adaptationSet.mimeType?.split('/')[1],
-        segments: [{ url }],
-        bitrate: Math.round(representation.bandwidth / 1000), // Kbps
-        size: Math.ceil((representation.bandwidth / 8e6) * this.mediaPresentationDuration), // MB
-      };
-      tracks.push(track);
-    }
-
-    return tracks;
-  }
-
-  getWidevinePssh(adaptationSet) {
-    const isWidevineProtection = (protection) =>
-      protection.schemeIdUri === KEY_SYSTEMS['com.widevine.alpha'];
-    return adaptationSet?.contentProtections?.find(isWidevineProtection)?.cencPssh || null;
-  }
-
-  getWidevineLicenseUrl(adaptationSet) {
-    const isWidevineProtection = (protection) =>
-      protection.schemeIdUri === KEY_SYSTEMS['com.widevine.alpha'];
-    return adaptationSet?.contentProtections?.find(isWidevineProtection)?.licenseUrl || null;
-  }
-
-  findBestRepresentation(representations) {
-    const bandwidths = representations.map((r) => r.bandwidth);
-    const maxBandwidth = Math.max(...bandwidths);
-    return representations.find((r) => r.bandwidth === maxBandwidth);
-  }
-
-  getSegments(adaptationSet, representation) {
-    const segments = [];
-    const segmentTemplate = representation.segmentTemplate || adaptationSet.segmentTemplate;
-    const baseUrls = representation.baseUrls || this.baseUrls;
-    const isBaseUrlRequired = !segmentTemplate.media.includes(`https://`);
-    const baseUrl = baseUrls?.[0];
-    const initTemplate = segmentTemplate.initialization;
-    const initUrl = initTemplate
-      ?.replace(/\$Bandwidth\$/i, representation.bandwidth)
-      ?.replace(/\$RepresentationID\$/i, representation.id);
-    const initFullUrl = isBaseUrlRequired ? baseUrl + initUrl : initUrl;
-    if (initUrl) segments.push({ url: initFullUrl, init: true });
-
-    const mediaTemplate = segmentTemplate.media.replace(/\$Bandwidth\$/i, representation.bandwidth);
-    let time = 0;
-    let index = parseInt(segmentTemplate.startNumber || segmentTemplate.start) || 0;
-
-    let s = segmentTemplate['SegmentTimeline']?.['S'];
-    if (!!s && !Array.isArray(segmentTemplate['SegmentTimeline']?.['S']))
-      s = [segmentTemplate['SegmentTimeline']?.['S']];
-
-    for (let i = 0; i < (s?.length || segmentTemplate.duration); i++) {
-      const segment = s?.[i] || {};
-      const repeats = parseInt(segment.r || '0') + 1;
-      if (segment.t) time = parseInt(segment.t);
-      const duration = parseInt(segment.d || segmentTemplate.timescale || '0');
-      for (let i = 0; i < repeats; i++) {
-        const url = mediaTemplate
-          ?.replace(/\$Number\$/i, index + '')
-          ?.replace(/\$Time\$/i, time + '')
-          ?.replace(/\$RepresentationID\$/i, representation.id);
-        const fullUrl = isBaseUrlRequired ? baseUrl + url : url;
-        segments.push({ url: fullUrl });
-        index++;
-        time += duration;
-      }
-    }
-
-    return segments;
-  }
-
-  getPssh(schemeIdUri = KEY_SYSTEMS['com.widevine.alpha']) {
-    let pssh = null;
-    for (const period of this.periods)
-      for (const adaptationSet of period.adaptationSets) {
-        for (const representation of adaptationSet.representations) {
-          if (!representation.contentProtections) continue;
-          for (const contentProtection of representation.contentProtections)
-            if (contentProtection.cencPssh && contentProtection.schemeIdUri === schemeIdUri) {
-              pssh = contentProtection.cencPssh;
-              break;
-            }
-        }
-        if (!adaptationSet.contentProtections) continue;
-        for (const contentProtection of adaptationSet.contentProtections)
-          if (contentProtection.cencPssh && contentProtection.schemeIdUri === schemeIdUri) {
-            pssh = contentProtection.cencPssh;
-            break;
-          }
-      }
-    return pssh;
-  }
-
-  getLicenseUrl(schemeIdUri = KEY_SYSTEMS['com.widevine.alpha']) {
-    let licenseUrl = null;
-    for (const period of this.periods)
-      for (const adaptationSet of period.adaptationSets) {
-        if (!adaptationSet.contentProtections) continue;
-        for (const contentProtection of adaptationSet.contentProtections)
-          if (contentProtection.licenseUrl && contentProtection.schemeIdUri === schemeIdUri) {
-            licenseUrl = contentProtection.licenseUrl;
-            break;
-          }
-      }
-    return licenseUrl;
-  }
-}
-
-const parseManifest = (text) => {
-  const parsedXml = parseXml(text);
-  const manifest = processManifest(parsedXml);
-  return manifest ? new Manifest(manifest) : null;
-};
-
-module.exports = { parseManifest };

package/lib/processor.js

@@ -1,99 +0,0 @@
-const { parseDuration, sanitizeBaseUrl } = require('./utils');
-
-const processElement = (element, type) => {
-  if (!element) return;
-  switch (type) {
-    case 'array':
-      return Array.isArray(element) ? element : [element];
-    case 'number':
-      return parseInt(element);
-    case 'duration':
-      return parseDuration(element);
-    default:
-      return element;
-  }
-};
-
-const processRepresentation = (representation) => {
-  const contentProtectionsList = processElement(representation?.['ContentProtection'], 'array');
-  const contentProtections = contentProtectionsList?.map((c) => processContentProtection(c));
-  return {
-    id: representation['id'],
-    baseUrls: processElement(representation['BaseURL'], 'array')?.map((url) =>
-      sanitizeBaseUrl(url.value)
-    ),
-    codecs: representation['codecs'],
-    bandwidth: processElement(representation['bandwidth'], 'number'),
-    frameRate: representation['frameRate'],
-    mimeType: representation['mimeType'],
-    audioSamplingRate: processElement(representation['audioSamplingRate'], 'number'),
-    width: processElement(representation['width'], 'number'),
-    height: processElement(representation['height'], 'number'),
-    sar: representation['sar'],
-    startWithSAP: representation['startWithSAP'],
-    segmentTemplate: representation['SegmentTemplate'],
-    contentProtections,
-  };
-};
-
-const processContentProtection = (contentProtection) => {
-  return {
-    schemeIdUri: contentProtection['schemeIdUri'],
-    value: contentProtection['value'],
-    cencDefaultKid: contentProtection['cenc:default_KID'],
-    cencPssh: contentProtection['cenc:pssh']?.['value'],
-    msprPro: contentProtection['mspr:pro']?.['value'],
-    licenseUrl: contentProtection['ms:laurl']?.['licenseUrl'],
-  };
-};
-
-const processAdaptationSet = (adaptationSet) => {
-  const contentProtectionsList = processElement(adaptationSet?.['ContentProtection'], 'array');
-  const contentProtections = contentProtectionsList?.map((c) => processContentProtection(c));
-  const representationsList = processElement(adaptationSet['Representation'], 'array');
-  const representations = representationsList.map((r) => processRepresentation(r));
-  return {
-    id: adaptationSet['id'],
-    group: processElement(adaptationSet['group'], 'number'),
-    baseUrls: processElement(adaptationSet['BaseURL'], 'array')?.map((url) =>
-      sanitizeBaseUrl(url.value)
-    ),
-    segmentAlignment: adaptationSet['segmentAlignment'],
-    lang: adaptationSet['lang'],
-    maxWidth: processElement(adaptationSet['maxWidth'], 'number'),
-    maxHeight: processElement(adaptationSet['maxHeight'], 'number'),
-    maxFrameRate: adaptationSet['maxFrameRate'],
-    contentType: adaptationSet['contentType'],
-    segmentTemplate: adaptationSet['SegmentTemplate'],
-    mimeType: adaptationSet['mimeType'],
-    label: adaptationSet['label'],
-    contentProtections,
-    representations,
-  };
-};
-
-const processPeriod = (period) => {
-  const adaptationSetsList = processElement(period['AdaptationSet'], 'array');
-  const adaptationSets = adaptationSetsList.map((a) => processAdaptationSet(a));
-  return {
-    id: processElement(period['id'], 'number'),
-    start: processElement(period['start'], 'duration'),
-    duration: processElement(period['duration'], 'duration'),
-    adaptationSets,
-  };
-};
-
-const processManifest = (parsedXml) => {
-  const mpd = parsedXml.MPD;
-  const periodsList = processElement(mpd['Period'], 'array');
-  if (!periodsList.length) return null;
-  return {
-    periods: periodsList.map((p) => processPeriod(p)),
-    baseUrls: processElement(mpd['BaseURL'], 'array')?.map((url) => sanitizeBaseUrl(url.value)),
-    locations: processElement(mpd['Location'], 'array'),
-    profiles: mpd['profiles'],
-    mediaPresentationDuration: processElement(mpd['mediaPresentationDuration'], 'duration'),
-  };
-};
-
-module.exports = { processManifest };

package/lib/utils.js

@@ -1,63 +0,0 @@
-/**
- * Parses an XML duration string.
- * @param {string} durationString The duration string, e.g., "PT1H3M43.2S",
- *   which means 1 hour, 3 minutes, and 43.2 seconds.
- * @return {?number} The parsed duration in seconds on success; otherwise,
- *   return null.
- * @see {@link http://www.datypic.com/sc/xsd/t-xsd_duration.html}
- */
-const parseDuration = (durationString) => {
-  if (!durationString) return null;
-
-  const re =
-    '^P(?:([0-9]*)Y)?(?:([0-9]*)M)?(?:([0-9]*)D)?' +
-    '(?:T(?:([0-9]*)H)?(?:([0-9]*)M)?(?:([0-9.]*)S)?)?$';
-  const matches = new RegExp(re).exec(durationString);
-  if (!matches) return null;
-
-  // Note: Number(null) == 0 but Number(undefined) == NaN.
-  const years = Number(matches[1] || null);
-  const months = Number(matches[2] || null);
-  const days = Number(matches[3] || null);
-  const hours = Number(matches[4] || null);
-  const minutes = Number(matches[5] || null);
-  const seconds = Number(matches[6] || null);
-
-  // Assume a year always has 365 days and a month always has 30 days.
-  const d =
-    60 * 60 * 24 * 365 * years +
-    60 * 60 * 24 * 30 * months +
-    60 * 60 * 24 * days +
-    60 * 60 * hours +
-    60 * minutes +
-    seconds;
-  return isFinite(d) ? d : null;
-};
-
-const getHeightByWidth = (videoWidth) => {
-  const width = typeof videoWidth === 'number' ? videoWidth : parseInt(videoWidth);
-  if (isNaN(width)) return;
-  let height = 144;
-  if (width >= 426) height = 240;
-  if (width >= 640) height = 360;
-  if (width >= 854) height = 480;
-  if (width >= 1024) height = 576;
-  if (width >= 1280) height = 720;
-  if (width >= 1920) height = 1080;
-  if (width >= 3840) height = 2160;
-  if (width >= 7680) height = 4320;
-  return height;
-};
-
-const getClosest = (value, array) =>
-  array.reduce((prev, curr) => (Math.abs(curr - value) < Math.abs(prev - value) ? curr : prev));
-
-const getQualityLabel = (videoWidth) => getHeightByWidth(videoWidth) + 'p';
-
-const sanitizeBaseUrl = (value) => {
-  if (!value.includes('.mpd')) return value;
-  const manifestFilename = value.split('.mpd')[0].split('/').at(-1) + '.mpd';
-  return value.replace(manifestFilename, '');
-};
-
-module.exports = { parseDuration, getHeightByWidth, getQualityLabel, getClosest, sanitizeBaseUrl };

package/types/constants.d.ts

@@ -1,5 +0,0 @@
-declare const CONTENT_TYPE: Record<string, string>;
-
-declare const KEY_SYSTEMS: Record<string, string>;
-
-export { CONTENT_TYPE, KEY_SYSTEMS };

package/types/manifest.d.ts

@@ -1,52 +0,0 @@
-import { AdaptationSet, ProcessedManifest, Representation } from './processor';
-import { QualityLabel } from './utils';
-
-declare class Manifest extends ProcessedManifest {
-  constructor(manifest: ProcessedManifest);
-
-  getVideoTrack(height: number): VideoTrack;
-  getAudioTracks(languages: string[]): AudioTrack[];
-  getSubtitleTracks(languages: string[]): SubtitleTrack[];
-  getWidevinePssh(adaptationSet: AdaptationSet): string | null;
-  getWidevineLicenseUrl(adaptationSet: AdaptationSet): string | null;
-  findBestRepresentation(representations: Representation[]): Representation;
-  getSegments(adaptationSet: AdaptationSet, representation: Representation): Segment[];
-  getPssh(): string | null;
-  getLicenseUrl(): string | null;
-}
-
-interface MediaTrack {
-  type: 'video' | 'audio' | 'text';
-  segments: Segment[];
-  bitrate: number; // Kbps
-  size: number; // MB
-  pssh: string | null;
-  licenseUrl: string | null;
-}
-
-interface VideoTrack extends MediaTrack {
-  type: 'video';
-  width: number;
-  height: number;
-  quality: QualityLabel;
-}
-
-interface AudioTrack extends MediaTrack {
-  type: 'audio';
-  audioSampleRate: number;
-  language: string;
-}
-
-interface SubtitleTrack extends MediaTrack {
-  type: 'text';
-  language: string;
-}
-
-interface Segment {
-  url: string;
-  init?: boolean;
-}
-
-declare const parseManifest: (text: string) => Manifest | null;
-
-export { parseManifest, Manifest, VideoTrack, AudioTrack, SubtitleTrack };

package/types/processor.d.ts

@@ -1,63 +0,0 @@
-interface ProcessedManifest {
-  periods: Period[];
-  baseUrls: string[];
-  locations: string[];
-  profiles: string;
-  mediaPresentationDuration: number;
-}
-
-interface Period {
-  id: number;
-  start: number;
-  duration: number;
-  adaptationSets: AdaptationSet[];
-}
-
-interface AdaptationSet {
-  id: string;
-  group: number;
-  baseUrls: string[];
-  segmentAlignment: string;
-  lang: string;
-  maxWidth: number;
-  maxHeight: number;
-  maxFrameRate: string;
-  contentType: string;
-  segmentTemplate: Record<string, any>;
-  contentProtections: ContentProtection[];
-  representations: Representation[];
-}
-
-interface Representation {
-  id: string;
-  baseUrls: string[]; // TODO: Check type
-  codecs: string;
-  bandwidth: number;
-  frameRate: string;
-  mimeType: string;
-  audioSamplingRate: number;
-  width: number;
-  height: number;
-  sar: string;
-  startWithSAP: string;
-}
-
-interface ContentProtection {
-  schemeIdUri: string;
-  value: string;
-  cencDefaultKid: string;
-  cencPssh: string;
-  msprPro: string;
-  licenseUrl: string;
-}
-
-declare const processManifest: (parsedXml: Record<string, any>) => ProcessedManifest;
-
-export {
-  processManifest,
-  ProcessedManifest,
-  Period,
-  AdaptationSet,
-  Representation,
-  ContentProtection,
-};

package/types/utils.d.ts

@@ -1,7 +0,0 @@
-declare function parseDuration(durationString: string): number | null;
-
-type QualityLabel = 'SD' | 'HD' | 'Full HD' | '4K';
-
-declare function getQualityLabel(videoHeight: number): QualityLabel;
-
-export { parseDuration, getQualityLabel, QualityLabel };

package/types/xml.d.ts

@@ -1,3 +0,0 @@
-declare const parseXml: (text: string) => Record<string, any>;
-
-export { parseXml };