dasha 3.1.5 → 4.0.0-alpha.1

package/lib/hls.js

@@ -1,234 +0,0 @@
-'use strict';
-
-const { dirname, basename } = require('node:path');
-const m3u8Parser = require('m3u8-parser');
-const { parseBitrate, getQualityLabel } = require('./util');
-const {
-  createResolutionFilter,
-  createVideoQualityFilter,
-  createAudioLanguageFilter,
-  createSubtitleLanguageFilter,
-  createVideoCodecFilter,
-  createAudioCodecFilter,
-  createAudioChannelsFilter,
-} = require('./track');
-const { createAudioTrack } = require('./audio');
-const { createVideoTrack } = require('./video');
-
-const parseM3u8 = (manifestString) => {
-  const parser = new m3u8Parser.Parser();
-  parser.push(manifestString);
-  parser.end();
-  return parser.manifest;
-};
-
-const fetchPlaylist = async (url) => {
-  const response = await fetch(url);
-  if (!response.ok)
-    throw new Error(`Failed to fetch playlist (${response.status}): ${url}`);
-  const text = await response.text();
-  return parseM3u8(text);
-};
-
-const parseUrl = (playlistUri, manifestUri) => {
-  let value = playlistUri;
-  if (!value.startsWith('https://'))
-    value =
-      new URL(value, manifestUri).toString() + new URL(manifestUri).search;
-  return value;
-};
-
-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,
-          id: entity.uri.replace('/', ''),
-          type: groupId,
-          label,
-          language: entity.language,
-          url,
-          default: entity.default,
-        });
-    }
-  }
-  return results;
-};
-
-const getAudioPlaylists = (m3u8, manifestUri) => {
-  if (!m3u8.mediaGroups) return [];
-  return parseMediaGroup(m3u8.mediaGroups.AUDIO, manifestUri);
-};
-
-const getSubtitlePlaylists = (m3u8, manifestUri) => {
-  if (!m3u8.mediaGroups) return [];
-  return parseMediaGroup(m3u8.mediaGroups.SUBTITLES, manifestUri);
-};
-
-const getVideoPlaylists = (m3u8, manifestUri) => {
-  if (!m3u8.playlists) return [];
-  return m3u8.playlists.map((data) => {
-    const bandwidth = data.attributes?.BANDWIDTH;
-    const url = data.resolvedUri || parseUrl(data.uri, manifestUri);
-    const track = {
-      id: data.uri.replace('/', ''),
-      bitrate: parseBitrate(bandwidth),
-      url,
-    };
-    track.type = 'video';
-    if (data.attributes.RESOLUTION) {
-      track.resolution = data.attributes.RESOLUTION;
-      track.quality = getQualityLabel(track.resolution);
-    }
-    if (data.attributes['VIDEO-RANGE'])
-      track.dynamicRange = data.attributes['VIDEO-RANGE'];
-    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 = [], track) => {
-  const mapSegment = (item) => {
-    let url = item.resolvedUri || item.uri;
-    if (!url.startsWith('https://') && track.url) {
-      const baseUrl = dirname(track.url) + '/';
-      url = new URL(url, baseUrl).toString();
-    }
-    return {
-      url,
-      duration: item.duration,
-      number: item.number,
-      presentationTime: item.presentationTime,
-    };
-  };
-  const segments = data.map(mapSegment);
-  const init = data[0].map;
-  if (data.length && (init?.resolvedUri || init?.uri)) {
-    const url = init?.resolvedUri || parseUrl(init.uri, track.url);
-    segments.unshift({
-      url: url,
-      init: true,
-      duration: 0,
-      number: 0,
-      presentationTime: 0,
-    });
-  }
-  return segments;
-};
-
-const parseSegments = (playlist, track) => {
-  track.segments = segmentsDto(playlist.segments, track);
-  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 widevine = playlist.contentProtection['com.widevine.alpha'];
-    if (widevine) {
-      track.protection.widevine = {
-        pssh: widevine.pssh,
-        uri: widevine.attributes.schemeIdUri,
-        keyId: widevine.attributes.keyId,
-      };
-    }
-  }
-};
-
-const fetchTrackSegments = (tracks) => {
-  return Promise.all(
-    tracks.map(async (track) => {
-      const playlist = await fetchPlaylist(track.url);
-      parseSegments(playlist, track);
-    }),
-  );
-};
-
-const parseManifest = async (manifestString, manifestUri) => {
-  const m3u8 = parseM3u8(manifestString);
-  const videos = getVideoPlaylists(m3u8, manifestUri);
-  const audios = getAudioPlaylists(m3u8, manifestUri);
-  const subtitles = getSubtitlePlaylists(m3u8, manifestUri);
-
-  if (!m3u8.playlists && m3u8.segments) {
-    // TODO: Handle audio-only manifests
-    const { pathname } = new URL(manifestUri);
-    const isAudio =
-      pathname.includes('.m4a') ||
-      pathname.includes('.mp3') ||
-      pathname.includes('.opus');
-    if (isAudio) {
-      const track = createAudioTrack({
-        id: 'audio' + basename(pathname),
-        label: 'audio',
-        type: 'audio',
-        codec: '',
-        channels: 2,
-        jointObjectCoding: '',
-        isDescriptive: false,
-        bitrate: NaN,
-        duration: NaN,
-        language: '',
-      });
-      parseSegments(m3u8, track);
-      audios.push(track);
-    } else {
-      const track = createVideoTrack({
-        id: 'video' + basename(pathname),
-        label: 'video',
-        type: 'video',
-        codec: '',
-        dynamicRange: '',
-        contentProtection: '',
-        bitrate: NaN,
-        duration: NaN,
-        width: NaN,
-        height: NaN,
-        fps: NaN,
-        language: '',
-      });
-      parseSegments(m3u8, track);
-      videos.push(track);
-    }
-  } else {
-    await Promise.all([
-      fetchTrackSegments(videos),
-      fetchTrackSegments(audios),
-      fetchTrackSegments(subtitles),
-    ]);
-  }
-
-  const manifest = {
-    tracks: {
-      all: videos.concat(audios).concat(subtitles),
-      videos,
-      audios,
-      subtitles,
-      withResolution: createResolutionFilter(videos),
-      withVideoCodecs: createVideoCodecFilter(videos),
-      withVideoQuality: createVideoQualityFilter(videos),
-      withAudioCodecs: createAudioCodecFilter(audios),
-      withAudioLanguages: createAudioLanguageFilter(audios),
-      withAudioChannels: createAudioChannelsFilter(audios),
-      withSubtitleLanguages: createSubtitleLanguageFilter(subtitles),
-    },
-  };
-
-  return manifest;
-};
-
-module.exports = { parseManifest };

package/lib/subtitle.js

@@ -1,137 +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 tryParseSubtitleCodec = (codecs) => {
-  try {
-    return parseSubtitleCodec(codecs);
-  } catch (e) {
-    return null;
-  }
-};
-
-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 = {
-  SUBTITLE_CODECS,
-  parseSubtitleCodec,
-  tryParseSubtitleCodec,
-  checkIsClosedCaption,
-  checkIsSdh,
-  checkIsForced,
-  createSubtitleTrack,
-};

package/lib/track.js

@@ -1,127 +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) {
-      const audiosWithLanguage = audios.filter((track) => track.language);
-      if (audiosWithLanguage.length) {
-        for (const audio of audiosWithLanguage) {
-          const alreadyAdded = languages.includes(audio.language);
-          if (!alreadyAdded) languages.push(audio.language);
-        }
-      } else {
-        audios.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
-        return audios.slice(0, maxTracksPerLanguage);
-      }
-    }
-    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}:${track.label}`)),
-    ];
-    for (const language of filteredLanguages) {
-      const tracks = filtered
-        .filter((track) => `${track.language}:${track.label}` === 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,98 +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 (e) {
-    return;
-  }
-};
-
-module.exports = {
-  parseSize,
-  parseBitrate,
-  getWidth,
-  getHeight,
-  getQualityLabel,
-  getBestTrack,
-  parseDuration,
-  isLanguageTagValid,
-};