hls.js 1.6.0-beta.2.0.canary.10923 → 1.6.0-beta.2.0.canary.10925

package/src/controller/interstitials-controller.ts

@@ -22,6 +22,10 @@ import {
   TimelineOccupancy,
 } from '../loader/interstitial-event';
 import { BufferHelper } from '../utils/buffer-helper';
+import {
+  addEventListener,
+  removeEventListener,
+} from '../utils/event-listener-helper';
 import { hash } from '../utils/hash';
 import { Logger } from '../utils/logger';
 import { isCompatibleTrackChange } from '../utils/mediasource-helper';
@@ -226,17 +230,17 @@ export default class InterstitialsController
   }
 
   private onDestroying() {
-    const media = this.primaryMedia;
+    const media = this.primaryMedia || this.media;
     if (media) {
       this.removeMediaListeners(media);
     }
   }
 
   private removeMediaListeners(media: HTMLMediaElement) {
-    media.removeEventListener('play', this.onPlay);
-    media.removeEventListener('pause', this.onPause);
-    media.removeEventListener('seeking', this.onSeeking);
-    media.removeEventListener('timeupdate', this.onTimeupdate);
+    removeEventListener(media, 'play', this.onPlay);
+    removeEventListener(media, 'pause', this.onPause);
+    removeEventListener(media, 'seeking', this.onSeeking);
+    removeEventListener(media, 'timeupdate', this.onTimeupdate);
   }
 
   private onMediaAttaching(
@@ -244,11 +248,10 @@ export default class InterstitialsController
     data: MediaAttachingData,
   ) {
     const media = (this.media = data.media);
-    this.removeMediaListeners(media);
-    media.addEventListener('seeking', this.onSeeking);
-    media.addEventListener('timeupdate', this.onTimeupdate);
-    media.addEventListener('play', this.onPlay);
-    media.addEventListener('pause', this.onPause);
+    addEventListener(media, 'seeking', this.onSeeking);
+    addEventListener(media, 'timeupdate', this.onTimeupdate);
+    addEventListener(media, 'play', this.onPlay);
+    addEventListener(media, 'pause', this.onPause);
   }
 
   private onMediaAttached(

package/src/controller/stream-controller.ts

@@ -1,7 +1,7 @@
 import BaseStreamController, { State } from './base-stream-controller';
 import { findFragmentByPTS } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
-import GapController, { MAX_START_GAP_JUMP } from './gap-controller';
+import { MAX_START_GAP_JUMP } from './gap-controller';
 import TransmuxerInterface from '../demux/transmuxer-interface';
 import { ErrorDetails } from '../errors';
 import { Events } from '../events';
@@ -11,13 +11,21 @@ import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
 import { ChunkMetadata } from '../types/transmuxer';
 import { BufferHelper } from '../utils/buffer-helper';
 import { pickMostCompleteCodecName } from '../utils/codecs';
+import {
+  addEventListener,
+  removeEventListener,
+} from '../utils/event-listener-helper';
 import { useAlternateAudio } from '../utils/rendition-helper';
 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';
-import type { SourceBufferName } from '../types/buffer';
+import type {
+  BufferCreatedTrack,
+  ExtendedSourceBuffer,
+  SourceBufferName,
+} from '../types/buffer';
 import type { NetworkComponentAPI } from '../types/component-api';
 import type {
   AudioTrackSwitchedData,
@@ -56,7 +64,6 @@ export default class StreamController
   implements NetworkComponentAPI
 {
   private audioCodecSwap: boolean = false;
-  private gapController: GapController | null = null;
   private level: number = -1;
   private _forceStartLoad: boolean = false;
   private _hasEnoughToStart: boolean = false;
@@ -67,7 +74,7 @@ export default class StreamController
   private couldBacktrack: boolean = false;
   private backtrackFragment: Fragment | null = null;
   private audioCodecSwitch: boolean = false;
-  private videoBuffer: any | null = null;
+  private videoBuffer: ExtendedSourceBuffer | null = null;
 
   constructor(
     hls: Hls,
@@ -123,7 +130,7 @@ export default class StreamController
 
   protected onHandlerDestroying() {
     // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = this.onMediaWaiting = null;
+    this.onMediaPlaying = this.onMediaSeeked = null;
     this.unregisterListeners();
     super.onHandlerDestroying();
   }
@@ -230,7 +237,9 @@ export default class StreamController
 
   protected onTickEnd() {
     super.onTickEnd();
-    this.checkBuffer();
+    if (this.media?.readyState) {
+      this.lastCurrentTime = this.media.currentTime;
+    }
     this.checkFragmentChanged();
   }
 
@@ -533,17 +542,8 @@ export default class StreamController
   ) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    media.removeEventListener('playing', this.onMediaPlaying);
-    media.removeEventListener('seeked', this.onMediaSeeked);
-    media.removeEventListener('waiting', this.onMediaWaiting);
-    media.addEventListener('playing', this.onMediaPlaying);
-    media.addEventListener('seeked', this.onMediaSeeked);
-    media.addEventListener('waiting', this.onMediaWaiting);
-    this.gapController = new GapController(
-      media,
-      this.fragmentTracker,
-      this.hls,
-    );
+    addEventListener(media, 'playing', this.onMediaPlaying);
+    addEventListener(media, 'seeked', this.onMediaSeeked);
   }
 
   protected onMediaDetaching(
@@ -552,16 +552,11 @@ export default class StreamController
   ) {
     const { media } = this;
     if (media) {
-      media.removeEventListener('playing', this.onMediaPlaying);
-      media.removeEventListener('seeked', this.onMediaSeeked);
-      media.removeEventListener('waiting', this.onMediaWaiting);
+      removeEventListener(media, 'playing', this.onMediaPlaying);
+      removeEventListener(media, 'seeked', this.onMediaSeeked);
     }
     this.videoBuffer = null;
     this.fragPlaying = null;
-    if (this.gapController) {
-      this.gapController.destroy();
-      this.gapController = null;
-    }
     super.onMediaDetaching(event, data);
     const transferringMedia = !!data.transferMedia;
     if (transferringMedia) {
@@ -570,20 +565,8 @@ export default class StreamController
     this._hasEnoughToStart = false;
   }
 
-  private onMediaWaiting = () => {
-    const gapController = this.gapController;
-    if (gapController) {
-      gapController.waiting = self.performance.now();
-    }
-  };
-
   private onMediaPlaying = () => {
     // tick to speed up FRAG_CHANGED triggering
-    const gapController = this.gapController;
-    if (gapController) {
-      gapController.ended = 0;
-      gapController.waiting = 0;
-    }
     this.tick();
   };
 
@@ -609,19 +592,6 @@ export default class StreamController
     this.tick();
   };
 
-  protected triggerEnded() {
-    const gapController = this.gapController;
-    if (gapController) {
-      if (gapController.ended) {
-        return;
-      }
-      gapController.ended = this.media?.currentTime || 1;
-    }
-    this.hls.trigger(Events.MEDIA_ENDED, {
-      stalled: false,
-    });
-  }
-
   protected onManifestLoading() {
     super.onManifestLoading();
     // reset buffer on manifest loading
@@ -935,11 +905,11 @@ export default class StreamController
     data: BufferCreatedData,
   ) {
     const tracks = data.tracks;
-    let mediaTrack;
-    let name;
+    let mediaTrack: BufferCreatedTrack | undefined;
+    let name: string | undefined;
     let alternate = false;
     for (const type in tracks) {
-      const track = tracks[type];
+      const track: BufferCreatedTrack = tracks[type];
       if (track.id === 'main') {
         name = type;
         mediaTrack = track;
@@ -1056,25 +1026,6 @@ export default class StreamController
     }
   }
 
-  // Checks the health of the buffer and attempts to resolve playback stalls.
-  private checkBuffer() {
-    const { media, gapController } = this;
-    if (!media || !gapController || !media.readyState) {
-      // Exit early if we don't have media or if the media hasn't buffered anything yet (readyState 0)
-      return;
-    }
-
-    if (this._hasEnoughToStart || !BufferHelper.getBuffered(media).length) {
-      // Resolve gaps using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
-      const state = this.state;
-      const activeFrag = state !== State.IDLE ? this.fragCurrent : null;
-      const levelDetails = this.getLevelDetails();
-      gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
-    }
-
-    this.lastCurrentTime = media.currentTime;
-  }
-
   private onFragLoadEmergencyAborted() {
     this.state = State.IDLE;
     // if loadedmetadata is not set, it means that we are emergency switch down on first frag
@@ -1095,8 +1046,10 @@ export default class StreamController
         (type === ElementaryStreamTypes.VIDEO
           ? this.videoBuffer
           : this.mediaBuffer) || this.media;
-      this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.MAIN);
-      this.tick();
+      if (mediaBuffer) {
+        this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.MAIN);
+        this.tick();
+      }
     }
   }
 

