dasha 2.3.1 → 2.3.3

package/lib/manifest.js

@@ -2,7 +2,7 @@
 
 const { parseXml } = require('./xml');
 const { processManifest } = require('./processor');
-const { getQualityLabel, getHeightByWidth } = require('./utils');
+const { getQualityLabel, getHeightByWidth, getClosest, sanitizeBaseUrl } = require('./utils');
 const { CONTENT_TYPE, KEY_SYSTEMS } = require('./constants');
 
 const isUrl = (value) => {
@@ -19,8 +19,9 @@ class Manifest {
   }
 
   addBaseUrl(value) {
-    if (Array.isArray(this.baseUrls)) this.baseUrls.push({ value });
-    else this.baseUrls = [{ value }];
+    const sanitizedValue = sanitizeBaseUrl(value);
+    if (Array.isArray(this.baseUrls)) this.baseUrls.push(sanitizedValue);
+    else this.baseUrls = [sanitizedValue];
   }
 
   getVideoTrack(height) {
@@ -34,11 +35,31 @@ class Manifest {
       .flat(1)
       .filter(isVideoAdaptationSet);
     const representations = adaptationSets.map((a) => a.representations).flat(2);
-    const matchesInHeight = representations.filter((r) => getHeightByWidth(r.width) === height);
-    const matchesInId = representations.filter((r) => r.id.includes(height));
-    const matches = matchesInHeight?.length ? matchesInHeight : matchesInId;
-    const representation = this.findBestRepresentation(matches.length ? matches : representations);
+
+    let suitableRepresentations = [];
+    if (height) {
+      const resolutions = representations.map((r) => ({
+        height: getHeightByWidth(r.width),
+        width: r.width,
+      }));
+      const heights = resolutions.map((r) => r.height);
+      const matchedHeight = height ? getClosest(height, heights) : Math.max(...heights);
+      const matchedResolution = resolutions.find((r) => r.height === matchedHeight);
+      const matchesInHeight = representations.filter((r) => matchedResolution.width === r.width);
+      const matchesInId = representations.filter((r) => r.id.includes(height.toString()));
+      suitableRepresentations = matchesInHeight?.length ? matchesInHeight : matchesInId;
+    }
+
+    const representation = this.findBestRepresentation(
+      suitableRepresentations.length ? suitableRepresentations : representations
+    );
     const adaptationSet = adaptationSets.find((a) => a.representations.includes(representation));
+    let codec = 'x264';
+    if (representation.codecs.includes('hvc') || representation.codecs.includes('hev'))
+      codec = 'x265';
+    let bitDepth = '8bit';
+    if (representation.codecs.includes('.2.4.')) bitDepth = '10bit';
+    if (representation.codecs.includes('.4.16.')) bitDepth = '12bit';
     return {
       id: 0,
       type: CONTENT_TYPE.video,
@@ -50,6 +71,10 @@ class Manifest {
       width: representation.width,
       height: representation.height,
       qualityLabel: getQualityLabel(representation.width),
+      hevc: representation.codecs.includes('hvc') || representation.codecs.includes('hev'),
+      codec,
+      codecs: representation.codecs,
+      bitDepth,
     };
   }
 
@@ -70,6 +95,7 @@ class Manifest {
     const tracks = [];
     for (const adaptationSet of adaptationSets) {
       const representation = this.findBestRepresentation(adaptationSet.representations);
+      let codec = '';
       const track = {
         id: tracks.length,
         type: CONTENT_TYPE.audio,
@@ -80,7 +106,8 @@ class Manifest {
         segments: this.getSegments(adaptationSet, representation),
         bitrate: Math.round(representation.bandwidth / 1000), // Kbps
         size: Math.ceil((representation.bandwidth / 8e6) * this.mediaPresentationDuration), // MB
-        audioSampleRate: representation.audioSamplingRate / 1000,
+        audioSamplingRate: representation.audioSamplingRate / 1000,
+        codecs: representation.codecs,
       };
       tracks.push(track);
     }
@@ -107,8 +134,8 @@ class Manifest {
     const tracks = [];
     for (const representation of selectedRepresentations) {
       const adaptationSet = adaptationSets.find((a) => a.representations.includes(representation));
-      const baseUrl = this.baseUrls?.[0]?.value;
-      const representationBaseUrl = representation.baseUrls?.[0]?.value;
+      const baseUrl = this.baseUrls?.[0];
+      const representationBaseUrl = representation.baseUrls?.[0];
       const url = isUrl(representationBaseUrl)
         ? representationBaseUrl
         : `${baseUrl || ''}${representationBaseUrl || ''}`;
@@ -151,7 +178,7 @@ class Manifest {
     const segmentTemplate = representation.segmentTemplate || adaptationSet.segmentTemplate;
     const baseUrls = representation.baseUrls || this.baseUrls;
     const isBaseUrlRequired = !segmentTemplate.media.includes(`https://`);
-    const baseUrl = baseUrls?.map((url) => url.value)?.[0];
+    const baseUrl = baseUrls?.[0];
     const initTemplate = segmentTemplate.initialization;
     const initUrl = initTemplate
       ?.replace(/\$Bandwidth\$/i, representation.bandwidth)
@@ -163,10 +190,12 @@ class Manifest {
     let time = 0;
     let index = parseInt(segmentTemplate.startNumber) || 0;
 
-    if (!Array.isArray(segmentTemplate['SegmentTimeline']['S']))
-      segmentTemplate['SegmentTimeline']['S'] = [segmentTemplate['SegmentTimeline']['S']];
+    let s = segmentTemplate['SegmentTimeline']?.['S'];
+    if (!!s && !Array.isArray(segmentTemplate['SegmentTimeline']?.['S']))
+      s = [segmentTemplate['SegmentTimeline']?.['S']];
 
-    for (const segment of segmentTemplate['SegmentTimeline']['S']) {
+    for (let i = segmentTemplate.start || 1; i < (s?.length || segmentTemplate.duration); i++) {
+      const segment = s?.[i] || {};
       const repeats = parseInt(segment.r || '0') + 1;
       if (segment.t) time = parseInt(segment.t);
       const duration = parseInt(segment.d || segmentTemplate.timescale || '0');
@@ -189,6 +218,14 @@ class Manifest {
     let pssh = null;
     for (const period of this.periods)
       for (const adaptationSet of period.adaptationSets) {
+        for (const representation of adaptationSet.representations) {
+          if (!representation.contentProtections) continue;
+          for (const contentProtection of representation.contentProtections)
+            if (contentProtection.cencPssh && contentProtection.schemeIdUri === schemeIdUri) {
+              pssh = contentProtection.cencPssh;
+              break;
+            }
+        }
         if (!adaptationSet.contentProtections) continue;
         for (const contentProtection of adaptationSet.contentProtections)
           if (contentProtection.cencPssh && contentProtection.schemeIdUri === schemeIdUri) {

package/lib/processor.js

@@ -1,4 +1,4 @@
-const { parseDuration } = require('./utils');
+const { parseDuration, sanitizeBaseUrl } = require('./utils');
 
 const processElement = (element, type) => {
   if (!element) return;
@@ -15,9 +15,13 @@ const processElement = (element, type) => {
 };
 
 const processRepresentation = (representation) => {
+  const contentProtectionsList = processElement(representation?.['ContentProtection'], 'array');
+  const contentProtections = contentProtectionsList?.map((c) => processContentProtection(c));
   return {
     id: representation['id'],
-    baseUrls: processElement(representation['BaseURL'], 'array'),
+    baseUrls: processElement(representation['BaseURL'], 'array')?.map((url) =>
+      sanitizeBaseUrl(url.value)
+    ),
     codecs: representation['codecs'],
     bandwidth: processElement(representation['bandwidth'], 'number'),
     frameRate: representation['frameRate'],
@@ -28,6 +32,7 @@ const processRepresentation = (representation) => {
     sar: representation['sar'],
     startWithSAP: representation['startWithSAP'],
     segmentTemplate: representation['SegmentTemplate'],
+    contentProtections,
   };
 };
 
@@ -50,7 +55,9 @@ const processAdaptationSet = (adaptationSet) => {
   return {
     id: adaptationSet['id'],
     group: processElement(adaptationSet['group'], 'number'),
-    baseUrls: processElement(adaptationSet['BaseURL'], 'array'),
+    baseUrls: processElement(adaptationSet['BaseURL'], 'array')?.map((url) =>
+      sanitizeBaseUrl(url.value)
+    ),
     segmentAlignment: adaptationSet['segmentAlignment'],
     lang: adaptationSet['lang'],
     maxWidth: processElement(adaptationSet['maxWidth'], 'number'),
@@ -82,7 +89,7 @@ const processManifest = (parsedXml) => {
   if (!periodsList.length) return null;
   return {
     periods: periodsList.map((p) => processPeriod(p)),
-    baseUrls: processElement(mpd['BaseURL'], 'array'),
+    baseUrls: processElement(mpd['BaseURL'], 'array')?.map((url) => sanitizeBaseUrl(url.value)),
     locations: processElement(mpd['Location'], 'array'),
     profiles: mpd['profiles'],
     mediaPresentationDuration: processElement(mpd['mediaPresentationDuration'], 'duration'),

package/lib/utils.js

@@ -49,6 +49,15 @@ const getHeightByWidth = (videoWidth) => {
   return height;
 };
 
+const getClosest = (value, array) =>
+  array.reduce((prev, curr) => (Math.abs(curr - value) < Math.abs(prev - value) ? curr : prev));
+
 const getQualityLabel = (videoWidth) => getHeightByWidth(videoWidth) + 'p';
 
-module.exports = { parseDuration, getHeightByWidth, getQualityLabel };
+const sanitizeBaseUrl = (value) => {
+  if (!value.includes('.mpd')) return value;
+  const manifestFilename = value.split('.mpd')[0].split('/').at(-1) + '.mpd';
+  return value.replace(manifestFilename, '');
+};
+
+module.exports = { parseDuration, getHeightByWidth, getQualityLabel, getClosest, sanitizeBaseUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dasha",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "author": "Vitaly Gashkov <vitalygashkov@bk.ru>",
   "description": "MPD-manifest parser for MPEG DASH",
   "license": "Apache-2.0",

package/types/manifest.d.ts

@@ -34,9 +34,13 @@ interface VideoTrack extends MediaTrack {
 interface AudioTrack extends MediaTrack {
   type: 'audio';
   audioSampleRate: number;
+  language: string;
 }
 
-interface SubtitleTrack {}
+interface SubtitleTrack extends MediaTrack {
+  type: 'text';
+  language: string;
+}
 
 interface Segment {
   url: string;
@@ -45,4 +49,4 @@ interface Segment {
 
 declare const parseManifest: (text: string) => Manifest | null;
 
-export { parseManifest, Manifest, VideoTrack, AudioTrack };
+export { parseManifest, Manifest, VideoTrack, AudioTrack, SubtitleTrack };