dasha 2.3.6 → 3.0.0

package/lib/hls.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const m3u8Parser = require('m3u8-parser');
+const { parseBitrate, getQualityLabel } = require('./util');
+const {
+  createResolutionFilter,
+  createVideoQualityFilter,
+  createAudioLanguageFilter,
+  createSubtitleLanguageFilter,
+} = require('./track');
+
+const parseM3u8 = (manifestString) => {
+  const parser = new m3u8Parser.Parser();
+  parser.push(manifestString);
+  parser.end();
+  return parser.manifest;
+};
+
+const fetchPlaylist = async (url) =>
+  fetch(url)
+    .then((response) => response.text())
+    .then(parseM3u8);
+
+const parseUrl = (playlistUri, manifestUri) => {
+  if (playlistUri.includes('https://')) return playlistUri;
+  const uri = new URL(manifestUri);
+  return uri.origin + playlistUri;
+};
+
+const urlsSame = (url1, url2) => {
+  return new URL(url1).pathname === new URL(url2).pathname;
+};
+
+const parseMediaGroup = (groups, manifestUri) => {
+  const results = [];
+  if (!groups) return results;
+  for (const [groupId, group] of Object.entries(groups)) {
+    for (const [label, entity] of Object.entries(group)) {
+      const url = parseUrl(entity.uri, manifestUri);
+      const existing = results.find((result) => urlsSame(result.url, url));
+      if (!existing)
+        results.push({
+          groupId,
+          label,
+          language: entity.language,
+          url,
+        });
+    }
+  }
+  return results;
+};
+
+const getAudioPlaylists = (m3u8, manifestUri) => {
+  return parseMediaGroup(m3u8.mediaGroups.AUDIO, manifestUri);
+};
+
+const getSubtitlePlaylists = (m3u8, manifestUri) => {
+  return parseMediaGroup(m3u8.mediaGroups.SUBTITLES, manifestUri);
+};
+
+const getVideoPlaylists = (m3u8, manifestUri) => {
+  return m3u8.playlists.map((data) => {
+    const bandwidth = data.attributes.BANDWIDTH;
+    const url = data.resolvedUri || parseUrl(data.uri, manifestUri);
+    const track = { bitrate: parseBitrate(bandwidth), url };
+    if (data.attributes.RESOLUTION) {
+      track.resolution = data.attributes.RESOLUTION;
+      track.quality = getQualityLabel(track.resolution);
+    }
+    if (data.attributes.CODECS) track.codecs = data.attributes.CODECS;
+    if (data.attributes['FRAME-RATE']) track.frameRate = data.attributes['FRAME-RATE'];
+    return track;
+  });
+};
+
+const segmentsDto = (data = []) => {
+  const mapSegment = (item) => ({
+    url: item.resolvedUri || item.uri,
+    duration: item.duration,
+    number: item.number,
+    presentationTime: item.presentationTime,
+  });
+  const segments = data.map(mapSegment);
+  if (data.length && data[0].map?.resolvedUri)
+    segments.unshift({
+      url: data[0].map.resolvedUri,
+      init: true,
+      duration: 0,
+      number: 0,
+      presentationTime: 0,
+    });
+  return segments;
+};
+
+const fetchTrackSegments = (tracks) => {
+  return Promise.all(
+    tracks.map(async (track) => {
+      const playlist = await fetchPlaylist(track.url);
+      track.segments = segmentsDto(playlist.segments);
+      if (playlist.contentProtection) {
+        track.protection = {};
+        const fairplayLegacy = playlist.contentProtection['com.apple.fps.1_0'];
+        if (fairplayLegacy)
+          track.protection.fairplay = {
+            keyFormat: fairplayLegacy.attributes.KEYFORMAT,
+            uri: fairplayLegacy.attributes.URI,
+            method: fairplayLegacy.attributes.METHOD,
+          };
+      }
+    })
+  );
+};
+
+const parseManifest = async (manifestString, manifestUri) => {
+  const m3u8 = parseM3u8(manifestString);
+  const videos = getVideoPlaylists(m3u8, manifestUri);
+  const audios = getAudioPlaylists(m3u8, manifestUri);
+  const subtitles = getSubtitlePlaylists(m3u8, manifestUri);
+
+  await Promise.all([
+    fetchTrackSegments(videos),
+    fetchTrackSegments(audios),
+    fetchTrackSegments(subtitles),
+  ]);
+
+  const manifest = {
+    tracks: {
+      all: videos.concat(audios).concat(subtitles),
+      videos,
+      audios,
+      subtitles,
+      withResolution: createResolutionFilter(videos),
+      withVideoQuality: createVideoQualityFilter(videos),
+      withAudioLanguages: createAudioLanguageFilter(audios),
+      withSubtitleLanguages: createSubtitleLanguageFilter(subtitles),
+    },
+  };
+
+  return manifest;
+};
+
+module.exports = { parseManifest };

