dasha 3.0.2 → 3.0.4

package/README.md

@@ -6,6 +6,11 @@
 
 Library for parsing MPEG-DASH and HLS manifests. Made with the purpose of obtaining a simplified representation convenient for further downloading of segments.
 
+<div align="left">
+  <span>English</span> •
+  <a href="https://github.com/vitalygashkov/dasha/tree/main/docs/README.ru.md">Pусский</a>
+</div>
+
 ## Install
 
 ```shell
@@ -15,9 +20,17 @@ npm i dasha
 ## Quick start
 
 ```js
+import fs from 'node:fs/promises';
 import { parse } from 'dasha';
 
 const url = 'https://dash.akamaized.net/dash264/TestCases/1a/sony/SNE_DASH_SD_CASE1A_REVISED.mpd';
 const body = await fetch(url).then((res) => res.text());
 const manifest = await parse(body, url);
+
+for (const track of manifest.tracks.all) {
+  for (const segment of track.segments) {
+    const content = await fetch(url).then((res) => res.arrayBuffer());
+    await fs.appendFile(`${track.id}.mp4`, content);
+  }
+}
 ```

package/dasha.js

@@ -2,6 +2,13 @@
 
 const dash = require('./lib/dash');
 const hls = require('./lib/hls');
+const {
+  filterByResolution,
+  filterByQuality,
+  filterByCodecs,
+  filterByLanguages,
+  filterByChannels,
+} = require('./lib/track');
 
 const parse = (text, url, fallbackLanguage) => {
   if (text.includes('<MPD')) return dash.parseManifest(text, url, fallbackLanguage);
@@ -9,4 +16,11 @@ const parse = (text, url, fallbackLanguage) => {
   else throw new Error('Invalid manifest');
 };
 
-module.exports = { parse };
+module.exports = {
+  parse,
+  filterByResolution,
+  filterByQuality,
+  filterByCodecs,
+  filterByLanguages,
+  filterByChannels,
+};

package/lib/dash.js

@@ -21,6 +21,9 @@ const {
   createVideoQualityFilter,
   createAudioLanguageFilter,
   createSubtitleLanguageFilter,
+  createVideoCodecFilter,
+  createAudioCodecFilter,
+  createAudioChannelsFilter,
 } = require('./track');
 
 const appendUtils = (element) => {
@@ -56,16 +59,12 @@ const combineGetters = (representation, adaptationSet) => {
 };
 
 const parseBaseUrl = (manifestUrl, mpd, period, representation) => {
-  let manifestBaseUrl = mpd.getBaseUrl();
-  if (!manifestBaseUrl) manifestBaseUrl = manifestUrl;
-  else if (!manifestBaseUrl.startsWith('https://'))
-    manifestBaseUrl = new URL(manifestBaseUrl, manifestUrl).toString();
-  const periodBaseUrl = new URL(period.getBaseUrl() || '', manifestBaseUrl).toString();
-  const representationBaseUrl = new URL(
-    representation.getBaseUrl() || '',
-    periodBaseUrl
-  ).toString();
-  return representationBaseUrl;
+  let base = mpd.getBaseUrl();
+  if (!base) base = manifestUrl;
+  else if (!base.startsWith('https://')) base = new URL(base, manifestUrl).toString();
+  if (!!period.getBaseUrl() || !!base) base = new URL(period.getBaseUrl() || '', base).toString();
+  const baseUrl = new URL(representation.getBaseUrl() || '', base).toString();
+  return baseUrl;
 };
 
 const parseContentTypes = (representation) => {
@@ -91,7 +90,7 @@ const parseLanguage = (representation, adaptationSet, fallbackLanguage) => {
     options.push(lang);
     if (id) {
       const m = id.match(/\w+_(\w+)=\d+/);
-      if (m) options.push(m.group(1));
+      if (m && m[1]) options.push(m[1]);
     }
   }
   options.push(adaptationSet.get('lang'));
@@ -177,10 +176,14 @@ const parseSegmentsFromTemplate = (
   const startNumber = Number(segmentTemplate.get('startNumber') || 1);
   const segmentTimeline = segmentTemplate.get('SegmentTimeline');
   resolveSegmentTemplateUrls(segmentTemplate, baseUrl, manifestUrl);
-  if (!duration) throw new Error('Duration of the Period was unable to be determined.');
   const segmentDuration = parseFloat(segmentTemplate.get('duration'));
   const segmentTimescale = parseFloat(segmentTemplate.get('timescale') || 1);
-  const segmentsCount = Math.ceil(duration / (segmentDuration / segmentTimescale));
+  // TODO: Support live manifests with type=dynamic
+  const DEFAULT_SEGMENTS_COUNT = 35;
+  // if (!duration) throw new Error('Duration of the Period was unable to be determined.');
+  const segmentsCount = duration
+    ? Math.ceil(duration / (segmentDuration / segmentTimescale))
+    : DEFAULT_SEGMENTS_COUNT;
   const bandwidth = representation.get('bandwidth');
   const id = representation.get('id');
   const segments = [];
@@ -226,12 +229,13 @@ const parseSegmentFromBase = async (segmentBase, baseUrl) => {
   const initialization = segmentBase.get('Initialization');
   let mediaRange = '';
   if (initialization) {
-    const range = initialization.get('range');
-    const headers = range ? { Range: `bytes=${range}` } : undefined;
-    const response = await fetch(baseUrl, headers);
-    const initData = await response.arrayBuffer();
-    const totalSize = response.headers.get('Content-Range').split('/')[-1];
-    if (totalSize) mediaRange = `${initData.byteLength}-${totalSize}`;
+    // const range = initialization.get('range');
+    // const headers = range ? { Range: `bytes=${range}` } : undefined;
+    // const response = await fetch(baseUrl, headers);
+    // const initData = await response.arrayBuffer();
+    // console.log(response.headers);
+    // const totalSize = response.headers.get('Content-Range').split('/')[-1];
+    // if (totalSize) mediaRange = `${initData.byteLength}-${totalSize}`;
   }
   return { url: baseUrl, range: mediaRange };
 };
@@ -402,6 +406,9 @@ const parseManifest = async (text, url, fallbackLanguage) => {
       }
     }
   }
+
+  videos.sort((a, b) => b.bitrate.bps - a.bitrate.bps);
+
   return {
     duration,
     tracks: {
@@ -410,8 +417,11 @@ const parseManifest = async (text, url, fallbackLanguage) => {
       audios,
       subtitles,
       withResolution: createResolutionFilter(videos),
+      withVideoCodecs: createVideoCodecFilter(videos),
       withVideoQuality: createVideoQualityFilter(videos),
+      withAudioCodecs: createAudioCodecFilter(audios),
       withAudioLanguages: createAudioLanguageFilter(audios),
+      withAudioChannels: createAudioChannelsFilter(audios),
       withSubtitleLanguages: createSubtitleLanguageFilter(subtitles),
     },
   };

package/lib/hls.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { dirname, basename } = require('node:path');
 const m3u8Parser = require('m3u8-parser');
 const { parseBitrate, getQualityLabel } = require('./util');
 const {
@@ -7,7 +8,12 @@ const {
   createVideoQualityFilter,
   createAudioLanguageFilter,
   createSubtitleLanguageFilter,
+  createVideoCodecFilter,
+  createAudioCodecFilter,
+  createAudioChannelsFilter,
 } = require('./track');
+const { createAudioTrack } = require('./audio');
+const { createVideoTrack } = require('./video');
 
 const parseM3u8 = (manifestString) => {
   const parser = new m3u8Parser.Parser();
@@ -22,9 +28,9 @@ const fetchPlaylist = async (url) =>
     .then(parseM3u8);
 
 const parseUrl = (playlistUri, manifestUri) => {
-  if (playlistUri.includes('https://')) return playlistUri;
-  const uri = new URL(manifestUri);
-  return uri.origin + playlistUri;
+  let value = playlistUri;
+  if (!value.startsWith('https://')) value = new URL(value, manifestUri).toString();
+  return value;
 };
 
 const urlsSame = (url1, url2) => {
@@ -51,18 +57,22 @@ const parseMediaGroup = (groups, manifestUri) => {
 };
 
 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 bandwidth = data.attributes?.BANDWIDTH;
     const url = data.resolvedUri || parseUrl(data.uri, manifestUri);
     const track = { bitrate: parseBitrate(bandwidth), url };
+    track.type = 'video';
     if (data.attributes.RESOLUTION) {
       track.resolution = data.attributes.RESOLUTION;
       track.quality = getQualityLabel(track.resolution);
@@ -73,13 +83,20 @@ const getVideoPlaylists = (m3u8, manifestUri) => {
   });
 };
 
-const segmentsDto = (data = []) => {
-  const mapSegment = (item) => ({
-    url: item.resolvedUri || item.uri,
-    duration: item.duration,
-    number: item.number,
-    presentationTime: item.presentationTime,
-  });
+const segmentsDto = (data = [], track) => {
+  const mapSegment = (item) => {
+    let url = item.resolvedUri || item.uri;
+    if (!url.startsWith('https://')) {
+      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);
   if (data.length && data[0].map?.resolvedUri)
     segments.unshift({
@@ -92,21 +109,25 @@ const segmentsDto = (data = []) => {
   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 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,
-          };
-      }
+      parseSegments(playlist, track);
     })
   );
 };
@@ -117,11 +138,51 @@ const parseManifest = async (manifestString, manifestUri) => {
   const audios = getAudioPlaylists(m3u8, manifestUri);
   const subtitles = getSubtitlePlaylists(m3u8, manifestUri);
 
-  await Promise.all([
-    fetchTrackSegments(videos),
-    fetchTrackSegments(audios),
-    fetchTrackSegments(subtitles),
-  ]);
+  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: {
@@ -130,8 +191,11 @@ const parseManifest = async (manifestString, manifestUri) => {
       audios,
       subtitles,
       withResolution: createResolutionFilter(videos),
+      withVideoCodecs: createVideoCodecFilter(videos),
       withVideoQuality: createVideoQualityFilter(videos),
+      withAudioCodecs: createAudioCodecFilter(audios),
       withAudioLanguages: createAudioLanguageFilter(audios),
+      withAudioChannels: createAudioChannelsFilter(audios),
       withSubtitleLanguages: createSubtitleLanguageFilter(subtitles),
     },
   };

package/lib/subtitle.js

@@ -18,6 +18,7 @@ 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;

package/lib/track.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getWidth, getBestTrack } = require('./util');
+const { getBestTrack } = require('./util');
 
 const parseMimes = (codecs) =>
   codecs
@@ -16,15 +16,29 @@ const createResolutionFilter = (videos) => {
   };
 };
 
+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) {
@@ -50,6 +64,14 @@ const createAudioLanguageFilter = (audios) => {
   };
 };
 
+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;
@@ -61,10 +83,25 @@ const createSubtitleLanguageFilter = (subtitles) => {
   };
 };
 
+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

@@ -33,6 +33,7 @@ const qualities = [
   { 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 },

package/lib/xml.js

@@ -28,7 +28,7 @@ function parse(text, options = {}) {
 
           var closeTag = text.substring(closeStart, pos);
           if (closeTag.indexOf(tagName) == -1) {
-            var parsedText = text.substring(0, pos).split('\n');
+            const parsedText = text.substring(0, pos).split('\n');
             throw new Error(
               'Unexpected close tag\nLine: ' +
                 (parsedText.length - 1) +
@@ -103,7 +103,7 @@ function parse(text, options = {}) {
           node.children = [];
         }
       } else {
-        var parsedText = parseText();
+        const parsedText = parseText();
         if (keepWhitespace) {
           if (parsedText.length > 0) {
             children.push(parsedText);
@@ -191,12 +191,12 @@ function parse(text, options = {}) {
     // optional parsing of children
     if (text.charCodeAt(pos - 1) !== slashCC) {
       if (tagName == 'script') {
-        var start = pos + 1;
+        const start = pos + 1;
         pos = text.indexOf('</script>', pos);
         children = [text.slice(start, pos)];
         pos += 9;
       } else if (tagName == 'style') {
-        var start = pos + 1;
+        const start = pos + 1;
         pos = text.indexOf('</style>', pos);
         children = [text.slice(start, pos)];
         pos += 8;
@@ -241,10 +241,10 @@ function parse(text, options = {}) {
     }
   }
 
-  var out = null;
+  let out = null;
   if (options.attrValue !== undefined) {
     options.attrName = options.attrName || 'id';
-    var out = [];
+    out = [];
 
     while ((pos = findElements()) !== -1) {
       pos = text.lastIndexOf('<', pos);
@@ -264,10 +264,6 @@ function parse(text, options = {}) {
     out = filter(out, options.filter);
   }
 
-  if (options.simplify) {
-    return simplify(Array.isArray(out) ? out : [out]);
-  }
-
   if (options.setPos) {
     out.pos = pos;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dasha",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "author": "Vitaly Gashkov <vitalygashkov@vk.com>",
   "description": "Parser for MPEG-DASH & HLS manifests",
   "license": "AGPL-3.0",
@@ -48,13 +48,13 @@
     "m3u8-parser": "^7.1.0"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^22.0.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-import-x": "^3.1.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "^3.2.5",
-    "tsup": "^8.0.2",
-    "typescript": "^5.4.5"
+    "prettier": "^3.3.3",
+    "tsup": "^8.2.3",
+    "typescript": "^5.5.4"
   }
 }

package/types/dasha.d.ts

@@ -8,12 +8,25 @@ export interface Manifest {
     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';