hls.js 1.5.7-0.canary.10042 → 1.5.7

package/src/controller/buffer-controller.ts

@@ -1,5 +1,5 @@
 import { Events } from '../events';
-import { Logger } from '../utils/logger';
+import { logger } from '../utils/logger';
 import { ErrorDetails, ErrorTypes } from '../errors';
 import { BufferHelper } from '../utils/buffer-helper';
 import {
@@ -7,12 +7,7 @@ import {
   pickMostCompleteCodecName,
 } from '../utils/codecs';
 import { getMediaSource } from '../utils/mediasource-helper';
-import {
-  ElementaryStreamTypes,
-  type Part,
-  type Fragment,
-} from '../loader/fragment';
-import { PlaylistLevelType } from '../types/loader';
+import { ElementaryStreamTypes } from '../loader/fragment';
 import type { TrackSet } from '../types/track';
 import BufferOperationQueue from './buffer-operation-queue';
 import {
@@ -36,7 +31,6 @@ import type {
 import type { ComponentAPI } from '../types/component-api';
 import type { ChunkMetadata } from '../types/transmuxer';
 import type Hls from '../hls';
-import type { FragmentTracker } from './fragment-tracker';
 import type { LevelDetails } from '../loader/level-details';
 import type { HlsConfig } from '../config';
 
@@ -48,7 +42,7 @@ interface BufferedChangeEvent extends Event {
   readonly removedRanges?: TimeRanges;
 }
 
-export default class BufferController extends Logger implements ComponentAPI {
+export default class BufferController implements ComponentAPI {
   // The level details used to determine duration, target-duration and live
   private details: LevelDetails | null = null;
   // cache the self generated object url to detect hijack of video tag
@@ -59,7 +53,6 @@ export default class BufferController extends Logger implements ComponentAPI {
   private listeners!: SourceBufferListeners;
 
   private hls: Hls;
-  private fragmentTracker: FragmentTracker;
 
   // The number of BUFFER_CODEC events received before any sourceBuffers are created
   public bufferCodecEventsExpected: number = 0;
@@ -76,14 +69,6 @@ export default class BufferController extends Logger implements ComponentAPI {
   // Last MP3 audio chunk appended
   private lastMpegAudioChunk: ChunkMetadata | null = null;
 
-  // Audio fragment blocked from appending until corresponding video appends or context changes
-  private blockedAudioAppend: {
-    op: BufferOperation;
-    frag: Fragment | Part;
-  } | null = null;
-  // Keep track of video append position for unblocking audio
-  private lastVideoAppendEnd: number = 0;
-
   private appendSource: boolean;
 
   // counters
@@ -97,11 +82,20 @@ export default class BufferController extends Logger implements ComponentAPI {
   public pendingTracks: TrackSet = {};
   public sourceBuffer!: SourceBuffers;
 
-  constructor(hls: Hls, fragmentTracker: FragmentTracker) {
-    super('buffer-controller', hls.logger);
+  protected log: (msg: any) => void;
+  protected warn: (msg: any, obj?: any) => void;
+  protected error: (msg: any, obj?: any) => void;
+
+  constructor(hls: Hls) {
     this.hls = hls;
-    this.fragmentTracker = fragmentTracker;
-    this.appendSource = hls.config.preferManagedMediaSource;
+    const logPrefix = '[buffer-controller]';
+    this.appendSource =
+      hls.config.preferManagedMediaSource &&
+      typeof self !== 'undefined' &&
+      (self as any).ManagedMediaSource;
+    this.log = logger.log.bind(logger, logPrefix);
+    this.warn = logger.warn.bind(logger, logPrefix);
+    this.error = logger.error.bind(logger, logPrefix);
     this._initSourceBuffer();
     this.registerListeners();
   }
@@ -118,13 +112,7 @@ export default class BufferController extends Logger implements ComponentAPI {
     this.details = null;
     this.lastMpegAudioChunk = null;
     // @ts-ignore
-    this.hls = this.fragmentTracker = null;
-    // @ts-ignore
-    this._onMediaSourceOpen = this._onMediaSourceClose = null;
-    // @ts-ignore
-    this._onMediaSourceEnded = null;
-    // @ts-ignore
-    this._onStartStreaming = this._onEndStreaming = null;
+    this.hls = null;
   }
 
   protected registerListeners() {
@@ -173,8 +161,6 @@ export default class BufferController extends Logger implements ComponentAPI {
       audiovideo: 0,
     };
     this.lastMpegAudioChunk = null;
-    this.blockedAudioAppend = null;
-    this.lastVideoAppendEnd = 0;
   }
 
   private onManifestLoading() {
@@ -211,8 +197,10 @@ export default class BufferController extends Logger implements ComponentAPI {
       ms.addEventListener('sourceopen', this._onMediaSourceOpen);
       ms.addEventListener('sourceended', this._onMediaSourceEnded);
       ms.addEventListener('sourceclose', this._onMediaSourceClose);
-      ms.addEventListener('startstreaming', this._onStartStreaming);
-      ms.addEventListener('endstreaming', this._onEndStreaming);
+      if (this.appendSource) {
+        ms.addEventListener('startstreaming', this._onStartStreaming);
+        ms.addEventListener('endstreaming', this._onEndStreaming);
+      }
 
       // cache the locally generated object url
       const objectUrl = (this._objectUrl = self.URL.createObjectURL(ms));
@@ -271,8 +259,13 @@ export default class BufferController extends Logger implements ComponentAPI {
       mediaSource.removeEventListener('sourceopen', this._onMediaSourceOpen);
       mediaSource.removeEventListener('sourceended', this._onMediaSourceEnded);
       mediaSource.removeEventListener('sourceclose', this._onMediaSourceClose);
-      mediaSource.removeEventListener('startstreaming', this._onStartStreaming);
-      mediaSource.removeEventListener('endstreaming', this._onEndStreaming);
+      if (this.appendSource) {
+        mediaSource.removeEventListener(
+          'startstreaming',
+          this._onStartStreaming,
+        );
+        mediaSource.removeEventListener('endstreaming', this._onEndStreaming);
+      }
 
       // Detach properly the MediaSource from the HTMLMediaElement as
       // suggested in https://github.com/w3c/media-source/issues/53.
@@ -313,7 +306,6 @@ export default class BufferController extends Logger implements ComponentAPI {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
-    this.hls.resumeBuffering();
   }
 
   private resetBuffer(type: SourceBufferName) {
@@ -339,11 +331,11 @@ export default class BufferController extends Logger implements ComponentAPI {
   ) {
     const sourceBufferCount = this.getSourceBufferTypes().length;
     const trackNames = Object.keys(data);
-    trackNames.forEach((trackName: SourceBufferName) => {
+    trackNames.forEach((trackName) => {
       if (sourceBufferCount) {
         // check if SourceBuffer codec needs to change
         const track = this.tracks[trackName];
-        if (track && typeof track.buffer?.changeType === 'function') {
+        if (track && typeof track.buffer.changeType === 'function') {
           const { id, codec, levelCodec, container, metadata } =
             data[trackName];
           const currentCodecFull = pickMostCompleteCodecName(
@@ -363,7 +355,7 @@ export default class BufferController extends Logger implements ComponentAPI {
             if (trackName.slice(0, 5) === 'audio') {
               trackCodec = getCodecCompatibleName(
                 trackCodec,
-                this.hls.config.preferManagedMediaSource,
+                this.appendSource,
               );
             }
             const mimeType = `${container};codecs=${trackCodec}`;
@@ -407,7 +399,7 @@ export default class BufferController extends Logger implements ComponentAPI {
     }
   }
 
-  protected appendChangeType(type: SourceBufferName, mimeType: string) {
+  protected appendChangeType(type, mimeType) {
     const { operationQueue } = this;
     const operation: BufferOperation = {
       execute: () => {
@@ -428,52 +420,14 @@ export default class BufferController extends Logger implements ComponentAPI {
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
 
-  private blockAudio(partOrFrag: Fragment | Part) {
-    const pStart = partOrFrag.start;
-    const pTime = pStart + partOrFrag.duration * 0.05;
-    const atGap =
-      this.fragmentTracker.getAppendedFrag(pStart, PlaylistLevelType.MAIN)
-        ?.gap === true;
-    if (atGap) {
-      return;
-    }
-    const op: BufferOperation = {
-      execute: () => {
-        if (
-          this.lastVideoAppendEnd > pTime ||
-          (this.sourceBuffer.video &&
-            BufferHelper.isBuffered(this.sourceBuffer.video, pTime)) ||
-          this.fragmentTracker.getAppendedFrag(pTime, PlaylistLevelType.MAIN)
-            ?.gap === true
-        ) {
-          this.blockedAudioAppend = null;
-          this.operationQueue.shiftAndExecuteNext('audio');
-        }
-      },
-      onStart: () => {},
-      onComplete: () => {},
-      onError: () => {},
-    };
-    this.blockedAudioAppend = { op, frag: partOrFrag };
-    this.operationQueue.append(op, 'audio', true);
-  }
-
-  private unblockAudio() {
-    const blockedAudioAppend = this.blockedAudioAppend;
-    if (blockedAudioAppend) {
-      this.blockedAudioAppend = null;
-      this.operationQueue.unblockAudio(blockedAudioAppend.op);
-    }
-  }
-
   protected onBufferAppending(
     event: Events.BUFFER_APPENDING,
     eventData: BufferAppendingData,
   ) {
-    const { operationQueue, tracks } = this;
-    const { data, type, parent, frag, part, chunkMeta } = eventData;
+    const { hls, operationQueue, tracks } = this;
+    const { data, type, frag, part, chunkMeta } = eventData;
     const chunkStats = chunkMeta.buffering[type];
-    const sn = frag.sn;
+
     const bufferAppendingStart = self.performance.now();
     chunkStats.start = bufferAppendingStart;
     const fragBuffering = frag.stats.buffering;
@@ -500,44 +454,7 @@ export default class BufferController extends Logger implements ComponentAPI {
       this.lastMpegAudioChunk = chunkMeta;
     }
 
-    // Block audio append until overlapping video append
-    const videoSb = this.sourceBuffer.video;
-    if (videoSb && sn !== 'initSegment') {
-      const partOrFrag = part || frag;
-      const blockedAudioAppend = this.blockedAudioAppend;
-      if (type === 'audio' && parent !== 'main' && !this.blockedAudioAppend) {
-        const pStart = partOrFrag.start;
-        const pTime = pStart + partOrFrag.duration * 0.05;
-        const vbuffered = videoSb.buffered;
-        const vappending = this.operationQueue.current('video');
-        if (!vbuffered.length && !vappending) {
-          // wait for video before appending audio
-          this.blockAudio(partOrFrag);
-        } else if (
-          !vappending &&
-          !BufferHelper.isBuffered(videoSb, pTime) &&
-          this.lastVideoAppendEnd < pTime
-        ) {
-          // audio is ahead of video
-          this.blockAudio(partOrFrag);
-        }
-      } else if (type === 'video') {
-        const videoAppendEnd = partOrFrag.end;
-        if (blockedAudioAppend) {
-          const audioStart = blockedAudioAppend.frag.start;
-          if (
-            videoAppendEnd > audioStart ||
-            videoAppendEnd < this.lastVideoAppendEnd ||
-            BufferHelper.isBuffered(videoSb, audioStart)
-          ) {
-            this.unblockAudio();
-          }
-        }
-        this.lastVideoAppendEnd = videoAppendEnd;
-      }
-    }
-
-    const fragStart = (part || frag).start;
+    const fragStart = frag.start;
     const operation: BufferOperation = {
       execute: () => {
         chunkStats.executeStart = self.performance.now();
@@ -547,7 +464,7 @@ export default class BufferController extends Logger implements ComponentAPI {
             const delta = fragStart - sb.timestampOffset;
             if (Math.abs(delta) >= 0.1) {
               this.log(
-                `Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${sn})`,
+                `Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${frag.sn})`,
               );
               sb.timestampOffset = fragStart;
             }
@@ -616,27 +533,30 @@ export default class BufferController extends Logger implements ComponentAPI {
             browser is able to evict some data from sourcebuffer. Retrying can help recover.
           */
           this.warn(
-            `Failed ${appendErrorCount}/${this.hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`,
+            `Failed ${appendErrorCount}/${hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`,
           );
-          if (appendErrorCount >= this.hls.config.appendErrorMaxRetry) {
+          if (appendErrorCount >= hls.config.appendErrorMaxRetry) {
             event.fatal = true;
           }
         }
-        this.hls.trigger(Events.ERROR, event);
+        hls.trigger(Events.ERROR, event);
       },
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
 
-  private getFlushOp(
-    type: SourceBufferName,
-    start: number,
-    end: number,
-  ): BufferOperation {
-    return {
-      execute: () => {
-        this.removeExecutor(type, start, end);
-      },
+  protected onBufferFlushing(
+    event: Events.BUFFER_FLUSHING,
+    data: BufferFlushingData,
+  ) {
+    const { operationQueue } = this;
+    const flushOperation = (type: SourceBufferName): BufferOperation => ({
+      execute: this.removeExecutor.bind(
+        this,
+        type,
+        data.startOffset,
+        data.endOffset,
+      ),
       onStart: () => {
         // logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
       },
@@ -647,26 +567,13 @@ export default class BufferController extends Logger implements ComponentAPI {
       onError: (error: Error) => {
         this.warn(`Failed to remove from ${type} SourceBuffer`, error);
       },
-    };
-  }
+    });
 
-  protected onBufferFlushing(
-    event: Events.BUFFER_FLUSHING,
-    data: BufferFlushingData,
-  ) {
-    const { operationQueue } = this;
-    const { type, startOffset, endOffset } = data;
-    if (type) {
-      operationQueue.append(
-        this.getFlushOp(type, startOffset, endOffset),
-        type,
-      );
+    if (data.type) {
+      operationQueue.append(flushOperation(data.type), data.type);
     } else {
-      this.getSourceBufferTypes().forEach((sbType: SourceBufferName) => {
-        operationQueue.append(
-          this.getFlushOp(sbType, startOffset, endOffset),
-          sbType,
-        );
+      this.getSourceBufferTypes().forEach((type: SourceBufferName) => {
+        operationQueue.append(flushOperation(type), type);
       });
     }
   }
@@ -719,9 +626,6 @@ export default class BufferController extends Logger implements ComponentAPI {
   // on BUFFER_EOS mark matching sourcebuffer(s) as ended and trigger checkEos()
   // an undefined data.type will mark all buffers as EOS.
   protected onBufferEos(event: Events.BUFFER_EOS, data: BufferEOSData) {
-    if (data.type === 'video') {
-      this.unblockAudio();
-    }
     const ended = this.getSourceBufferTypes().reduce((acc, type) => {
       const sb = this.sourceBuffer[type];
       if (sb && (!data.type || data.type === type)) {
@@ -767,14 +671,11 @@ export default class BufferController extends Logger implements ComponentAPI {
       return;
     }
     this.details = details;
-    const durationAndRange = this.getDurationAndRange();
-    if (!durationAndRange) {
-      return;
-    }
+
     if (this.getSourceBufferTypes().length) {
-      this.blockBuffers(() => this.updateMediaSource(durationAndRange));
+      this.blockBuffers(this.updateMediaElementDuration.bind(this));
     } else {
-      this.updateMediaSource(durationAndRange);
+      this.updateMediaElementDuration();
     }
   }
 
@@ -926,18 +827,14 @@ export default class BufferController extends Logger implements ComponentAPI {
    * 'liveDurationInfinity` is set to `true`
    * More details: https://github.com/video-dev/hls.js/issues/355
    */
-  private getDurationAndRange(): {
-    duration: number;
-    start?: number;
-    end?: number;
-  } | null {
+  private updateMediaElementDuration() {
     if (
       !this.details ||
       !this.media ||
       !this.mediaSource ||
       this.mediaSource.readyState !== 'open'
     ) {
-      return null;
+      return;
     }
     const { details, hls, media, mediaSource } = this;
     const levelDuration = details.fragments[0].start + details.totalduration;
@@ -949,47 +846,31 @@ export default class BufferController extends Logger implements ComponentAPI {
     if (details.live && hls.config.liveDurationInfinity) {
       // Override duration to Infinity
       mediaSource.duration = Infinity;
-      const len = details.fragments.length;
-      if (len && details.live && !!mediaSource.setLiveSeekableRange) {
-        const start = Math.max(0, details.fragments[0].start);
-        const end = Math.max(start, start + details.totalduration);
-        return { duration: Infinity, start, end };
-      }
-      return { duration: Infinity };
+      this.updateSeekableRange(details);
     } else if (
       (levelDuration > msDuration && levelDuration > mediaDuration) ||
       !Number.isFinite(mediaDuration)
     ) {
-      return { duration: levelDuration };
+      // levelDuration was the last value we set.
+      // not using mediaSource.duration as the browser may tweak this value
+      // only update Media Source duration if its value increase, this is to avoid
+      // flushing already buffered portion when switching between quality level
+      this.log(`Updating Media Source duration to ${levelDuration.toFixed(3)}`);
+      mediaSource.duration = levelDuration;
     }
-    return null;
   }
 
-  private updateMediaSource({
-    duration,
-    start,
-    end,
-  }: {
-    duration: number;
-    start?: number;
-    end?: number;
-  }) {
-    if (
-      !this.media ||
-      !this.mediaSource ||
-      this.mediaSource.readyState !== 'open'
-    ) {
-      return;
-    }
-    if (Number.isFinite(duration)) {
-      this.log(`Updating Media Source duration to ${duration.toFixed(3)}`);
-    }
-    this.mediaSource.duration = duration;
-    if (start !== undefined && end !== undefined) {
+  updateSeekableRange(levelDetails) {
+    const mediaSource = this.mediaSource;
+    const fragments = levelDetails.fragments;
+    const len = fragments.length;
+    if (len && levelDetails.live && mediaSource?.setLiveSeekableRange) {
+      const start = Math.max(0, fragments[0].start);
+      const end = Math.max(start, start + levelDetails.totalduration);
       this.log(
-        `Media Source duration is set to ${this.mediaSource.duration}. Setting seekable range to ${start}-${end}.`,
+        `Media Source duration is set to ${mediaSource.duration}. Setting seekable range to ${start}-${end}.`,
       );
-      this.mediaSource.setLiveSeekableRange(start, end);
+      mediaSource.setLiveSeekableRange(start, end);
     }
   }
 
@@ -1049,10 +930,7 @@ export default class BufferController extends Logger implements ComponentAPI {
         let codec = track.levelCodec || track.codec;
         if (codec) {
           if (trackName.slice(0, 5) === 'audio') {
-            codec = getCodecCompatibleName(
-              codec,
-              this.hls.config.preferManagedMediaSource,
-            );
+            codec = getCodecCompatibleName(codec, this.appendSource);
           }
         }
         const mimeType = `${track.container};codecs=${codec}`;
@@ -1065,19 +943,21 @@ export default class BufferController extends Logger implements ComponentAPI {
           this.addBufferListener(sbName, 'updateend', this._onSBUpdateEnd);
           this.addBufferListener(sbName, 'error', this._onSBUpdateError);
           // ManagedSourceBuffer bufferedchange event
-          this.addBufferListener(
-            sbName,
-            'bufferedchange',
-            (type: SourceBufferName, event: BufferedChangeEvent) => {
-              // If media was ejected check for a change. Added ranges are redundant with changes on 'updateend' event.
-              const removedRanges = event.removedRanges;
-              if (removedRanges?.length) {
-                this.hls.trigger(Events.BUFFER_FLUSHED, {
-                  type: trackName as SourceBufferName,
-                });
-              }
-            },
-          );
+          if (this.appendSource) {
+            this.addBufferListener(
+              sbName,
+              'bufferedchange',
+              (type: SourceBufferName, event: BufferedChangeEvent) => {
+                // If media was ejected check for a change. Added ranges are redundant with changes on 'updateend' event.
+                const removedRanges = event.removedRanges;
+                if (removedRanges?.length) {
+                  this.hls.trigger(Events.BUFFER_FLUSHED, {
+                    type: trackName as SourceBufferName,
+                  });
+                }
+              },
+            );
+          }
 
           this.tracks[trackName] = {
             buffer: sb,
@@ -1108,10 +988,7 @@ export default class BufferController extends Logger implements ComponentAPI {
     this.log('Media source opened');
     if (media) {
       media.removeEventListener('emptied', this._onMediaEmptied);
-      const durationAndRange = this.getDurationAndRange();
-      if (durationAndRange) {
-        this.updateMediaSource(durationAndRange);
-      }
+      this.updateMediaElementDuration();
       this.hls.trigger(Events.MEDIA_ATTACHED, {
         media,
         mediaSource: mediaSource as MediaSource,
@@ -1136,7 +1013,7 @@ export default class BufferController extends Logger implements ComponentAPI {
   private _onMediaEmptied = () => {
     const { mediaSrc, _objectUrl } = this;
     if (mediaSrc !== _objectUrl) {
-      this.error(
+      logger.error(
         `Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`,
       );
     }
@@ -1232,7 +1109,7 @@ export default class BufferController extends Logger implements ComponentAPI {
       }
       return;
     }
-    sb.ending = false;
+
     sb.ended = false;
     sb.appendBuffer(data);
   }
@@ -1255,14 +1132,10 @@ export default class BufferController extends Logger implements ComponentAPI {
     const blockingOperations = buffers.map((type) =>
       operationQueue.appendBlocker(type as SourceBufferName),
     );
-    const audioBlocked = buffers.length > 1 && !!this.blockedAudioAppend;
-    if (audioBlocked) {
-      this.unblockAudio();
-    }
-    Promise.all(blockingOperations).then((result) => {
+    Promise.all(blockingOperations).then(() => {
       // logger.debug(`[buffer-controller]: Blocking operation resolved; unblocking ${buffers} SourceBuffer`);
       onUnblocked();
-      buffers.forEach((type, i) => {
+      buffers.forEach((type) => {
         const sb = this.sourceBuffer[type];
         // Only cycle the queue if the SB is not updating. There's a bug in Chrome which sets the SB updating flag to
         // true when changing the MediaSource duration (https://bugs.chromium.org/p/chromium/issues/detail?id=959359&can=2&q=mediasource%20duration)

package/src/controller/buffer-operation-queue.ts

@@ -30,23 +30,26 @@ export default class BufferOperationQueue {
     }
   }
 
-  public appendBlocker(type: SourceBufferName): Promise<void> {
-    return new Promise((resolve) => {
-      const operation: BufferOperation = {
-        execute: resolve,
-        onStart: () => {},
-        onComplete: () => {},
-        onError: () => {},
-      };
-      this.append(operation, type);
-    });
+  public insertAbort(operation: BufferOperation, type: SourceBufferName) {
+    const queue = this.queues[type];
+    queue.unshift(operation);
+    this.executeNext(type);
   }
 
-  unblockAudio(op: BufferOperation) {
-    const queue = this.queues.audio;
-    if (queue[0] === op) {
-      this.shiftAndExecuteNext('audio');
-    }
+  public appendBlocker(type: SourceBufferName): Promise<{}> {
+    let execute;
+    const promise: Promise<{}> = new Promise((resolve) => {
+      execute = resolve;
+    });
+    const operation: BufferOperation = {
+      execute,
+      onStart: () => {},
+      onComplete: () => {},
+      onError: () => {},
+    };
+
+    this.append(operation, type);
+    return promise;
   }
 
   public executeNext(type: SourceBufferName) {
@@ -77,7 +80,7 @@ export default class BufferOperationQueue {
     this.executeNext(type);
   }
 
-  public current(type: SourceBufferName): BufferOperation {
+  public current(type: SourceBufferName) {
     return this.queues[type][0];
   }
 }

package/src/controller/cap-level-controller.ts

@@ -12,6 +12,7 @@ import type {
   LevelsUpdatedData,
 } from '../types/events';
 import StreamController from './stream-controller';
+import { logger } from '../utils/logger';
 import type { ComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 
@@ -151,13 +152,12 @@ class CapLevelController implements ComponentAPI {
         const hls = this.hls;
         const maxLevel = this.getMaxLevel(levels.length - 1);
         if (maxLevel !== this.autoLevelCapping) {
-          hls.logger.log(
+          logger.log(
             `Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`,
           );
         }
         hls.autoLevelCapping = maxLevel;
         if (
-          hls.autoLevelEnabled &&
           hls.autoLevelCapping > this.autoLevelCapping &&
           this.streamController
         ) {