package/lib/subtitle.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const { parseMimes } = require('./track');
+const { parseBitrate, parseSize } = require('./util');
+
+const SUBTITLE_CODECS = {
+  SubRip: 'SRT', // https://wikipedia.org/wiki/SubRip
+  SubStationAlpha: 'SSA', // https://wikipedia.org/wiki/SubStation_Alpha
+  SubStationAlphav4: 'ASS', // https://wikipedia.org/wiki/SubStation_Alpha#Advanced_SubStation_Alpha=
+  TimedTextMarkupLang: 'TTML', // https://wikipedia.org/wiki/Timed_Text_Markup_Language
+  WebVTT: 'VTT', // https://wikipedia.org/wiki/WebVTT
+  // MPEG-DASH box-encapsulated subtitle formats
+  fTTML: 'STPP', // https://www.w3.org/TR/2018/REC-ttml-imsc1.0.1-20180424
+  fVTT: 'WVTT', // https://www.w3.org/TR/webvtt1
+};
+
+const parseSubtitleCodecFromMime = (mime) => {
+  const target = mime.toLowerCase().trim().split('.')[0];
+  switch (target) {
+    case 'srt':
+      return SUBTITLE_CODECS.SubRip;
+    case 'ssa':
+      return SUBTITLE_CODECS.SubStationAlpha;
+    case 'ass':
+      return SUBTITLE_CODECS.SubStationAlphav4;
+    case 'ttml':
+      return SUBTITLE_CODECS.TimedTextMarkupLang;
+    case 'vtt':
+      return SUBTITLE_CODECS.WebVTT;
+    case 'stpp':
+      return SUBTITLE_CODECS.fTTML;
+    case 'wvtt':
+      return SUBTITLE_CODECS.fVTT;
+    default:
+      throw new Error(`The MIME ${mime} is not supported as subtitle codec`);
+  }
+};
+
+const parseSubtitleCodec = (codecs) => {
+  const mimes = parseMimes(codecs);
+  for (const mime of mimes) {
+    try {
+      return parseSubtitleCodecFromMime(mime);
+    } catch (e) {
+      continue;
+    }
+  }
+  throw new Error(`No MIME types matched any supported Subtitle Codecs in ${codecs}`);
+};
+
+const checkIsClosedCaption = (roles = []) => {
+  for (const role of roles) {
+    const isClosedCaption =
+      role.attributes.schemeIdUri === 'urn:mpeg:dash:role:2011' &&
+      role.attributes.value === 'caption';
+    if (isClosedCaption) return true;
+  }
+  return false;
+};
+
+const checkIsSdh = (accessibilities = []) => {
+  for (const accessibility of accessibilities) {
+    const { schemeIdUri, value } = accessibility.attributes;
+    const isSdh = schemeIdUri === 'urn:tva:metadata:cs:AudioPurposeCS:2007' && value === '2';
+    if (isSdh) return true;
+  }
+  return false;
+};
+
+const checkIsForced = (roles = []) => {
+  for (const role of roles) {
+    const isForced =
+      role.attributes.schemeIdUri === 'urn:mpeg:dash:role:2011' &&
+      (role.attributes.value === 'forced-subtitle' || role.attributes.value === 'forced_subtitle');
+    if (isForced) return true;
+  }
+  return false;
+};
+
+const createSubtitleTrack = ({
+  id,
+  label,
+  bitrate,
+  duration,
+  type,
+  codec,
+  isClosedCaption,
+  isSdh,
+  isForced,
+  language,
+  segments,
+}) => {
+  const parsedBitrate = parseBitrate(Number(bitrate));
+  const size = duration ? parseSize(Number(bitrate), Number(duration)) : undefined;
+  return {
+    id,
+    label,
+    bitrate: parsedBitrate,
+    size,
+    type,
+    codec,
+    isClosedCaption,
+    isSdh,
+    isForced,
+    segments,
+    language,
+    toString() {
+      return ['SUBTITLE', `[${codec}]`, language].join(' | ');
+    },
+  };
+};
+
+module.exports = {
+  parseSubtitleCodec,
+  checkIsClosedCaption,
+  checkIsSdh,
+  checkIsForced,
+  createSubtitleTrack,
+};

