dasha 3.1.5 → 4.0.0-alpha.2

package/lib/video.js

@@ -1,200 +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 tryParseVideoCodec = (codecs) => {
-  try {
-    return parseVideoCodec(codecs);
-  } catch (e) {
-    return null;
-  }
-};
-
-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,
-  tryParseVideoCodec,
-  parseDynamicRange,
-  createVideoTrack,
-  VIDEO_CODECS,
-};

package/lib/xml.js

@@ -1,310 +0,0 @@
-function parse(text, options = {}) {
-  var pos = options.pos || 0;
-  var keepComments = !!options.keepComments;
-  var keepWhitespace = !!options.keepWhitespace;
-
-  var openBracket = '<';
-  var openBracketCC = '<'.charCodeAt(0);
-  var closeBracket = '>';
-  var closeBracketCC = '>'.charCodeAt(0);
-  var minusCC = '-'.charCodeAt(0);
-  var slashCC = '/'.charCodeAt(0);
-  var exclamationCC = '!'.charCodeAt(0);
-  var singleQuoteCC = "'".charCodeAt(0);
-  var doubleQuoteCC = '"'.charCodeAt(0);
-  var openCornerBracketCC = '['.charCodeAt(0);
-  var closeCornerBracketCC = ']'.charCodeAt(0);
-
-  /**
-   * parsing a list of entries
-   */
-  function parseChildren(tagName) {
-    var children = [];
-    while (text[pos]) {
-      if (text.charCodeAt(pos) == openBracketCC) {
-        if (text.charCodeAt(pos + 1) === slashCC) {
-          var closeStart = pos + 2;
-          pos = text.indexOf(closeBracket, pos);
-
-          var closeTag = text.substring(closeStart, pos);
-          if (closeTag.indexOf(tagName) == -1) {
-            const parsedText = text.substring(0, pos).split('\n');
-            throw new Error(
-              'Unexpected close tag\nLine: ' +
-                (parsedText.length - 1) +
-                '\nColumn: ' +
-                (parsedText[parsedText.length - 1].length + 1) +
-                '\nChar: ' +
-                text[pos],
-            );
-          }
-
-          if (pos + 1) pos += 1;
-
-          return children;
-        } else if (text.charCodeAt(pos + 1) === exclamationCC) {
-          if (text.charCodeAt(pos + 2) == minusCC) {
-            //comment support
-            const startCommentPos = pos;
-            while (
-              pos !== -1 &&
-              !(
-                text.charCodeAt(pos) === closeBracketCC &&
-                text.charCodeAt(pos - 1) == minusCC &&
-                text.charCodeAt(pos - 2) == minusCC &&
-                pos != -1
-              )
-            ) {
-              pos = text.indexOf(closeBracket, pos + 1);
-            }
-            if (pos === -1) {
-              pos = text.length;
-            }
-            if (keepComments) {
-              children.push(text.substring(startCommentPos, pos + 1));
-            }
-          } else if (
-            text.charCodeAt(pos + 2) === openCornerBracketCC &&
-            text.charCodeAt(pos + 8) === openCornerBracketCC &&
-            text.substr(pos + 3, 5).toLowerCase() === 'cdata'
-          ) {
-            // cdata
-            var cdataEndIndex = text.indexOf(']]>', pos);
-            if (cdataEndIndex == -1) {
-              children.push(text.substr(pos + 9));
-              pos = text.length;
-            } else {
-              children.push(text.substring(pos + 9, cdataEndIndex));
-              pos = cdataEndIndex + 3;
-            }
-            continue;
-          } else {
-            // doctypesupport
-            const startDoctype = pos + 1;
-            pos += 2;
-            var encapsuled = false;
-            while (
-              (text.charCodeAt(pos) !== closeBracketCC ||
-                encapsuled === true) &&
-              text[pos]
-            ) {
-              if (text.charCodeAt(pos) === openCornerBracketCC) {
-                encapsuled = true;
-              } else if (
-                encapsuled === true &&
-                text.charCodeAt(pos) === closeCornerBracketCC
-              ) {
-                encapsuled = false;
-              }
-              pos++;
-            }
-            children.push(text.substring(startDoctype, pos));
-          }
-          pos++;
-          continue;
-        }
-        var node = parseNode();
-        children.push(node);
-        if (node.tagName[0] === '?') {
-          children.push(...node.children);
-          node.children = [];
-        }
-      } else {
-        const parsedText = parseText();
-        if (keepWhitespace) {
-          if (parsedText.length > 0) {
-            children.push(parsedText);
-          }
-        } else {
-          var trimmed = parsedText.trim();
-          if (trimmed.length > 0) {
-            children.push(trimmed);
-          }
-        }
-        pos++;
-      }
-    }
-    return children;
-  }
-
-  /**
-   *    returns the text outside of texts until the first '<'
-   */
-  function parseText() {
-    var start = pos;
-    pos = text.indexOf(openBracket, pos) - 1;
-    if (pos === -2) pos = text.length;
-    return text.slice(start, pos + 1);
-  }
-  /**
-   *    returns text until the first nonAlphabetic letter
-   */
-  var nameSpacer = '\r\n\t>/= ';
-
-  function parseName() {
-    var start = pos;
-    while (nameSpacer.indexOf(text[pos]) === -1 && text[pos]) {
-      pos++;
-    }
-    return text.slice(start, pos);
-  }
-  /**
-   *    is parsing a node, including tagName, Attributes and its children,
-   * to parse children it uses the parseChildren again, that makes the parsing recursive
-   */
-  var NoChildNodes = options.noChildNodes || [
-    'img',
-    'br',
-    'input',
-    'meta',
-    'link',
-    'hr',
-  ];
-
-  function parseNode() {
-    pos++;
-    const tagName = parseName();
-    const attributes = {};
-    let children = [];
-
-    // parsing attributes
-    while (text.charCodeAt(pos) !== closeBracketCC && text[pos]) {
-      var c = text.charCodeAt(pos);
-      if ((c > 64 && c < 91) || (c > 96 && c < 123)) {
-        //if('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(S[pos])!==-1 ){
-        var name = parseName();
-        // search beginning of the string
-        var code = text.charCodeAt(pos);
-        while (
-          code &&
-          code !== singleQuoteCC &&
-          code !== doubleQuoteCC &&
-          !((code > 64 && code < 91) || (code > 96 && code < 123)) &&
-          code !== closeBracketCC
-        ) {
-          pos++;
-          code = text.charCodeAt(pos);
-        }
-        if (code === singleQuoteCC || code === doubleQuoteCC) {
-          var value = parseString();
-          if (pos === -1) {
-            return {
-              tagName,
-              attributes,
-              children,
-            };
-          }
-        } else {
-          value = null;
-          pos--;
-        }
-        attributes[name] = value;
-      }
-      pos++;
-    }
-    // optional parsing of children
-    if (text.charCodeAt(pos - 1) !== slashCC) {
-      if (tagName == 'script') {
-        const start = pos + 1;
-        pos = text.indexOf('</script>', pos);
-        children = [text.slice(start, pos)];
-        pos += 9;
-      } else if (tagName == 'style') {
-        const start = pos + 1;
-        pos = text.indexOf('</style>', pos);
-        children = [text.slice(start, pos)];
-        pos += 8;
-      } else if (NoChildNodes.indexOf(tagName) === -1) {
-        pos++;
-        children = parseChildren(tagName);
-      } else {
-        pos++;
-      }
-    } else {
-      pos++;
-    }
-    return {
-      tagName,
-      attributes,
-      children,
-    };
-  }
-
-  /**
-   *    is parsing a string, that starts with a char and with the same usually  ' or "
-   */
-
-  function parseString() {
-    var startChar = text[pos];
-    var startpos = pos + 1;
-    pos = text.indexOf(startChar, startpos);
-    return text.slice(startpos, pos);
-  }
-
-  /**
-   *
-   */
-  function findElements() {
-    var r = new RegExp(
-      '\\s' + options.attrName + '\\s*=[\'"]' + options.attrValue + '[\'"]',
-    ).exec(text);
-    if (r) {
-      return r.index;
-    } else {
-      return -1;
-    }
-  }
-
-  let out = null;
-  if (options.attrValue !== undefined) {
-    options.attrName = options.attrName || 'id';
-    out = [];
-
-    while ((pos = findElements()) !== -1) {
-      pos = text.lastIndexOf('<', pos);
-      if (pos !== -1) {
-        out.push(parseNode());
-      }
-      text = text.substr(pos);
-      pos = 0;
-    }
-  } else if (options.parseNode) {
-    out = parseNode();
-  } else {
-    out = parseChildren('');
-  }
-
-  if (options.filter) {
-    out = filter(out, options.filter);
-  }
-
-  if (options.setPos) {
-    out.pos = pos;
-  }
-
-  return out;
-}
-
-/**
- * behaves the same way as Array.filter, if the filter method return true, the element is in the resultList
- * @params children{Array} the children of a node
- * @param f{function} the filter method
- */
-function filter(children, f, dept = 0, path = '') {
-  var out = [];
-  children.forEach(function (child, i) {
-    if (typeof child === 'object' && f(child, i, dept, path)) out.push(child);
-    if (child.children) {
-      var kids = filter(
-        child.children,
-        f,
-        dept + 1,
-        (path ? path + '.' : '') + i + '.' + child.tagName,
-      );
-      out = out.concat(kids);
-    }
-  });
-  return out;
-}
-
-module.exports = { parse, filter };