package/src/hls.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from 'eventemitter3';
 import { buildAbsoluteURL } from 'url-toolkit';
 import { enableStreamingMode, hlsDefaultConfig, mergeConfig } from './config';
 import { FragmentTracker } from './controller/fragment-tracker';
+import GapController from './controller/gap-controller';
 import ID3TrackController from './controller/id3-track-controller';
 import LatencyController from './controller/latency-controller';
 import LevelController from './controller/level-controller';
@@ -14,6 +15,7 @@ import KeyLoader from './loader/key-loader';
 import PlaylistLoader from './loader/playlist-loader';
 import { MetadataSchema } from './types/demuxer';
 import { type HdcpLevel, isHdcpLevel, type Level } from './types/level';
+import { PlaylistLevelType } from './types/loader';
 import { enableLogs, type ILogger } from './utils/logger';
 import { getMediaDecodingInfoPromise } from './utils/mediacapabilities-helper';
 import { getMediaSource } from './utils/mediasource-helper';
@@ -24,6 +26,7 @@ import type AbrController from './controller/abr-controller';
 import type AudioStreamController from './controller/audio-stream-controller';
 import type AudioTrackController from './controller/audio-track-controller';
 import type BasePlaylistController from './controller/base-playlist-controller';
+import type { InFlightData, State } from './controller/base-stream-controller';
 import type BaseStreamController from './controller/base-stream-controller';
 import type BufferController from './controller/buffer-controller';
 import type CapLevelController from './controller/cap-level-controller';
