dasha 3.0.5 → 3.1.0

package/lib/subtitle.js

@@ -1,120 +0,0 @@
-'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':
-    case 'x-subrip':
-      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

@@ -1,107 +0,0 @@
-'use strict';
-
-const { 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 createCodecFilter = (tracks) => {
-  return (codecs) => {
-    if (!codecs?.length) return tracks;
-    const results = tracks.filter((track) => codecs.includes(track.codec));
-    results.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-    return results;
-  };
-};
-
-const createVideoCodecFilter = (videos) => createCodecFilter(videos);
-
-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);
-    results.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-    return results.length ? results : [getBestTrack(videos)];
-  };
-};
-
-const createAudioCodecFilter = (audios) => createCodecFilter(audios);
-
-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 filtered = [];
-    for (const language of languages) {
-      const tracks = audios.filter((track) => track.language?.startsWith(language));
-      filtered.push(...tracks);
-    }
-    const results = [];
-    const filteredLanguages = [...new Set(filtered.map((track) => track.language))];
-    for (const language of filteredLanguages) {
-      const tracks = filtered
-        .filter((track) => track.language === language)
-        .slice(0, maxTracksPerLanguage);
-      results.push(...tracks);
-    }
-    return results;
-  };
-};
-
-const createAudioChannelsFilter = (audios) => {
-  return (channels) => {
-    if (!channels) return audios;
-    const value = typeof channels === 'string' ? parseFloat(channels) : channels;
-    return audios.filter((track) => track.channels === value);
-  };
-};
-
-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)
-      )
-    );
-  };
-};
-
-const filterByResolution = (tracks, resolution) => createResolutionFilter(tracks)(resolution);
-const filterByQuality = (tracks, quality) => createVideoQualityFilter(tracks)(quality);
-const filterByCodecs = (tracks, codecs) => createCodecFilter(tracks)(codecs);
-const filterByLanguages = (tracks, languages, maxTracksPerLanguage) =>
-  createAudioLanguageFilter(tracks)(languages, maxTracksPerLanguage);
-const filterByChannels = (tracks, channels) => createAudioChannelsFilter(tracks)(channels);
-
-module.exports = {
-  parseMimes,
-  createResolutionFilter,
-  createVideoCodecFilter,
-  createVideoQualityFilter,
-  createAudioCodecFilter,
-  createAudioLanguageFilter,
-  createAudioChannelsFilter,
-  createSubtitleLanguageFilter,
-  filterByResolution,
-  filterByQuality,
-  filterByCodecs,
-  filterByLanguages,
-  filterByChannels,
-};

package/lib/util.js

@@ -1,97 +0,0 @@
-'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: 1024, height: 576 },
-  { 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

@@ -1,158 +0,0 @@
-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 };