package/types/dasha.d.ts

@@ -1,161 +0,0 @@
-export function parse(
-  text: string,
-  url?: string,
-  fallbackLanguage?: string,
-): Promise<Manifest>;
-
-export interface Manifest {
-  duration?: number;
-  tracks: {
-    all: (VideoTrack | AudioTrack | SubtitleTrack)[];
-    videos: VideoTrack[];
-    audios: AudioTrack[];
-    subtitles: SubtitleTrack[];
-    withResolution(resolution: {
-      width?: string;
-      height?: string;
-    }): VideoTrack[];
-    withVideoCodecs(codecs: VideoCodec[]): VideoTrack[];
-    withVideoQuality(quality: number | string): VideoTrack[];
-    withAudioCodecs(codecs: AudioCodec[]): AudioTrack[];
-    withAudioLanguages(
-      languages: string[],
-      maxTracksPerLanguage?: number,
-    ): AudioTrack[];
-    withSubtitleLanguages(languages: string[]): SubtitleTrack[];
-  };
-}
-
-export function filterByResolution(resolution: {
-  width?: string;
-  height?: string;
-}): VideoTrack[];
-export function filterByCodecs(
-  tracks: VideoTrack[],
-  codecs: VideoCodec[],
-): VideoTrack[];
-export function filterByCodecs(
-  tracks: AudioTrack[],
-  codecs: AudioCodec[],
-): AudioTrack[];
-export function filterByQuality(
-  tracks: VideoTrack[],
-  quality: number | string,
-): VideoTrack[];
-export function filterByLanguages(
-  tracks: AudioTrack[],
-  languages: string[],
-  maxTracksPerLanguage?: number,
-): AudioTrack[];
-export function filterByChannels(
-  tracks: AudioTrack[],
-  channels: number | string,
-): AudioTrack[];
-
-export interface Track {
-  id: string;
-  type: 'video' | 'audio' | 'text';
-  segments: Segment[];
-  size?: Size;
-  label?: string;
-  protection?: TrackProtection;
-  toString: () => string;
-}
-
-export interface Bitrate {
-  bps: number;
-  kbps: number;
-  mbps: number;
-  gbps: number;
-  toString: () => string;
-}
-
-export interface Size {
-  b: number;
-  kb: number;
-  mb: number;
-  gb: number;
-  toString: () => string;
-}
-
-export interface Segment {
-  url: string;
-  range?: string;
-  init?: boolean;
-  duration?: number;
-  number?: number;
-  presentationTime?: number;
-}
-
-export interface TrackProtection {
-  common?: { id: string; value: 'cenc' | 'cbcs'; defaultKeyId?: string };
-  playready?: { id: string; pssh?: string; value?: string };
-  widevine?: { id: string; pssh: string; defaultKeyId?: string };
-  fairplay?: { keyFormat: string; uri: string; method: string };
-}
-
-export type VideoCodec = 'H.264' | 'H.265' | 'VC-1' | 'VP8' | 'VP9' | 'AV1';
-export type DynamicRange = 'SDR' | 'HLG' | 'HDR10' | 'HDR10+' | 'DV';
-
-export interface VideoTrack extends Track {
-  type: 'video';
-  codec: VideoCodec;
-  bitrate: Bitrate;
-  width: number;
-  height: number;
-  quality:
-    | '144p'
-    | '240p'
-    | '360p'
-    | '480p'
-    | '720p'
-    | '1080p'
-    | '2160p'
-    | '4320p'
-    | string;
-  dynamicRange: DynamicRange;
-  fps?: string;
-  language?: string;
-}
-
-export type AudioCodec =
-  | 'AAC'
-  | 'DD'
-  | 'DD+'
-  | 'OPUS'
-  | 'VORB'
-  | 'DTS'
-  | 'ALAC'
-  | 'FLAC';
-
-export interface AudioTrack extends Track {
-  type: 'audio';
-  codec: AudioCodec;
-  bitrate: Bitrate;
-  language: string;
-  channels?: number;
-  jointObjectCoding?: number;
-  isDescriptive?: boolean;
-}
-
-export type SubtitleCodec =
-  | 'SRT' // https://wikipedia.org/wiki/SubRip
-  | 'SSA' // https://wikipedia.org/wiki/SubStation_Alpha
-  | 'ASS' // https://wikipedia.org/wiki/SubStation_Alpha#Advanced_SubStation_Alpha=
-  | 'TTML' // https://wikipedia.org/wiki/Timed_Text_Markup_Language
-  | 'VTT' // https://wikipedia.org/wiki/WebVTT
-  // MPEG-DASH box-encapsulated subtitle formats
-  | 'STPP' // https://www.w3.org/TR/2018/REC-ttml-imsc1.0.1-20180424
-  | 'WVTT'; // https://www.w3.org/TR/webvtt1
-
-export interface SubtitleTrack extends Track {
-  type: 'text';
-  codec: SubtitleCodec;
-  bitrate?: Bitrate;
-  language: string;
-  isClosedCaption?: boolean;
-  isSdh?: boolean;
-  isForced?: boolean;
-}
-
-export type AnyTrack = VideoTrack | AudioTrack | SubtitleTrack;