hls.js 1.5.14-0.canary.10515 → 1.5.14

package/src/controller/level-controller.ts

@@ -1,4 +1,4 @@
-import type {
+import {
   ManifestLoadedData,
   ManifestParsedData,
   LevelLoadedData,
@@ -27,6 +27,8 @@ import type Hls from '../hls';
 import type { HlsUrlParameters, LevelParsed } from '../types/level';
 import type { MediaPlaylist } from '../types/media-playlist';
 
+let chromeOrFirefox: boolean;
+
 export default class LevelController extends BasePlaylistController {
   private _levels: Level[] = [];
   private _firstLevel: number = -1;
@@ -43,7 +45,7 @@ export default class LevelController extends BasePlaylistController {
     hls: Hls,
     contentSteeringController: ContentSteeringController | null,
   ) {
-    super(hls, 'level-controller');
+    super(hls, '[level-controller]');
     this.steering = contentSteeringController;
     this._registerListeners();
   }
@@ -117,12 +119,22 @@ export default class LevelController extends BasePlaylistController {
 
     data.levels.forEach((levelParsed: LevelParsed) => {
       const attributes = levelParsed.attrs;
+
+      // erase audio codec info if browser does not support mp4a.40.34.
+      // demuxer will autodetect codec and fallback to mpeg/audio
       let { audioCodec, videoCodec } = levelParsed;
+      if (audioCodec?.indexOf('mp4a.40.34') !== -1) {
+        chromeOrFirefox ||= /chrome|firefox/i.test(navigator.userAgent);
+        if (chromeOrFirefox) {
+          levelParsed.audioCodec = audioCodec = undefined;
+        }
+      }
+
       if (audioCodec) {
-        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
-        levelParsed.audioCodec = audioCodec =
-          getCodecCompatibleName(audioCodec, preferManagedMediaSource) ||
-          undefined;
+        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(
+          audioCodec,
+          preferManagedMediaSource,
+        );
       }
 
       if (videoCodec?.indexOf('avc1') === 0) {
@@ -509,30 +521,6 @@ export default class LevelController extends BasePlaylistController {
     this._startLevel = newLevel;
   }
 
-  get pathwayPriority(): string[] | null {
-    if (this.steering) {
-      return this.steering.pathwayPriority;
-    }
-
-    return null;
-  }
-
-  set pathwayPriority(pathwayPriority: string[]) {
-    if (this.steering) {
-      const pathwaysList = this.steering.pathways();
-      const filteredPathwayPriority = pathwayPriority.filter((pathwayId) => {
-        return pathwaysList.indexOf(pathwayId) !== -1;
-      });
-      if (pathwayPriority.length < 1) {
-        this.warn(
-          `pathwayPriority ${pathwayPriority} should contain at least one pathway from list: ${pathwaysList}`,
-        );
-        return;
-      }
-      this.steering.pathwayPriority = filteredPathwayPriority;
-    }
-  }
-
   protected onError(event: Events.ERROR, data: ErrorData) {
     if (data.fatal || !data.context) {
       return;
@@ -584,13 +572,7 @@ export default class LevelController extends BasePlaylistController {
       if (curLevel.fragmentError === 0) {
         curLevel.loadError = 0;
       }
-      // Ignore matching details populated by loading a Media Playlist directly
-      let previousDetails = curLevel.details;
-      if (previousDetails === data.details && previousDetails.advanced) {
-        previousDetails = undefined;
-      }
-
-      this.playlistLoaded(level, data, previousDetails);
+      this.playlistLoaded(level, data, curLevel.details);
     } else if (data.deliveryDirectives?.skip) {
       // received a delta playlist update that cannot be merged
       details.deltaUpdateFailed = true;

package/src/controller/stream-controller.ts

@@ -2,14 +2,9 @@ import BaseStreamController, { State } from './base-stream-controller';
 import { changeTypeSupported } from '../is-supported';
 import { Events } from '../events';
 import { BufferHelper, BufferInfo } from '../utils/buffer-helper';
-import { findFragmentByPTS } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
 import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
-import {
-  ElementaryStreamTypes,
-  Fragment,
-  MediaFragment,
-} from '../loader/fragment';
+import { ElementaryStreamTypes, Fragment } from '../loader/fragment';
 import TransmuxerInterface from '../demux/transmuxer-interface';
 import { ChunkMetadata } from '../types/transmuxer';
 import GapController, { MAX_START_GAP_JUMP } from './gap-controller';
@@ -17,15 +12,15 @@ import { ErrorDetails } from '../errors';
 import type { NetworkComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 import type { Level } from '../types/level';
+import type { LevelDetails } from '../loader/level-details';
 import type { FragmentTracker } from './fragment-tracker';
 import type KeyLoader from '../loader/key-loader';
 import type { TransmuxerResult } from '../types/transmuxer';
-import type { Track, TrackSet } from '../types/track';
+import type { TrackSet } from '../types/track';
 import type { SourceBufferName } from '../types/buffer';
 import type {
   AudioTrackSwitchedData,
   AudioTrackSwitchingData,
-  BufferCodecsData,
   BufferCreatedData,
   BufferEOSData,
   BufferFlushedData,
@@ -54,6 +49,8 @@ export default class StreamController
   private altAudio: boolean = false;
   private audioOnly: boolean = false;
   private fragPlaying: Fragment | null = null;
+  private onvplaying: EventListener | null = null;
+  private onvseeked: EventListener | null = null;
   private fragLastKbps: number = 0;
   private couldBacktrack: boolean = false;
   private backtrackFragment: Fragment | null = null;
@@ -69,15 +66,17 @@ export default class StreamController
       hls,
       fragmentTracker,
       keyLoader,
-      'stream-controller',
+      '[stream-controller]',
       PlaylistLevelType.MAIN,
     );
-    this.registerListeners();
+    this._registerListeners();
   }
 
-  protected registerListeners() {
-    super.registerListeners();
+  private _registerListeners() {
     const { hls } = this;
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
@@ -86,6 +85,7 @@ export default class StreamController
       this.onFragLoadEmergencyAborted,
       this,
     );
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.on(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -94,9 +94,11 @@ export default class StreamController
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
 
-  protected unregisterListeners() {
-    super.unregisterListeners();
+  protected _unregisterListeners() {
     const { hls } = this;
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.off(
@@ -104,6 +106,7 @@ export default class StreamController
       this.onFragLoadEmergencyAborted,
       this,
     );
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.off(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -113,9 +116,7 @@ export default class StreamController
   }
 
   protected onHandlerDestroying() {
-    // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = null;
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
   }
 
@@ -219,9 +220,6 @@ export default class StreamController
   }
 
   private doTickIdle() {
-    if (!this.buffering) {
-      return;
-    }
     const { hls, levelLastLoaded, levels, media } = this;
 
     // if start level not parsed yet OR
@@ -365,6 +363,7 @@ export default class StreamController
   ) {
     // Check if fragment is not loaded
     const fragState = this.fragmentTracker.getState(frag);
+    this.fragCurrent = frag;
     if (
       fragState === FragmentState.NOT_LOADED ||
       fragState === FragmentState.PARTIAL
@@ -377,6 +376,7 @@ export default class StreamController
         );
         this._loadBitrateTestFrag(frag, level);
       } else {
+        this.startFragRequested = true;
         super.loadFragment(frag, level, targetBufferTime);
       }
     } else {
@@ -516,8 +516,10 @@ export default class StreamController
   ) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    media.addEventListener('playing', this.onMediaPlaying);
-    media.addEventListener('seeked', this.onMediaSeeked);
+    this.onvplaying = this.onMediaPlaying.bind(this);
+    this.onvseeked = this.onMediaSeeked.bind(this);
+    media.addEventListener('playing', this.onvplaying as EventListener);
+    media.addEventListener('seeked', this.onvseeked as EventListener);
     this.gapController = new GapController(
       this.config,
       media,
@@ -528,11 +530,12 @@ export default class StreamController
 
   protected onMediaDetaching() {
     const { media } = this;
-    if (media) {
-      media.removeEventListener('playing', this.onMediaPlaying);
-      media.removeEventListener('seeked', this.onMediaSeeked);
+    if (media && this.onvplaying && this.onvseeked) {
+      media.removeEventListener('playing', this.onvplaying);
+      media.removeEventListener('seeked', this.onvseeked);
+      this.onvplaying = this.onvseeked = null;
+      this.videoBuffer = null;
     }
-    this.videoBuffer = null;
     this.fragPlaying = null;
     if (this.gapController) {
       this.gapController.destroy();
@@ -541,12 +544,12 @@ export default class StreamController
     super.onMediaDetaching();
   }
 
-  private onMediaPlaying = () => {
+  private onMediaPlaying() {
     // tick to speed up FRAG_CHANGED triggering
     this.tick();
-  };
+  }
 
-  private onMediaSeeked = () => {
+  private onMediaSeeked() {
     const media = this.media;
     const currentTime = media ? media.currentTime : null;
     if (Number.isFinite(currentTime)) {
@@ -566,17 +569,21 @@ export default class StreamController
 
     // tick to speed up FRAG_CHANGED triggering
     this.tick();
-  };
+  }
 
-  protected onManifestLoading() {
-    super.onManifestLoading();
+  private onManifestLoading() {
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
     this.hls.trigger(Events.BUFFER_RESET, undefined);
+    this.fragmentTracker.removeAllFragments();
     this.couldBacktrack = false;
-    this.fragLastKbps = 0;
-    this.fragPlaying = this.backtrackFragment = null;
-    this.altAudio = this.audioOnly = false;
+    this.startPosition = this.lastCurrentTime = this.fragLastKbps = 0;
+    this.levels =
+      this.fragPlaying =
+      this.backtrackFragment =
+      this.levelLastLoaded =
+        null;
+    this.altAudio = this.audioOnly = this.startFragRequested = false;
   }
 
   private onManifestParsed(
@@ -690,8 +697,7 @@ export default class StreamController
   }
 
   protected _handleFragmentLoadProgress(data: FragLoadedData) {
-    const frag = data.frag as MediaFragment;
-    const { part, payload } = data;
+    const { frag, part, payload } = data;
     const { levels } = this;
     if (!levels) {
       this.warn(
@@ -700,7 +706,7 @@ export default class StreamController
       return;
     }
     const currentLevel = levels[frag.level];
-    const details = currentLevel.details;
+    const details = currentLevel.details as LevelDetails;
     if (!details) {
       this.warn(
         `Dropping fragment ${frag.sn} of level ${frag.level} after level details were reset`,
@@ -729,7 +735,7 @@ export default class StreamController
     const partial = partIndex !== -1;
     const chunkMeta = new ChunkMetadata(
       frag.level,
-      frag.sn,
+      frag.sn as number,
       frag.stats.chunkCount,
       payload.byteLength,
       partIndex,
@@ -873,12 +879,12 @@ export default class StreamController
       (8 * stats.total) / (stats.buffering.end - stats.loading.first),
     );
     if (frag.sn !== 'initSegment') {
-      this.fragPrevious = frag as MediaFragment;
+      this.fragPrevious = frag;
     }
     this.fragBufferedComplete(frag, part);
   }
 
-  protected onError(event: Events.ERROR, data: ErrorData) {
+  private onError(event: Events.ERROR, data: ErrorData) {
     if (data.fatal) {
       this.state = State.ERROR;
       return;
@@ -936,10 +942,8 @@ export default class StreamController
 
     if (this.loadedmetadata || !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);
+      const activeFrag = this.state !== State.IDLE ? this.fragCurrent : null;
+      gapController.poll(this.lastCurrentTime, activeFrag);
     }
 
     this.lastCurrentTime = media.currentTime;
@@ -951,7 +955,7 @@ export default class StreamController
     // in that case, reset startFragRequested flag
     if (!this.loadedmetadata) {
       this.startFragRequested = false;
-      this.nextLoadPosition = this.lastCurrentTime;
+      this.nextLoadPosition = this.startPosition;
     }
     this.tickImmediate();
   }
@@ -1063,7 +1067,7 @@ export default class StreamController
   }
 
   private _handleTransmuxComplete(transmuxResult: TransmuxerResult) {
-    const id = this.playlistType;
+    const id = 'main';
     const { hls } = this;
     const { remuxResult, chunkMeta } = transmuxResult;
 
@@ -1113,7 +1117,7 @@ export default class StreamController
     }
 
     // Avoid buffering if backtracking this fragment
-    if (video && details) {
+    if (video && details && frag.sn !== 'initSegment') {
       const prevFrag = details.fragments[frag.sn - 1 - details.startSN];
       const isFirstFragment = frag.sn === details.startSN;
       const isFirstInDiscontinuity = !prevFrag || frag.cc > prevFrag.cc;
@@ -1303,7 +1307,6 @@ export default class StreamController
           currentLevel.audioCodec || ''
         }/${audio.codec}]`,
       );
-      delete tracks.audiovideo;
     }
     if (video) {
       video.levelCodec = currentLevel.videoCodec;
@@ -1315,34 +1318,28 @@ export default class StreamController
           video.codec
         }]`,
       );
-      delete tracks.audiovideo;
     }
     if (audiovideo) {
       this.log(
         `Init audiovideo buffer, container:${audiovideo.container}, codecs[level/parsed]=[${currentLevel.codecs}/${audiovideo.codec}]`,
       );
-      delete tracks.video;
-      delete tracks.audio;
-    }
-    const trackTypes = Object.keys(tracks);
-    if (trackTypes.length) {
-      this.hls.trigger(Events.BUFFER_CODECS, tracks as BufferCodecsData);
-      // loop through tracks that are going to be provided to bufferController
-      trackTypes.forEach((trackName) => {
-        const track = tracks[trackName] as Track;
-        const initSegment = track.initSegment;
-        if (initSegment?.byteLength) {
-          this.hls.trigger(Events.BUFFER_APPENDING, {
-            type: trackName as SourceBufferName,
-            data: initSegment,
-            frag,
-            part: null,
-            chunkMeta,
-            parent: frag.type,
-          });
-        }
-      });
     }
+    this.hls.trigger(Events.BUFFER_CODECS, tracks);
+    // loop through tracks that are going to be provided to bufferController
+    Object.keys(tracks).forEach((trackName) => {
+      const track = tracks[trackName];
+      const initSegment = track.initSegment;
+      if (initSegment?.byteLength) {
+        this.hls.trigger(Events.BUFFER_APPENDING, {
+          type: trackName as SourceBufferName,
+          data: initSegment,
+          frag,
+          part: null,
+          chunkMeta,
+          parent: frag.type,
+        });
+      }
+    });
     // trigger handler right now
     this.tickImmediate();
   }
@@ -1354,15 +1351,6 @@ export default class StreamController
     );
   }
 
-  public get maxBufferLength(): number {
-    const { levels, level } = this;
-    const levelInfo = levels?.[level];
-    if (!levelInfo) {
-      return this.config.maxBufferLength;
-    }
-    return this.getMaxBufferLength(levelInfo.maxBitrate);
-  }
-
   private backtrack(frag: Fragment) {
     this.couldBacktrack = true;
     // Causes findFragments to backtrack through fragments to find the keyframe
@@ -1427,31 +1415,26 @@ export default class StreamController
   }
 
   get currentFrag(): Fragment | null {
-    if (this.fragPlaying) {
-      return this.fragPlaying;
-    }
-    const currentTime = this.media?.currentTime || this.lastCurrentTime;
-    if (Number.isFinite(currentTime)) {
-      return this.getAppendedFrag(currentTime);
+    const media = this.media;
+    if (media) {
+      return this.fragPlaying || this.getAppendedFrag(media.currentTime);
     }
     return null;
   }
 
   get currentProgramDateTime(): Date | null {
-    const currentTime = this.media?.currentTime || this.lastCurrentTime;
-    if (Number.isFinite(currentTime)) {
-      const details = this.getLevelDetails();
-      const frag =
-        this.currentFrag ||
-        (details
-          ? findFragmentByPTS(null, details.fragments, currentTime)
-          : null);
-      if (frag) {
-        const programDateTime = frag.programDateTime;
-        if (programDateTime !== null) {
-          const epocMs = programDateTime + (currentTime - frag.start) * 1000;
-          return new Date(epocMs);
-        }
+    const media = this.media;
+    if (media) {
+      const currentTime = media.currentTime;
+      const frag = this.currentFrag;
+      if (
+        frag &&
+        Number.isFinite(currentTime) &&
+        Number.isFinite(frag.programDateTime)
+      ) {
+        const epocMs =
+          (frag.programDateTime as number) + (currentTime - frag.start) * 1000;
+        return new Date(epocMs);
       }
     }
     return null;