@@ -34,6 +37,7 @@ import type ErrorController from './controller/error-controller';
 import type FPSController from './controller/fps-controller';
 import type InterstitialsController from './controller/interstitials-controller';
 import type { InterstitialsManager } from './controller/interstitials-controller';
+import type { SubtitleStreamController } from './controller/subtitle-stream-controller';
 import type SubtitleTrackController from './controller/subtitle-track-controller';
 import type Decrypter from './crypt/decrypter';
 import type TransmuxerInterface from './demux/transmuxer-interface';
@@ -91,9 +95,12 @@ export default class Hls implements HlsEventEmitter {
   private latencyController: LatencyController;
   private levelController: LevelController;
   private streamController: StreamController;
+  private audioStreamController?: AudioStreamController;
+  private subtititleStreamController?: SubtitleStreamController;
   private audioTrackController?: AudioTrackController;
   private subtitleTrackController?: SubtitleTrackController;
   private interstitialsController?: InterstitialsController;
+  private gapController: GapController;
   private emeController?: EMEController;
   private cmcdController?: CMCDController;
   private _media: HTMLMediaElement | null = null;
@@ -229,6 +236,11 @@ export default class Hls implements HlsEventEmitter {
       keyLoader,
     ));
 
+    const gapController = (this.gapController = new GapController(
+      this,
+      fragmentTracker,
+    ));
+
     // Cap level controller uses streamController to flush the buffer
     capLevelController.setStreamController(streamController);
     // fpsController uses streamController to switch when frames are being dropped