package/lib/track.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { getWidth, getBestTrack } = require('./util');
+
+const parseMimes = (codecs) =>
+  codecs
+    .toLowerCase()
+    .split(',')
+    .map((codec) => codec.trim().split('.')[0]);
+
+const createResolutionFilter = (videos) => {
+  return ({ width, height }) => {
+    return videos.filter(
+      (track) => (!width || track.width === width) && (!height || track.height === height)
+    );
+  };
+};
+
+const createVideoQualityFilter = (videos) => {
+  return (quality) => {
+    if (!quality) return [getBestTrack(videos)];
+    const trackQuality = String(quality).includes('p') ? quality : `${quality}p`;
+    const results = videos.filter((track) => track.quality === trackQuality);
+    return results.length ? results : [getBestTrack(videos)];
+  };
+};
+
+const createAudioLanguageFilter = (audios) => {
+  return (languages = [], maxTracksPerLanguage) => {
+    if (!languages.length) {
+      for (const audio of audios) {
+        const alreadyAdded = languages.includes(audio.language);
+        if (!alreadyAdded) languages.push(audio.language);
+      }
+    }
+    const results = [];
+    for (const language of languages) {
+      const tracks = audios.filter((track) => track.language?.startsWith(language));
+      if (tracks.length > maxTracksPerLanguage) {
+        results.push(...tracks.slice(0, maxTracksPerLanguage));
+      } else {
+        results.push(...tracks);
+      }
+    }
+    return results;
+  };
+};
+
+const createSubtitleLanguageFilter = (subtitles) => {
+  return (languages) => {
+    if (!languages.length) return subtitles;
+    return subtitles.filter((track) =>
+      languages.some(
+        (language) => track.language?.startsWith(language) || track.label?.startsWith(language)
+      )
+    );
+  };
+};
+
+module.exports = {
+  parseMimes,
+  createResolutionFilter,
+  createVideoQualityFilter,
+  createAudioLanguageFilter,
+  createSubtitleLanguageFilter,
+};

