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

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 {
@@ -10,12 +10,7 @@ import {
   getMediaSource,
   isManagedMediaSource,
 } 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 {
@@ -39,7 +34,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';
 
@@ -51,7 +45,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
@@ -62,7 +56,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;
@@ -79,14 +72,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
@@ -100,14 +85,19 @@ 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;
+    const logPrefix = '[buffer-controller]';
     this.appendSource = isManagedMediaSource(
       getMediaSource(hls.config.preferManagedMediaSource),
     );
-
+    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();
   }
@@ -124,13 +114,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() {
@@ -147,7 +131,6 @@ export default class BufferController extends Logger implements ComponentAPI {
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.on(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.on(Events.FRAG_CHANGED, this.onFragChanged, this);
-    hls.on(Events.ERROR, this.onError, this);
   }
 
   protected unregisterListeners() {
@@ -164,7 +147,6 @@ export default class BufferController extends Logger implements ComponentAPI {
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.off(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.off(Events.FRAG_CHANGED, this.onFragChanged, this);
-    hls.off(Events.ERROR, this.onError, this);
   }
 
   private _initSourceBuffer() {
@@ -175,10 +157,12 @@ export default class BufferController extends Logger implements ComponentAPI {
       video: [],
       audiovideo: [],
     };
-    this.resetAppendErrors();
+    this.appendErrors = {
+      audio: 0,
+      video: 0,
+      audiovideo: 0,
+    };
     this.lastMpegAudioChunk = null;
-    this.blockedAudioAppend = null;
-    this.lastVideoAppendEnd = 0;
   }
 
   private onManifestLoading() {
@@ -286,38 +270,37 @@ export default class BufferController extends Logger implements ComponentAPI {
         mediaSource.removeEventListener('endstreaming', this._onEndStreaming);
       }
 
-      this.mediaSource = null;
-      this._objectUrl = null;
-    }
-
-    // Detach properly the MediaSource from the HTMLMediaElement as
-    // suggested in https://github.com/w3c/media-source/issues/53.
-    if (media) {
-      media.removeEventListener('emptied', this._onMediaEmptied);
-      if (_objectUrl) {
-        self.URL.revokeObjectURL(_objectUrl);
-      }
+      // Detach properly the MediaSource from the HTMLMediaElement as
+      // suggested in https://github.com/w3c/media-source/issues/53.
+      if (media) {
+        media.removeEventListener('emptied', this._onMediaEmptied);
+        if (_objectUrl) {
+          self.URL.revokeObjectURL(_objectUrl);
+        }
 
-      // clean up video tag src only if it's our own url. some external libraries might
-      // hijack the video tag and change its 'src' without destroying the Hls instance first
-      if (this.mediaSrc === _objectUrl) {
-        media.removeAttribute('src');
-        if (this.appendSource) {
-          removeSourceChildren(media);
+        // clean up video tag src only if it's our own url. some external libraries might
+        // hijack the video tag and change its 'src' without destroying the Hls instance first
+        if (this.mediaSrc === _objectUrl) {
+          media.removeAttribute('src');
+          if (this.appendSource) {
+            removeSourceChildren(media);
+          }
+          media.load();
+        } else {
+          this.warn(
+            'media|source.src was changed by a third party - skip cleanup',
+          );
         }
-        media.load();
-      } else {
-        this.warn(
-          'media|source.src was changed by a third party - skip cleanup',
-        );
       }
+
+      this.mediaSource = null;
       this.media = null;
+      this._objectUrl = null;
+      this.bufferCodecEventsExpected = this._bufferCodecEventsTotal;
+      this.pendingTracks = {};
+      this.tracks = {};
     }
 
-    this.bufferCodecEventsExpected = this._bufferCodecEventsTotal;
-    this.pendingTracks = {};
-    this.tracks = {};
-
     this.hls.trigger(Events.MEDIA_DETACHED, undefined);
   }
 
@@ -326,7 +309,6 @@ export default class BufferController extends Logger implements ComponentAPI {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
-    this.hls.resumeBuffering();
   }
 
   private resetBuffer(type: SourceBufferName) {
@@ -352,11 +334,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(
@@ -420,7 +402,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: () => {
@@ -441,52 +423,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;
@@ -513,44 +457,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();
@@ -560,7 +467,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;
             }
@@ -629,27 +536,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`);
       },
@@ -660,26 +570,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);
       });
     }
   }
@@ -732,9 +629,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)) {
@@ -780,34 +674,14 @@ 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);
-    }
-  }
-
-  private onError(event: Events.ERROR, data: ErrorData) {
-    if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && data.frag) {
-      const nextAutoLevel = data.errorAction?.nextAutoLevel;
-      if (Number.isFinite(nextAutoLevel) && nextAutoLevel !== data.frag.level) {
-        this.resetAppendErrors();
-      }
+      this.updateMediaElementDuration();
     }
   }
 
-  private resetAppendErrors() {
-    this.appendErrors = {
-      audio: 0,
-      video: 0,
-      audiovideo: 0,
-    };
-  }
-
   trimBuffers() {
     const { hls, details, media } = this;
     if (!media || details === null) {
@@ -956,18 +830,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;
@@ -979,47 +849,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);
     }
   }
 
@@ -1140,10 +994,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,
@@ -1168,15 +1019,14 @@ 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})`,
       );
     }
   };
 
   private get mediaSrc(): string | undefined {
-    const media =
-      (this.media?.firstChild as HTMLSourceElement | null) || this.media;
+    const media = this.media?.querySelector?.('source') || this.media;
     return media?.src;
   }
 
@@ -1264,7 +1114,7 @@ export default class BufferController extends Logger implements ComponentAPI {
       }
       return;
     }
-    sb.ending = false;
+
     sb.ended = false;
     sb.appendBuffer(data);
   }
@@ -1287,14 +1137,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';
 
@@ -138,7 +139,6 @@ class CapLevelController implements ComponentAPI {
 
   protected onMediaDetaching() {
     this.stopCapping();
-    this.media = null;
   }
 
   detectPlayerSize() {
@@ -152,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
         ) {