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

package/package.json

@@ -114,7 +114,7 @@
     "lint-staged": "15.2.10",
     "markdown-styles": "3.2.0",
     "micromatch": "4.0.8",
-    "mocha": "10.7.3",
+    "mocha": "10.8.2",
     "node-fetch": "3.3.2",
     "npm-run-all2": "6.2.6",
     "prettier": "3.3.3",
@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.85.0"
   },
-  "version": "1.6.0-beta.1.0.canary.10743"
+  "version": "1.6.0-beta.1.0.canary.10746"
 }

package/src/controller/latency-controller.ts

@@ -33,7 +33,7 @@ export default class LatencyController implements ComponentAPI {
     if (config.liveMaxLatencyDuration !== undefined) {
       return config.liveMaxLatencyDuration;
     }
-    const levelDetails = this.hls.latestLevelDetails;
+    const levelDetails = this.hls?.latestLevelDetails;
     return levelDetails
       ? config.liveMaxLatencyDurationCount * levelDetails.targetduration
       : 0;

package/src/controller/stream-controller.ts

@@ -11,8 +11,8 @@ import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
 import { ChunkMetadata } from '../types/transmuxer';
 import { BufferHelper } from '../utils/buffer-helper';
 import { pickMostCompleteCodecName } from '../utils/codecs';
-import type Hls from '../hls';
 import type { FragmentTracker } from './fragment-tracker';
+import type Hls from '../hls';
 import type { Fragment, MediaFragment } from '../loader/fragment';
 import type KeyLoader from '../loader/key-loader';
 import type { LevelDetails } from '../loader/level-details';

package/src/loader/date-range.ts

@@ -1,6 +1,6 @@
 import { AttrList } from '../utils/attr-list';
 import { logger } from '../utils/logger';
-import type { Fragment } from './fragment';
+import type { MediaFragmentRef } from './fragment';
 
 // Avoid exporting const enum so that these values can be inlined
 const enum DateRangeAttribute {
@@ -47,7 +47,7 @@ export function isSCTE35Attribute(attrName: string): boolean {
 
 export class DateRange {
   public attr: AttrList;
-  public tagAnchor: Fragment | null;
+  public tagAnchor: MediaFragmentRef | null;
   public tagOrder: number;
   private _startDate: Date;
   private _endDate?: Date;

package/src/loader/fragment.ts

@@ -29,23 +29,27 @@ export type ElementaryStreams = Record<
   ElementaryStreamInfo | null
 >;
 
+export type Base = {
+  url: string;
+};
+
 export class BaseSegment {
   private _byteRange: [number, number] | null = null;
   private _url: string | null = null;
+  private _stats: LoadStats | null = null;
+  private _streams: ElementaryStreams | null = null;
 
   // baseurl is the URL to the playlist
-  public readonly baseurl: string;
+  public readonly base: Base;
+
   // relurl is the portion of the URL that comes from inside the playlist.
   public relurl?: string;
-  // Holds the types of data this fragment supports
-  public elementaryStreams: ElementaryStreams = {
-    [ElementaryStreamTypes.AUDIO]: null,
-    [ElementaryStreamTypes.VIDEO]: null,
-    [ElementaryStreamTypes.AUDIOVIDEO]: null,
-  };
 
-  constructor(baseurl: string) {
-    this.baseurl = baseurl;
+  constructor(base: Base | string) {
+    if (typeof base === 'string') {
+      base = { url: base };
+    }
+    this.base = base;
   }
 
   // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
@@ -60,8 +64,12 @@ export class BaseSegment {
     this._byteRange = [start, parseInt(params[0]) + start];
   }
 
+  get baseurl(): string {
+    return this.base.url;
+  }
+
   get byteRange(): [number, number] | [] {
-    if (!this._byteRange) {
+    if (this._byteRange === null) {
       return [];
     }
 
@@ -76,6 +84,40 @@ export class BaseSegment {
     return this.byteRange[1];
   }
 
+  get elementaryStreams(): ElementaryStreams {
+    if (this._streams === null) {
+      this._streams = {
+        [ElementaryStreamTypes.AUDIO]: null,
+        [ElementaryStreamTypes.VIDEO]: null,
+        [ElementaryStreamTypes.AUDIOVIDEO]: null,
+      };
+    }
+    return this._streams;
+  }
+
+  set elementaryStreams(value: ElementaryStreams) {
+    this._streams = value;
+  }
+
+  get hasStats(): boolean {
+    return this._stats !== null;
+  }
+
+  get hasStreams(): boolean {
+    return this._streams !== null;
+  }
+
+  get stats(): LoadStats {
+    if (this._stats === null) {
+      this._stats = new LoadStats();
+    }
+    return this._stats;
+  }
+
+  set stats(value: LoadStats) {
+    this._stats = value;
+  }
+
   get url(): string {
     if (!this._url && this.baseurl && this.relurl) {
       this._url = buildAbsoluteURL(this.baseurl, this.relurl, {
@@ -99,16 +141,26 @@ export class BaseSegment {
 
 export interface MediaFragment extends Fragment {
   sn: number;
+  ref: MediaFragmentRef;
 }
 
+export type MediaFragmentRef = {
+  base: Base;
+  start: number;
+  duration: number;
+  sn: number;
+  programDateTime: number | null;
+};
+
 /**
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
  */
 export class Fragment extends BaseSegment {
   private _decryptdata: LevelKey | null = null;
+  private _programDateTime: number | null = null;
+  private _ref: MediaFragmentRef | null = null;
 
   public rawProgramDateTime: string | null = null;
-  public programDateTime: number | null = null;
   public tagList: Array<string[]> = [];
 
   // EXTINF has to be present for a m3u8 to be considered valid
@@ -147,8 +199,6 @@ export class Fragment extends BaseSegment {
   public maxStartPTS?: number;
   // The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
   public minEndPTS?: number;
-  // Load/parse timing information
-  public stats: LoadStats = new LoadStats();
   // Init Segment bytes (unset for media segments)
   public data?: Uint8Array;
   // A flag indicating whether the segment was downloaded in order to test bitrate, and was not buffered
@@ -164,8 +214,8 @@ export class Fragment extends BaseSegment {
   // Deprecated
   public urlId: number = 0;
 
-  constructor(type: PlaylistLevelType, baseurl: string) {
-    super(baseurl);
+  constructor(type: PlaylistLevelType, base: Base | string) {
+    super(base);
     this.type = type;
   }
 
@@ -203,10 +253,6 @@ export class Fragment extends BaseSegment {
       return null;
     }
 
-    if (!Number.isFinite(this.programDateTime)) {
-      return null;
-    }
-
     const duration = !Number.isFinite(this.duration) ? 0 : this.duration;
 
     return this.programDateTime + duration * 1000;
@@ -225,10 +271,58 @@ export class Fragment extends BaseSegment {
         return true;
       }
     }
-
     return false;
   }
 
+  get programDateTime(): number | null {
+    if (this._programDateTime === null && this.rawProgramDateTime) {
+      this.programDateTime = Date.parse(this.rawProgramDateTime);
+    }
+    return this._programDateTime;
+  }
+
+  set programDateTime(value: number | null) {
+    if (!Number.isFinite(value)) {
+      this._programDateTime = this.rawProgramDateTime = null;
+      return;
+    }
+    this._programDateTime = value;
+  }
+
+  get ref(): MediaFragmentRef | null {
+    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: number) {
+    this.setStart(this.start + value);
+  }
+
+  setStart(value: number) {
+    this.start = value;
+    if (this._ref) {
+      this._ref.start = value;
+    }
+  }
+
+  setDuration(value: number) {
+    this.duration = value;
+    if (this._ref) {
+      this._ref.duration = value;
+    }
+  }
+
   setKeyFormat(keyFormat: KeySystemFormats) {
     if (this.levelkeys) {
       const key = this.levelkeys[keyFormat];
@@ -282,16 +376,15 @@ export class Part extends BaseSegment {
   public readonly relurl: string;
   public readonly fragment: MediaFragment;
   public readonly index: number;
-  public stats: LoadStats = new LoadStats();
 
   constructor(
     partAttrs: AttrList,
     frag: MediaFragment,
-    baseurl: string,
+    base: Base | string,
     index: number,
     previous?: Part,
   ) {
-    super(baseurl);
+    super(base);
     this.duration = partAttrs.decimalFloatingPoint('DURATION');
     this.gap = partAttrs.bool('GAP');
     this.independent = partAttrs.bool('INDEPENDENT');

package/src/loader/interstitial-event.ts

@@ -1,6 +1,6 @@
 import { hash } from '../utils/hash';
 import type { DateRange, DateRangeCue } from './date-range';
-import type { Fragment } from './fragment';
+import type { MediaFragmentRef } from './fragment';
 import type { Loader, LoaderContext } from '../types/loader';
 
 export const ALIGNED_END_THRESHOLD_SECONDS = 0.02; // 0.1 // 0.2
@@ -74,7 +74,7 @@ export class InterstitialEvent {
   public assetList: InterstitialAssetItem[] = [];
   public assetListLoader?: Loader<LoaderContext>;
   public assetListResponse: AssetListJSON | null = null;
-  public resumeAnchor?: Fragment;
+  public resumeAnchor?: MediaFragmentRef;
   public error?: Error;
 
   constructor(dateRange: DateRange, base: BaseData) {
@@ -261,11 +261,14 @@ export class InterstitialEvent {
   }
 }
 
-function getSnapToFragmentTime(time: number, frag: Fragment) {
+function getSnapToFragmentTime(time: number, frag: MediaFragmentRef) {
   return time - frag.start < frag.duration / 2 &&
-    !(Math.abs(time - frag.end) < ALIGNED_END_THRESHOLD_SECONDS)
+    !(
+      Math.abs(time - (frag.start + frag.duration)) <
+      ALIGNED_END_THRESHOLD_SECONDS
+    )
     ? frag.start
-    : frag.end;
+    : frag.start + frag.duration;
 }
 
 export function getInterstitialUrl(

package/src/loader/m3u8-parser.ts

@@ -48,8 +48,6 @@ const LEVEL_PLAYLIST_REGEX_FAST = new RegExp(
   [
     /#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*)\s+)?/.source, // 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',
@@ -58,7 +56,7 @@ const LEVEL_PLAYLIST_REGEX_FAST = new RegExp(
 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):(.+)/
+    /#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,
@@ -306,6 +304,7 @@ export default class M3U8Parser {
     levelUrlId: number,
     multivariantVariableList: VariableMap | null,
   ): LevelDetails {
+    const base = { url: baseurl };
     const level = new LevelDetails(baseurl);
     const fragments: M3U8ParserFragments = level.fragments;
     const programDateTimes: MediaFragment[] = [];
@@ -316,7 +315,7 @@ export default class M3U8Parser {
     let totalduration = 0;
     let discontinuityCounter = 0;
     let prevFrag: Fragment | null = null;
-    let frag: Fragment = new Fragment(type, baseurl);
+    let frag: Fragment = new Fragment(type, base);
     let result: RegExpExecArray | RegExpMatchArray | null;
     let i: number;
     let levelkeys: { [key: string]: LevelKey } | undefined;
@@ -333,7 +332,7 @@ export default 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;
@@ -342,8 +341,10 @@ export default 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;
@@ -387,22 +388,6 @@ export default 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) {
@@ -410,7 +395,7 @@ export default class M3U8Parser {
           continue;
         }
         for (i = 1; i < result.length; i++) {
-          if (typeof result[i] !== 'undefined') {
+          if (result[i] !== undefined) {
             break;
           }
         }
@@ -418,9 +403,24 @@ export default 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;
@@ -546,7 +546,7 @@ export default 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;
@@ -607,7 +607,7 @@ export default class M3U8Parser {
             const part = new Part(
               partAttrs,
               frag as MediaFragment,
-              baseurl,
+              base,
               index,
               previousFragmentPart,
             );
@@ -709,7 +709,7 @@ export function mapDateRanges(
   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,
@@ -719,7 +719,7 @@ export function mapDateRanges(
         playlistEnd,
       );
       if (fragIndex !== -1) {
-        dateRange.tagAnchor = details.fragments[fragIndex];
+        dateRange.tagAnchor = details.fragments[fragIndex].ref;
         break;
       }
     }
@@ -736,31 +736,30 @@ function findFragmentWithStartDate(
   const pdtFragment = programDateTimes[index];
   if (pdtFragment) {
     // find matching range between PDT tags
-    const durationBetweenPdt =
-      (programDateTimes[index + 1]?.start || endTime) - pdtFragment.start;
     const pdtStart = pdtFragment.programDateTime as number;
-    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 as number;
-          if (
-            startDateTime >= fragStartDateTime &&
-            startDateTime < fragStartDateTime + fragments[i].duration * 1000
-          ) {
-            return i;
+    if (startDateTime >= pdtStart || index === 0) {
+      const durationBetweenPdt =
+        (programDateTimes[index + 1]?.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 as number;
+            if (
+              startDateTime >= fragStartDateTime &&
+              startDateTime < fragStartDateTime + fragments[i].duration * 1000
+            ) {
+              return i;
+            }
           }
         }
+        return startIndex;
       }
-      return startIndex;
     }
   }
   return -1;
@@ -862,12 +861,6 @@ export function assignProgramDateTime(
   programDateTimes: MediaFragment[],
 ) {
   if (frag.rawProgramDateTime) {
-    frag.programDateTime = Date.parse(frag.rawProgramDateTime);
-    if (!Number.isFinite(frag.programDateTime)) {
-      frag.programDateTime = null;
-      frag.rawProgramDateTime = null;
-      return;
-    }
     programDateTimes.push(frag);
   } else if (prevFrag?.programDateTime) {
     frag.programDateTime = prevFrag.endProgramDateTime;

package/src/utils/level-helper.ts

@@ -38,19 +38,19 @@ function updateFromToPTS(fragFrom: MediaFragment, fragTo: MediaFragment) {
       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));
   }
 }
 
@@ -92,9 +92,9 @@ export function updateFragPTSDTS(
 
   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;
@@ -170,15 +170,14 @@ export function mergeDetails(
         Number.isFinite(oldFrag.startPTS) &&
         Number.isFinite(oldFrag.endPTS)
       ) {
-        newFrag.start = newFrag.startPTS = oldFrag.startPTS as number;
+        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 as number) - (oldFrag.startPTS as number);
+        newFrag.setDuration(oldFrag.endPTS! - oldFrag.startPTS!);
 
         if (newFrag.duration) {
           PTSFrag = newFrag;
@@ -187,9 +186,17 @@ export function mergeDetails(
         // 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;
@@ -432,14 +439,14 @@ export function adjustSliding(
   addSliding(newDetails, sliding);
 }
 
-export function addSliding(details: LevelDetails, start: number) {
-  if (start) {
+export function addSliding(details: LevelDetails, sliding: number) {
+  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);
     }
   }
 }