@@ -250,6 +262,7 @@ export default class Hls implements HlsEventEmitter {
     const coreComponents: ComponentAPI[] = [
       abrController,
       bufferController,
+      gapController,
       capLevelController,
       fpsController,
       id3TrackController,
@@ -263,7 +276,11 @@ export default class Hls implements HlsEventEmitter {
     const AudioStreamControllerClass = config.audioStreamController;
     if (AudioStreamControllerClass) {
       networkControllers.push(
-        new AudioStreamControllerClass(this, fragmentTracker, keyLoader),
+        (this.audioStreamController = new AudioStreamControllerClass(
+          this,
+          fragmentTracker,
+          keyLoader,
+        )),
       );
     }
     // Instantiate subtitleTrackController before SubtitleStreamController to receive level events first
@@ -274,7 +291,11 @@ export default class Hls implements HlsEventEmitter {
     const SubtitleStreamControllerClass = config.subtitleStreamController;
     if (SubtitleStreamControllerClass) {
       networkControllers.push(
-        new SubtitleStreamControllerClass(this, fragmentTracker, keyLoader),
+        (this.subtititleStreamController = new SubtitleStreamControllerClass(
+          this,
+          fragmentTracker,
+          keyLoader,
+        )),
       );
     }
     this.createController(config.timelineController, coreComponents);
@@ -604,6 +625,21 @@ export default class Hls implements HlsEventEmitter {
     }
   }
 
+  get inFlightFragments(): InFlightFragments {
+    const inFlightData = {
+      [PlaylistLevelType.MAIN]: this.streamController.inFlightFrag,
+    };
+    if (this.audioStreamController) {
+      inFlightData[PlaylistLevelType.AUDIO] =
+        this.audioStreamController.inFlightFrag;
+    }
+    if (this.subtititleStreamController) {
+      inFlightData[PlaylistLevelType.SUBTITLE] =
+        this.subtititleStreamController.inFlightFrag;
+    }
+    return inFlightData;
+  }
+
   /**
    * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
    */
@@ -1181,6 +1217,11 @@ export default class Hls implements HlsEventEmitter {
   }
 }
 
+export type InFlightFragments = {
+  [PlaylistLevelType.MAIN]: InFlightData;
+  [PlaylistLevelType.AUDIO]?: InFlightData;
+  [PlaylistLevelType.SUBTITLE]?: InFlightData;
+};
 export type {
   AudioSelectionOption,
   SubtitleSelectionOption,
@@ -1211,6 +1252,7 @@ export type {
   FPSController,
   InterstitialsController,
   StreamController,
+  SubtitleStreamController,
   SubtitleTrackController,
   EwmaBandWidthEstimator,
   InterstitialsManager,
@@ -1219,6 +1261,8 @@ export type {
   KeyLoader,
   TaskLoop,
   TransmuxerInterface,
+  InFlightData,
+  State,
 };
 export type {
   ABRControllerConfig,
@@ -1232,6 +1276,7 @@ export type {
   FPSControllerConfig,
   FragmentLoaderConfig,
   FragmentLoaderConstructor,
+  GapControllerConfig,
   HlsLoadPolicies,
   LevelControllerConfig,
   LoaderConfig,
@@ -1270,7 +1315,6 @@ export type {
   InterstitialScheduleItem,
   InterstitialSchedulePrimaryItem,
 } from './controller/interstitials-schedule';
-export type { SubtitleStreamController } from './controller/subtitle-stream-controller';
 export type { TimelineController } from './controller/timeline-controller';
 export type { DecrypterAesMode } from './crypt/decrypter-aes-mode';
 export type { DateRange, DateRangeCue } from './loader/date-range';

package/src/utils/buffer-helper.ts

@@ -23,6 +23,7 @@ export type BufferInfo = {
   end: number;
   nextStart?: number;
   buffered?: BufferTimeRange[];
+  bufferedIndex: number;
 };
 
 const noopBuffered: TimeRanges = {
@@ -47,22 +48,34 @@ export class BufferHelper {
     return false;
   }
 
+  static bufferedRanges(media: Bufferable | null): BufferTimeRange[] {
+    if (media) {
+      const timeRanges = BufferHelper.getBuffered(media);
+      return BufferHelper.timeRangesToArray(timeRanges);
+    }
+    return [];
+  }
+
+  static timeRangesToArray(timeRanges: TimeRanges): BufferTimeRange[] {
+    const buffered: BufferTimeRange[] = [];
+    for (let i = 0; i < timeRanges.length; i++) {
+      buffered.push({ start: timeRanges.start(i), end: timeRanges.end(i) });
+    }
+    return buffered;
+  }
+
   static bufferInfo(
     media: Bufferable | null,
     pos: number,
     maxHoleDuration: number,
   ): BufferInfo {
     if (media) {
-      const vbuffered = BufferHelper.getBuffered(media);
-      if (vbuffered.length) {
-        const buffered: BufferTimeRange[] = [];
-        for (let i = 0; i < vbuffered.length; i++) {
-          buffered.push({ start: vbuffered.start(i), end: vbuffered.end(i) });
-        }
+      const buffered = BufferHelper.bufferedRanges(media);
+      if (buffered.length) {
         return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
       }
     }
-    return { len: 0, start: pos, end: pos };
+    return { len: 0, start: pos, end: pos, bufferedIndex: -1 };
   }
 
   static bufferedInfo(
@@ -72,14 +85,20 @@ export class BufferHelper {
   ): BufferInfo {
     pos = Math.max(0, pos);
     // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
-    buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    if (buffered.length > 1) {
+      buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    }
 
+    let bufferedIndex: number = -1;
     let buffered2: BufferTimeRange[] = [];
     if (maxHoleDuration) {
       // there might be some small holes between buffer time range
       // consider that holes smaller than maxHoleDuration are irrelevant and build another
       // buffer time range representations that discards those holes
       for (let i = 0; i < buffered.length; i++) {
+        if (pos >= buffered[i].start && pos <= buffered[i].end) {
+          bufferedIndex = i;
+        }
         const buf2len = buffered2.length;
         if (buf2len) {
           const buf2end = buffered2[buf2len - 1].end;
@@ -107,23 +126,25 @@ export class BufferHelper {
 
     let bufferLen = 0;
 
-    // bufferStartNext can possibly be undefined based on the conditional logic below
-    let bufferStartNext: number | undefined;
+    let nextStart: number | undefined;
 
-    // bufferStart and bufferEnd are buffer boundaries around current video position
+    // bufferStart and bufferEnd are buffer boundaries around current playback position (pos)
     let bufferStart: number = pos;
     let bufferEnd: number = pos;
     for (let i = 0; i < buffered2.length; i++) {
       const start = buffered2[i].start;
       const end = buffered2[i].end;
       // logger.log('buf start/end:' + buffered.start(i) + '/' + buffered.end(i));
+      if (bufferedIndex === -1 && pos >= start && pos <= end) {
+        bufferedIndex = i;
+      }
       if (pos + maxHoleDuration >= start && pos < end) {
         // play position is inside this buffer TimeRange, retrieve end of buffer position and buffer length
         bufferStart = start;
         bufferEnd = end;
         bufferLen = bufferEnd - pos;
       } else if (pos + maxHoleDuration < start) {
-        bufferStartNext = start;
+        nextStart = start;
         break;
       }
     }
@@ -131,8 +152,9 @@ export class BufferHelper {
       len: bufferLen,
       start: bufferStart || 0,
       end: bufferEnd || 0,
-      nextStart: bufferStartNext,
+      nextStart,
       buffered,
+      bufferedIndex,
     };
   }
 

package/src/utils/event-listener-helper.ts

@@ -0,0 +1,16 @@
+export function addEventListener(
+  el: HTMLElement,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+) {
+  removeEventListener(el, type, listener);
+  el.addEventListener(type, listener);
+}
+
+export function removeEventListener(
+  el: HTMLElement,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+) {
+  el.removeEventListener(type, listener);
+}