hls.js 1.6.0-beta.1.0.canary.10745 → 1.6.0-beta.1.0.canary.10746

package/dist/hls.light.mjs

@@ -397,7 +397,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.1.0.canary.10745"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.1.0.canary.10746"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -2766,20 +2766,21 @@ var ElementaryStreamTypes = {
   AUDIOVIDEO: "audiovideo"
 };
 class BaseSegment {
-  constructor(baseurl) {
+  constructor(base) {
     this._byteRange = null;
     this._url = null;
+    this._stats = null;
+    this._streams = null;
     // baseurl is the URL to the playlist
-    this.baseurl = void 0;
+    this.base = void 0;
     // relurl is the portion of the URL that comes from inside the playlist.
     this.relurl = void 0;
-    // Holds the types of data this fragment supports
-    this.elementaryStreams = {
-      [ElementaryStreamTypes.AUDIO]: null,
-      [ElementaryStreamTypes.VIDEO]: null,
-      [ElementaryStreamTypes.AUDIOVIDEO]: null
-    };
-    this.baseurl = baseurl;
+    if (typeof base === 'string') {
+      base = {
+        url: base
+      };
+    }
+    this.base = base;
   }
 
   // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
@@ -2793,8 +2794,11 @@ class BaseSegment {
     }
     this._byteRange = [start, parseInt(params[0]) + start];
   }
+  get baseurl() {
+    return this.base.url;
+  }
   get byteRange() {
-    if (!this._byteRange) {
+    if (this._byteRange === null) {
       return [];
     }
     return this._byteRange;
@@ -2805,6 +2809,34 @@ class BaseSegment {
   get byteRangeEndOffset() {
     return this.byteRange[1];
   }
+  get elementaryStreams() {
+    if (this._streams === null) {
+      this._streams = {
+        [ElementaryStreamTypes.AUDIO]: null,
+        [ElementaryStreamTypes.VIDEO]: null,
+        [ElementaryStreamTypes.AUDIOVIDEO]: null
+      };
+    }
+    return this._streams;
+  }
+  set elementaryStreams(value) {
+    this._streams = value;
+  }
+  get hasStats() {
+    return this._stats !== null;
+  }
+  get hasStreams() {
+    return this._streams !== null;
+  }
+  get stats() {
+    if (this._stats === null) {
+      this._stats = new LoadStats();
+    }
+    return this._stats;
+  }
+  set stats(value) {
+    this._stats = value;
+  }
   get url() {
     if (!this._url && this.baseurl && this.relurl) {
       this._url = urlToolkitExports.buildAbsoluteURL(this.baseurl, this.relurl, {
@@ -2829,11 +2861,12 @@ class BaseSegment {
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
  */
 class Fragment extends BaseSegment {
-  constructor(type, baseurl) {
-    super(baseurl);
+  constructor(type, base) {
+    super(base);
     this._decryptdata = null;
+    this._programDateTime = null;
+    this._ref = null;
     this.rawProgramDateTime = null;
-    this.programDateTime = null;
     this.tagList = [];
     // EXTINF has to be present for a m3u8 to be considered valid
     this.duration = 0;
@@ -2871,8 +2904,6 @@ class Fragment extends BaseSegment {
     this.maxStartPTS = void 0;
     // The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
     this.minEndPTS = void 0;
-    // Load/parse timing information
-    this.stats = new LoadStats();
     // Init Segment bytes (unset for media segments)
     this.data = void 0;
     // A flag indicating whether the segment was downloaded in order to test bitrate, and was not buffered
@@ -2916,9 +2947,6 @@ class Fragment extends BaseSegment {
     if (this.programDateTime === null) {
       return null;
     }
-    if (!isFiniteNumber(this.programDateTime)) {
-      return null;
-    }
     const duration = !isFiniteNumber(this.duration) ? 0 : this.duration;
     return this.programDateTime + duration * 1000;
   }
@@ -2938,6 +2966,49 @@ class Fragment extends BaseSegment {
     }
     return false;
   }
+  get programDateTime() {
+    if (this._programDateTime === null && this.rawProgramDateTime) {
+      this.programDateTime = Date.parse(this.rawProgramDateTime);
+    }
+    return this._programDateTime;
+  }
+  set programDateTime(value) {
+    if (!isFiniteNumber(value)) {
+      this._programDateTime = this.rawProgramDateTime = null;
+      return;
+    }
+    this._programDateTime = value;
+  }
+  get ref() {
+    if (this.sn === 'initSegment') {
+      return null;
+    }
+    if (!this._ref) {
+      this._ref = {
+        base: this.base,
+        start: this.start,
+        duration: this.duration,
+        sn: this.sn,
+        programDateTime: this.programDateTime
+      };
+    }
+    return this._ref;
+  }
+  addStart(value) {
+    this.setStart(this.start + value);
+  }
+  setStart(value) {
+    this.start = value;
+    if (this._ref) {
+      this._ref.start = value;
+    }
+  }
+  setDuration(value) {
+    this.duration = value;
+    if (this._ref) {
+      this._ref.duration = value;
+    }
+  }
   setKeyFormat(keyFormat) {
     if (this.levelkeys) {
       const key = this.levelkeys[keyFormat];
@@ -2977,8 +3048,8 @@ class Fragment extends BaseSegment {
  * Object representing parsed data from an HLS Partial Segment. Found in {@link hls.js#LevelDetails.partList}.
  */
 class Part extends BaseSegment {
-  constructor(partAttrs, frag, baseurl, index, previous) {
-    super(baseurl);
+  constructor(partAttrs, frag, base, index, previous) {
+    super(base);
     this.fragOffset = 0;
     this.duration = 0;
     this.gap = false;
@@ -2986,7 +3057,6 @@ class Part extends BaseSegment {
     this.relurl = void 0;
     this.fragment = void 0;
     this.index = void 0;
-    this.stats = new LoadStats();
     this.duration = partAttrs.decimalFloatingPoint('DURATION');
     this.gap = partAttrs.bool('GAP');
     this.independent = partAttrs.bool('INDEPENDENT');
@@ -4398,13 +4468,9 @@ const LEVEL_PLAYLIST_REGEX_FAST = new RegExp([/#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*
 // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
 /(?!#) *(\S[^\r\n]*)/.source,
 // segment URI, group 3 => the URI (note newline is not eaten)
-/#EXT-X-BYTERANGE:*(.+)/.source,
-// next segment's byterange, group 4 => range spec (x@y)
-/#EXT-X-PROGRAM-DATE-TIME:(.+)/.source,
-// next segment's program date/time group 5 => the datetime spec
 /#.*/.source // All other non-segment oriented tags will match with all groups empty
 ].join('|'), 'g');
-const LEVEL_PLAYLIST_REGEX_SLOW = new RegExp([/#(EXTM3U)/.source, /#EXT-X-(DATERANGE|DEFINE|KEY|MAP|PART|PART-INF|PLAYLIST-TYPE|PRELOAD-HINT|RENDITION-REPORT|SERVER-CONTROL|SKIP|START):(.+)/.source, /#EXT-X-(BITRATE|DISCONTINUITY-SEQUENCE|MEDIA-SEQUENCE|TARGETDURATION|VERSION): *(\d+)/.source, /#EXT-X-(DISCONTINUITY|ENDLIST|GAP|INDEPENDENT-SEGMENTS)/.source, /(#)([^:]*):(.*)/.source, /(#)(.*)(?:.*)\r?\n?/.source].join('|'));
+const LEVEL_PLAYLIST_REGEX_SLOW = new RegExp([/#(EXTM3U)/.source, /#EXT-X-(PROGRAM-DATE-TIME|BYTERANGE|DATERANGE|DEFINE|KEY|MAP|PART|PART-INF|PLAYLIST-TYPE|PRELOAD-HINT|RENDITION-REPORT|SERVER-CONTROL|SKIP|START):(.+)/.source, /#EXT-X-(BITRATE|DISCONTINUITY-SEQUENCE|MEDIA-SEQUENCE|TARGETDURATION|VERSION): *(\d+)/.source, /#EXT-X-(DISCONTINUITY|ENDLIST|GAP|INDEPENDENT-SEGMENTS)/.source, /(#)([^:]*):(.*)/.source, /(#)(.*)(?:.*)\r?\n?/.source].join('|'));
 class M3U8Parser {
   static findGroup(groups, mediaGroupId) {
     for (let i = 0; i < groups.length; i++) {
@@ -4589,6 +4655,9 @@ class M3U8Parser {
     return results;
   }
   static parseLevelPlaylist(string, baseurl, id, type, levelUrlId, multivariantVariableList) {
+    const base = {
+      url: baseurl
+    };
     const level = new LevelDetails(baseurl);
     const fragments = level.fragments;
     const programDateTimes = [];
@@ -4599,7 +4668,7 @@ class M3U8Parser {
     let totalduration = 0;
     let discontinuityCounter = 0;
     let prevFrag = null;
-    let frag = new Fragment(type, baseurl);
+    let frag = new Fragment(type, base);
     let result;
     let i;
     let levelkeys;
@@ -4612,7 +4681,7 @@ class M3U8Parser {
     while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
       if (createNextFrag) {
         createNextFrag = false;
-        frag = new Fragment(type, baseurl);
+        frag = new Fragment(type, base);
         // setup the next fragment for part loading
         frag.playlistOffset = totalduration;
         frag.start = totalduration;
@@ -4621,8 +4690,10 @@ class M3U8Parser {
         frag.level = id;
         if (currentInitSegment) {
           frag.initSegment = currentInitSegment;
-          frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
-          currentInitSegment.rawProgramDateTime = null;
+          if (currentInitSegment.rawProgramDateTime) {
+            frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
+            currentInitSegment.rawProgramDateTime = null;
+          }
           if (nextByteRange) {
             frag.setByteRange(nextByteRange);
             nextByteRange = null;
@@ -4659,22 +4730,6 @@ class M3U8Parser {
           currentPart = 0;
           createNextFrag = true;
         }
-      } else if (result[4]) {
-        // X-BYTERANGE
-        const data = (' ' + result[4]).slice(1);
-        if (prevFrag) {
-          frag.setByteRange(data, prevFrag);
-        } else {
-          frag.setByteRange(data);
-        }
-      } else if (result[5]) {
-        // PROGRAM-DATE-TIME
-        // avoid sliced strings    https://github.com/video-dev/hls.js/issues/939
-        frag.rawProgramDateTime = (' ' + result[5]).slice(1);
-        frag.tagList.push(['PROGRAM-DATE-TIME', frag.rawProgramDateTime]);
-        if (firstPdtIndex === -1) {
-          firstPdtIndex = fragments.length;
-        }
       } else {
         result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
         if (!result) {
@@ -4682,7 +4737,7 @@ class M3U8Parser {
           continue;
         }
         for (i = 1; i < result.length; i++) {
-          if (typeof result[i] !== 'undefined') {
+          if (result[i] !== undefined) {
             break;
           }
         }
@@ -4690,8 +4745,23 @@ class M3U8Parser {
         // avoid sliced strings    https://github.com/video-dev/hls.js/issues/939
         const tag = (' ' + result[i]).slice(1);
         const value1 = (' ' + result[i + 1]).slice(1);
-        const value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : '';
+        const value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : null;
         switch (tag) {
+          case 'BYTERANGE':
+            if (prevFrag) {
+              frag.setByteRange(value1, prevFrag);
+            } else {
+              frag.setByteRange(value1);
+            }
+            break;
+          case 'PROGRAM-DATE-TIME':
+            // avoid sliced strings    https://github.com/video-dev/hls.js/issues/939
+            frag.rawProgramDateTime = value1;
+            frag.tagList.push(['PROGRAM-DATE-TIME', value1]);
+            if (firstPdtIndex === -1) {
+              firstPdtIndex = fragments.length;
+            }
+            break;
           case 'PLAYLIST-TYPE':
             level.type = value1.toUpperCase();
             break;
@@ -4798,7 +4868,7 @@ class M3U8Parser {
                 // Initial segment tag is after segment duration tag.
                 //   #EXTINF: 6.0
                 //   #EXT-X-MAP:URI="init.mp4
-                const init = new Fragment(type, baseurl);
+                const init = new Fragment(type, base);
                 setInitSegment(init, mapAttrs, id, levelkeys);
                 currentInitSegment = init;
                 frag.initSegment = currentInitSegment;
@@ -4847,7 +4917,7 @@ class M3U8Parser {
               const previousFragmentPart = currentPart > 0 ? partList[partList.length - 1] : undefined;
               const index = currentPart++;
               const partAttrs = new AttrList(value1, level);
-              const part = new Part(partAttrs, frag, baseurl, index, previousFragmentPart);
+              const part = new Part(partAttrs, frag, base, index, previousFragmentPart);
               partList.push(part);
               frag.duration += part.duration;
               break;
@@ -4938,11 +5008,11 @@ function mapDateRanges(programDateTimes, details) {
   for (let i = dateRangeIds.length; i--;) {
     const dateRange = details.dateRanges[dateRangeIds[i]];
     const startDateTime = dateRange.startDate.getTime();
-    dateRange.tagAnchor = lastProgramDateTime;
+    dateRange.tagAnchor = lastProgramDateTime.ref;
     for (let j = programDateTimeCount; j--;) {
       const fragIndex = findFragmentWithStartDate(details, startDateTime, programDateTimes, j, playlistEnd);
       if (fragIndex !== -1) {
-        dateRange.tagAnchor = details.fragments[fragIndex];
+        dateRange.tagAnchor = details.fragments[fragIndex].ref;
         break;
       }
     }
@@ -4951,25 +5021,27 @@ function mapDateRanges(programDateTimes, details) {
 function findFragmentWithStartDate(details, startDateTime, programDateTimes, index, endTime) {
   const pdtFragment = programDateTimes[index];
   if (pdtFragment) {
-    var _programDateTimes;
     // find matching range between PDT tags
-    const durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
     const pdtStart = pdtFragment.programDateTime;
-    if ((startDateTime >= pdtStart || index === 0) && startDateTime <= pdtStart + durationBetweenPdt * 1000) {
-      // map to fragment with date-time range
-      const startIndex = programDateTimes[index].sn - details.startSN;
-      const fragments = details.fragments;
-      if (fragments.length > programDateTimes.length) {
-        const endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
-        const endIndex = endSegment.sn - details.startSN;
-        for (let i = endIndex; i > startIndex; i--) {
-          const fragStartDateTime = fragments[i].programDateTime;
-          if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
-            return i;
+    if (startDateTime >= pdtStart || index === 0) {
+      var _programDateTimes;
+      const durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
+      if (startDateTime <= pdtStart + durationBetweenPdt * 1000) {
+        // map to fragment with date-time range
+        const startIndex = programDateTimes[index].sn - details.startSN;
+        const fragments = details.fragments;
+        if (fragments.length > programDateTimes.length) {
+          const endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
+          const endIndex = endSegment.sn - details.startSN;
+          for (let i = endIndex; i > startIndex; i--) {
+            const fragStartDateTime = fragments[i].programDateTime;
+            if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
+              return i;
+            }
           }
         }
+        return startIndex;
       }
-      return startIndex;
     }
   }
   return -1;
@@ -5034,12 +5106,6 @@ function backfillProgramDateTimes(fragments, firstPdtIndex) {
 }
 function assignProgramDateTime(frag, prevFrag, programDateTimes) {
   if (frag.rawProgramDateTime) {
-    frag.programDateTime = Date.parse(frag.rawProgramDateTime);
-    if (!isFiniteNumber(frag.programDateTime)) {
-      frag.programDateTime = null;
-      frag.rawProgramDateTime = null;
-      return;
-    }
     programDateTimes.push(frag);
   } else if (prevFrag != null && prevFrag.programDateTime) {
     frag.programDateTime = prevFrag.endProgramDateTime;
@@ -5083,19 +5149,19 @@ function updateFromToPTS(fragFrom, fragTo) {
       frag = fragTo;
     }
     if (frag.duration !== duration) {
-      frag.duration = duration;
+      frag.setDuration(duration);
     }
     // we dont know startPTS[toIdx]
   } else if (fragTo.sn > fragFrom.sn) {
     const contiguous = fragFrom.cc === fragTo.cc;
     // TODO: With part-loading end/durations we need to confirm the whole fragment is loaded before using (or setting) minEndPTS
     if (contiguous && fragFrom.minEndPTS) {
-      fragTo.start = fragFrom.start + (fragFrom.minEndPTS - fragFrom.start);
+      fragTo.setStart(fragFrom.start + (fragFrom.minEndPTS - fragFrom.start));
     } else {
-      fragTo.start = fragFrom.start + fragFrom.duration;
+      fragTo.setStart(fragFrom.start + fragFrom.duration);
     }
   } else {
-    fragTo.start = Math.max(fragFrom.start - fragTo.duration, 0);
+    fragTo.setStart(Math.max(fragFrom.start - fragTo.duration, 0));
   }
 }
 function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
@@ -5126,9 +5192,9 @@ function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
   }
   const drift = startPTS - frag.start;
   if (frag.start !== 0) {
-    frag.start = startPTS;
+    frag.setStart(startPTS);
   }
-  frag.duration = endPTS - frag.start;
+  frag.setDuration(endPTS - frag.start);
   frag.startPTS = startPTS;
   frag.maxStartPTS = maxStartPTS;
   frag.startDTS = startDTS;
@@ -5191,13 +5257,13 @@ function mergeDetails(oldDetails, newDetails) {
       ccOffset = oldFrag.cc - newFrag.cc;
     }
     if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
-      newFrag.start = newFrag.startPTS = oldFrag.startPTS;
+      newFrag.setStart(newFrag.startPTS = oldFrag.startPTS);
       newFrag.startDTS = oldFrag.startDTS;
       newFrag.maxStartPTS = oldFrag.maxStartPTS;
       newFrag.endPTS = oldFrag.endPTS;
       newFrag.endDTS = oldFrag.endDTS;
       newFrag.minEndPTS = oldFrag.minEndPTS;
-      newFrag.duration = oldFrag.endPTS - oldFrag.startPTS;
+      newFrag.setDuration(oldFrag.endPTS - oldFrag.startPTS);
       if (newFrag.duration) {
         PTSFrag = newFrag;
       }
@@ -5205,9 +5271,13 @@ function mergeDetails(oldDetails, newDetails) {
       // PTS is known when any segment has startPTS and endPTS
       newDetails.PTSKnown = newDetails.alignedSliding = true;
     }
-    newFrag.elementaryStreams = oldFrag.elementaryStreams;
+    if (oldFrag.hasStreams) {
+      newFrag.elementaryStreams = oldFrag.elementaryStreams;
+    }
     newFrag.loader = oldFrag.loader;
-    newFrag.stats = oldFrag.stats;
+    if (oldFrag.hasStats) {
+      newFrag.stats = oldFrag.stats;
+    }
     if (oldFrag.initSegment) {
       newFrag.initSegment = oldFrag.initSegment;
       currentInitSegment = oldFrag.initSegment;
@@ -5373,14 +5443,14 @@ function adjustSliding(oldDetails, newDetails, matchingStableVariantOrRendition
   }
   addSliding(newDetails, sliding);
 }
-function addSliding(details, start) {
-  if (start) {
+function addSliding(details, sliding) {
+  if (sliding) {
     const fragments = details.fragments;
     for (let i = details.skippedSegments; i < fragments.length; i++) {
-      fragments[i].start += start;
+      fragments[i].addStart(sliding);
     }
     if (details.fragmentHint) {
-      details.fragmentHint.start += start;
+      details.fragmentHint.addStart(sliding);
     }
   }
 }
@@ -17881,13 +17951,14 @@ class LatencyController {
     return this._latency || 0;
   }
   get maxLatency() {
+    var _this$hls;
     const {
       config
     } = this;
     if (config.liveMaxLatencyDuration !== undefined) {
       return config.liveMaxLatencyDuration;
     }
-    const levelDetails = this.hls.latestLevelDetails;
+    const levelDetails = (_this$hls = this.hls) == null ? void 0 : _this$hls.latestLevelDetails;
     return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
   }
   get targetLatency() {
@@ -18962,7 +19033,7 @@ class GapController extends Logger {
   }
 }
 
-const version = "1.6.0-beta.1.0.canary.10745";
+const version = "1.6.0-beta.1.0.canary.10746";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js