package/lib/util.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const formatBytes = (bytes, sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']) => {
+  if (bytes == 0) return `0 ${sizes[0]}`;
+  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
+  if (i == 0) return bytes + ' ' + sizes[i];
+  return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + sizes[i];
+};
+
+const parseSize = (bandwidth, duration) => ({
+  b: bandwidth * duration,
+  kb: (bandwidth / 1000) * duration,
+  mb: (bandwidth / 8e6) * duration,
+  gb: (bandwidth / 8e9) * duration,
+  toString() {
+    return formatBytes(bandwidth * duration);
+  },
+});
+
+const parseBitrate = (bandwidth) => ({
+  bps: bandwidth,
+  kbps: bandwidth / 1000,
+  mbps: bandwidth / 8e6,
+  gbps: bandwidth / 8e9,
+  toString() {
+    return formatBytes(bandwidth, ['bps', 'Kbps', 'Mbps', 'Gbps']);
+  },
+});
+
+const qualities = [
+  { width: 7680, height: 4320 },
+  { width: 3840, height: 2160 },
+  { width: 2560, height: 1440 },
+  { width: 1920, height: 1080 },
+  { width: 1280, height: 720 },
+  { width: 854, height: 480 },
+  { width: 640, height: 360 },
+  { width: 426, height: 240 },
+  { width: 256, height: 144 },
+];
+const getWidth = (height) => qualities.find((q) => q.height === height)?.width;
+const getHeight = (width) => qualities.find((q) => q.width === width)?.height;
+const getQualityLabel = (resolution) => `${getHeight(resolution.width) || resolution.height}p`;
+
+const getBestTrack = (tracks) => {
+  const maxBitrate = Math.max(...tracks.map((track) => track.bitrate.bps));
+  return tracks.find((track) => track.bitrate.bps === maxBitrate);
+};
+
+const parseDuration = (str) => {
+  const SECONDS_IN_YEAR = 365 * 24 * 60 * 60;
+  const SECONDS_IN_MONTH = 30 * 24 * 60 * 60;
+  const SECONDS_IN_DAY = 24 * 60 * 60;
+  const SECONDS_IN_HOUR = 60 * 60;
+  const SECONDS_IN_MIN = 60;
+
+  // P10Y10M10DT10H10M10.1S
+  const durationRegex =
+    /P(?:(\d*)Y)?(?:(\d*)M)?(?:(\d*)D)?(?:T(?:(\d*)H)?(?:(\d*)M)?(?:([\d.]*)S)?)?/;
+  const match = durationRegex.exec(str);
+
+  if (!match) {
+    return 0;
+  }
+
+  const [year, month, day, hour, minute, second] = match.slice(1);
+
+  return (
+    parseFloat(year || 0) * SECONDS_IN_YEAR +
+    parseFloat(month || 0) * SECONDS_IN_MONTH +
+    parseFloat(day || 0) * SECONDS_IN_DAY +
+    parseFloat(hour || 0) * SECONDS_IN_HOUR +
+    parseFloat(minute || 0) * SECONDS_IN_MIN +
+    parseFloat(second || 0)
+  );
+};
+
+const isLanguageTagValid = (value) => {
+  try {
+    Intl.getCanonicalLocales(value);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+
+module.exports = {
+  parseSize,
+  parseBitrate,
+  getWidth,
+  getHeight,
+  getQualityLabel,
+  getBestTrack,
+  parseDuration,
+  isLanguageTagValid,
+};

package/lib/video.js

@@ -0,0 +1,158 @@
+const { parseBitrate, getQualityLabel, parseSize } = require('./util');
+
+const VIDEO_CODECS = {
+  avc: 'H.264',
+  hevc: 'H.265',
+  vc1: 'VC-1',
+  vp8: 'VP8',
+  vp9: 'VP9',
+  av1: 'AV1',
+};
+
+const DYNAMIC_RANGE = {
+  sdr: 'SDR', // Standart Dynamic Range
+  hlg: 'HLG', // Hybrid log-gamma (HDR)
+  hdr10: 'HDR10',
+  hdr10p: 'HDR10+',
+  dv: 'DV', // Dolby Vision
+};
+
+const PRIMARIES = {
+  Unspecified: 0,
+  BT_709: 1,
+  BT_601_625: 5,
+  BT_601_525: 6,
+  BT_2020_and_2100: 9,
+  SMPTE_ST_2113_and_EG_4321: 12, // P3D65
+};
+
+const TRANSFER = {
+  Unspecified: 0,
+  BT_709: 1,
+  BT_601: 6,
+  BT_2020: 14,
+  BT_2100: 15,
+  BT_2100_PQ: 16,
+  BT_2100_HLG: 18,
+};
+
+const MATRIX = {
+  RGB: 0,
+  YCbCr_BT_709: 1,
+  YCbCr_BT_601_625: 5,
+  YCbCr_BT_601_525: 6,
+  YCbCr_BT_2020_and_2100: 9, // YCbCr BT.2100 shares the same CP
+  ICtCp_BT_2100: 14,
+};
+
+const parseVideoCodecFromMime = (mime) => {
+  const target = mime.toLowerCase().trim().split('.')[0];
+  const avc = ['avc1', 'avc2', 'avc3', 'dva1', 'dvav'];
+  const hevc = ['hev1', 'hev2', 'hev3', 'hvc1', 'hvc2', 'hvc3', 'dvh1', 'dvhe', 'lhv1', 'lhe1'];
+  const vc1 = ['vc-1'];
+  const vp8 = ['vp08', 'vp8'];
+  const vp9 = ['vp09', 'vp9'];
+  const av1 = ['av01'];
+  if (avc.includes(target)) return VIDEO_CODECS.avc;
+  if (hevc.includes(target)) return VIDEO_CODECS.hevc;
+  if (vc1.includes(target)) return VIDEO_CODECS.hevc;
+  if (vp8.includes(target)) return VIDEO_CODECS.vp8;
+  if (vp9.includes(target)) return VIDEO_CODECS.vp9;
+  if (av1.includes(target)) return VIDEO_CODECS.av1;
+  throw new Error(`The MIME ${mime} is not supported as video codec`);
+};
+
+const parseDynamicRangeFromCicp = (primaries, transfer, matrix) => {
+  // While not part of any standard, it is typically used as a PAL variant of Transfer.BT_601=6.
+  // i.e. where Transfer 6 would be for BT.601-NTSC and Transfer 5 would be for BT.601-PAL.
+  // The codebase is currently agnostic to either, so a manual conversion to 6 is done.
+  if (transfer == 5) transfer = TRANSFER.BT_601;
+
+  if (
+    primaries == PRIMARIES.Unspecified &&
+    transfer == TRANSFER.Unspecified &&
+    matrix == MATRIX.RGB
+  )
+    return DYNAMIC_RANGE.sdr;
+  else if ([PRIMARIES.BT_601_625, PRIMARIES.BT_601_525].includes(primaries))
+    return DYNAMIC_RANGE.sdr;
+  else if (TRANSFER.BT_2100_PQ === transfer) return DYNAMIC_RANGE.hdr10;
+  else if (TRANSFER.BT_2100_HLG === transfer) return DYNAMIC_RANGE.hlg;
+  else return DYNAMIC_RANGE.sdr;
+};
+
+const createVideoTrack = ({
+  id,
+  label,
+  type,
+  codec,
+  dynamicRange,
+  contentProtection,
+  bitrate,
+  duration,
+  width,
+  height,
+  fps,
+  language,
+  segments,
+}) => {
+  const parsedBitrate = parseBitrate(Number(bitrate));
+  const parsedWidth = Number(width);
+  const parsedHeight = Number(height);
+  const size = duration ? parseSize(Number(bitrate), Number(duration)) : undefined;
+  return {
+    id,
+    label,
+    type,
+    codec,
+    bitrate: parsedBitrate,
+    size,
+    protection: contentProtection,
+    segments,
+    dynamicRange,
+    language,
+    width: parsedWidth,
+    height: parsedHeight,
+    fps: Number(fps),
+    quality: getQualityLabel({ width: parsedWidth, height: parsedHeight }),
+    toString() {
+      return [
+        'VIDEO',
+        `[${codec}, ${dynamicRange}]`,
+        language,
+        `${width}x${height} @ ${parsedBitrate.kbps} kb/s, ${fps} FPS`,
+      ].join(' | ');
+    },
+  };
+};
+
+const parseVideoCodec = (codecs) => {
+  for (const codec of codecs.toLowerCase().split(',')) {
+    const mime = codec.trim().split('.')[0];
+    try {
+      return parseVideoCodecFromMime(mime);
+    } catch (e) {
+      continue;
+    }
+  }
+  throw new Error(`No MIME types matched any supported Video Codecs in ${codecs}`);
+};
+
+const parseDynamicRange = (codecs, supplementalProps = [], essentialProps = []) => {
+  const dv = ['dva1', 'dvav', 'dvhe', 'dvh1'];
+  if (dv.some((value) => codecs.startsWith(value))) return DYNAMIC_RANGE.dv;
+  const primariesScheme = 'urn:mpeg:mpegB:cicp:ColourPrimaries';
+  const transferScheme = 'urn:mpeg:mpegB:cicp:TransferCharacteristics';
+  const matrixScheme = 'urn:mpeg:mpegB:cicp:MatrixCoefficients';
+  const allProps = [...essentialProps, ...supplementalProps];
+  const getValues = (scheme) =>
+    allProps
+      .filter((prop) => prop.attributes.schemeIdUri === scheme)
+      .map((prop) => parseInt(prop.attributes.value));
+  const primaries = getValues(primariesScheme).reduce((acc, current) => acc + current, 0);
+  const transfer = getValues(transferScheme).reduce((acc, current) => acc + current, 0);
+  const matrix = getValues(matrixScheme).reduce((acc, current) => acc + current, 0);
+  return parseDynamicRangeFromCicp(primaries, transfer, matrix);
+};
+
+module.exports = { parseVideoCodec, parseDynamicRange, createVideoTrack, VIDEO_CODECS };