hls.js 1.5.10-0.canary.10328 → 1.5.10

package/src/controller/cmcd-controller.ts

@@ -1,15 +1,15 @@
 import { Events } from '../events';
-import type Hls from '../hls';
+import Hls from '../hls';
 import { Cmcd } from '@svta/common-media-library/cmcd/Cmcd';
 import { CmcdObjectType } from '@svta/common-media-library/cmcd/CmcdObjectType';
 import { CmcdStreamingFormat } from '@svta/common-media-library/cmcd/CmcdStreamingFormat';
 import { appendCmcdHeaders } from '@svta/common-media-library/cmcd/appendCmcdHeaders';
 import { appendCmcdQuery } from '@svta/common-media-library/cmcd/appendCmcdQuery';
-import type { CmcdEncodeOptions } from '@svta/common-media-library/cmcd/CmcdEncodeOptions';
 import { uuid } from '@svta/common-media-library/utils/uuid';
 import { BufferHelper } from '../utils/buffer-helper';
+import { logger } from '../utils/logger';
 import type { ComponentAPI } from '../types/component-api';
-import type { Fragment, Part } from '../loader/fragment';
+import type { Fragment } from '../loader/fragment';
 import type { BufferCreatedData, MediaAttachedData } from '../types/events';
 import type {
   FragmentLoaderContext,
@@ -81,7 +81,7 @@ export default class CMCDController implements ComponentAPI {
     // @ts-ignore
     this.hls = this.config = this.audioBuffer = this.videoBuffer = null;
     // @ts-ignore
-    this.onWaiting = this.onPlaying = this.media = null;
+    this.onWaiting = this.onPlaying = null;
   }
 
   private onMediaAttached(
@@ -165,7 +165,7 @@ export default class CMCDController implements ComponentAPI {
       data.su = this.buffering;
     }
 
-    // TODO: Implement rtp, nrr, dl
+    // TODO: Implement rtp, nrr, nor, dl
 
     const { includeKeys } = this;
     if (includeKeys) {
@@ -175,18 +175,14 @@ export default class CMCDController implements ComponentAPI {
       }, {});
     }
 
-    const options: CmcdEncodeOptions = {
-      baseUrl: context.url,
-    };
-
     if (this.useHeaders) {
       if (!context.headers) {
         context.headers = {};
       }
 
-      appendCmcdHeaders(context.headers, data, options);
+      appendCmcdHeaders(context.headers, data);
     } else {
-      context.url = appendCmcdQuery(context.url, data, options);
+      context.url = appendCmcdQuery(context.url, data);
     }
   }
 
@@ -200,7 +196,7 @@ export default class CMCDController implements ComponentAPI {
         su: !this.initialized,
       });
     } catch (error) {
-      this.hls.logger.warn('Could not generate manifest CMCD data.', error);
+      logger.warn('Could not generate manifest CMCD data.', error);
     }
   };
 
@@ -209,11 +205,11 @@ export default class CMCDController implements ComponentAPI {
    */
   private applyFragmentData = (context: FragmentLoaderContext) => {
     try {
-      const { frag, part } = context;
-      const level = this.hls.levels[frag.level];
-      const ot = this.getObjectType(frag);
+      const fragment = context.frag;
+      const level = this.hls.levels[fragment.level];
+      const ot = this.getObjectType(fragment);
       const data: Cmcd = {
-        d: (part || frag).duration * 1000,
+        d: fragment.duration * 1000,
         ot,
       };
 
@@ -227,45 +223,12 @@ export default class CMCDController implements ComponentAPI {
         data.bl = this.getBufferLength(ot);
       }
 
-      const next = part ? this.getNextPart(part) : this.getNextFrag(frag);
-
-      if (next?.url && next.url !== frag.url) {
-        data.nor = next.url;
-      }
-
       this.apply(context, data);
     } catch (error) {
-      this.hls.logger.warn('Could not generate segment CMCD data.', error);
+      logger.warn('Could not generate segment CMCD data.', error);
     }
   };
 
-  private getNextFrag(fragment: Fragment): Fragment | undefined {
-    const levelDetails = this.hls.levels[fragment.level]?.details;
-    if (levelDetails) {
-      const index = (fragment.sn as number) - levelDetails.startSN;
-      return levelDetails.fragments[index + 1];
-    }
-
-    return undefined;
-  }
-
-  private getNextPart(part: Part): Part | undefined {
-    const { index, fragment } = part;
-    const partList = this.hls.levels[fragment.level]?.details?.partList;
-
-    if (partList) {
-      const { sn } = fragment;
-      for (let i = partList.length - 1; i >= 0; i--) {
-        const p = partList[i];
-        if (p.index === index && p.fragment.sn === sn) {
-          return partList[i + 1];
-        }
-      }
-    }
-
-    return undefined;
-  }
-
   /**
    * The CMCD object type.
    */
@@ -324,7 +287,7 @@ export default class CMCDController implements ComponentAPI {
    * Get the buffer length for a media type in milliseconds
    */
   private getBufferLength(type: CmcdObjectType) {
-    const media = this.media;
+    const media = this.hls.media;
     const buffer =
       type === CmcdObjectType.AUDIO ? this.audioBuffer : this.videoBuffer;
 

package/src/controller/content-steering-controller.ts

@@ -3,7 +3,7 @@ import { Level } from '../types/level';
 import { reassignFragmentLevelIndexes } from '../utils/level-helper';
 import { AttrList } from '../utils/attr-list';
 import { ErrorActionFlags, NetworkErrorAction } from './error-controller';
-import { Logger } from '../utils/logger';
+import { logger } from '../utils/logger';
 import {
   PlaylistContextType,
   type Loader,
@@ -48,15 +48,13 @@ export type UriReplacement = {
 
 const PATHWAY_PENALTY_DURATION_MS = 300000;
 
-export default class ContentSteeringController
-  extends Logger
-  implements NetworkComponentAPI
-{
+export default class ContentSteeringController implements NetworkComponentAPI {
   private readonly hls: Hls;
+  private log: (msg: any) => void;
   private loader: Loader<LoaderContext> | null = null;
   private uri: string | null = null;
   private pathwayId: string = '.';
-  private _pathwayPriority: string[] | null = null;
+  private pathwayPriority: string[] | null = null;
   private timeToLoad: number = 300;
   private reloadTimer: number = -1;
   private updated: number = 0;
@@ -68,8 +66,8 @@ export default class ContentSteeringController
   private penalizedPathways: { [pathwayId: string]: number } = {};
 
   constructor(hls: Hls) {
-    super('content-steering', hls.logger);
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
 
@@ -92,23 +90,6 @@ export default class ContentSteeringController
     hls.off(Events.ERROR, this.onError, this);
   }
 
-  pathways() {
-    return (this.levels || []).reduce((pathways, level) => {
-      if (pathways.indexOf(level.pathwayId) === -1) {
-        pathways.push(level.pathwayId);
-      }
-      return pathways;
-    }, [] as string[]);
-  }
-
-  get pathwayPriority(): string[] | null {
-    return this._pathwayPriority;
-  }
-
-  set pathwayPriority(pathwayPriority: string[]) {
-    this.updatePathwayPriority(pathwayPriority);
-  }
-
   startLoad() {
     this.started = true;
     this.clearTimeout();
@@ -195,7 +176,7 @@ export default class ContentSteeringController
       errorAction.flags === ErrorActionFlags.MoveAllAlternatesMatchingHost
     ) {
       const levels = this.levels;
-      let pathwayPriority = this._pathwayPriority;
+      let pathwayPriority = this.pathwayPriority;
       let errorPathway = this.pathwayId;
       if (data.context) {
         const { groupId, pathwayId, type } = data.context;
@@ -210,14 +191,19 @@ export default class ContentSteeringController
       }
       if (!pathwayPriority && levels) {
         // If PATHWAY-PRIORITY was not provided, list pathways for error handling
-        pathwayPriority = this.pathways();
+        pathwayPriority = levels.reduce((pathways, level) => {
+          if (pathways.indexOf(level.pathwayId) === -1) {
+            pathways.push(level.pathwayId);
+          }
+          return pathways;
+        }, [] as string[]);
       }
       if (pathwayPriority && pathwayPriority.length > 1) {
         this.updatePathwayPriority(pathwayPriority);
         errorAction.resolved = this.pathwayId !== errorPathway;
       }
       if (!errorAction.resolved) {
-        this.warn(
+        logger.warn(
           `Could not resolve ${data.details} ("${
             data.error.message
           }") with content-steering for Pathway: ${errorPathway} levels: ${
@@ -259,7 +245,7 @@ export default class ContentSteeringController
   }
 
   private updatePathwayPriority(pathwayPriority: string[]) {
-    this._pathwayPriority = pathwayPriority;
+    this.pathwayPriority = pathwayPriority;
     let levels: Level[] | undefined;
 
     // Evaluate if we should remove the pathway from the penalized list
@@ -456,7 +442,7 @@ export default class ContentSteeringController
       ) => {
         this.log(`Loaded steering manifest: "${url}"`);
         const steeringData = response.data as SteeringManifest;
-        if (steeringData?.VERSION !== 1) {
+        if (steeringData.VERSION !== 1) {
           this.log(`Steering VERSION ${steeringData.VERSION} not supported!`);
           return;
         }

package/src/controller/eme-controller.ts

@@ -5,7 +5,7 @@
  */
 import { Events } from '../events';
 import { ErrorTypes, ErrorDetails } from '../errors';
-import { Logger } from '../utils/logger';
+import { logger } from '../utils/logger';
 import {
   getKeySystemsForConfig,
   getSupportedMediaKeySystemConfigurations,
@@ -19,7 +19,7 @@ import {
   KeySystems,
   requestMediaKeySystemAccess,
 } from '../utils/mediakeys-helper';
-import { strToUtf8array } from '../utils/utf8-utils';
+import { strToUtf8array } from '../utils/keysystem-util';
 import { base64Decode } from '../utils/numeric-encoding-utils';
 import { DecryptData, LevelKey } from '../loader/level-key';
 import Hex from '../utils/hex';
@@ -41,6 +41,9 @@ import type {
   LoaderConfiguration,
   LoaderContext,
 } from '../types/loader';
+
+const LOGGER_PREFIX = '[eme]';
+
 interface KeySystemAccessPromises {
   keySystemAccess: Promise<MediaKeySystemAccess>;
   mediaKeys?: Promise<MediaKeys>;
@@ -65,7 +68,7 @@ export interface MediaKeySessionContext {
  * @class
  * @constructor
  */
-class EMEController extends Logger implements ComponentAPI {
+class EMEController implements ComponentAPI {
   public static CDMCleanupPromise: Promise<void> | void;
 
   private readonly hls: Hls;
@@ -87,9 +90,15 @@ class EMEController extends Logger implements ComponentAPI {
   private setMediaKeysQueue: Promise<void>[] = EMEController.CDMCleanupPromise
     ? [EMEController.CDMCleanupPromise]
     : [];
+  private onMediaEncrypted = this._onMediaEncrypted.bind(this);
+  private onWaitingForKey = this._onWaitingForKey.bind(this);
+
+  private debug: (msg: any) => void = logger.debug.bind(logger, LOGGER_PREFIX);
+  private log: (msg: any) => void = logger.log.bind(logger, LOGGER_PREFIX);
+  private warn: (msg: any) => void = logger.warn.bind(logger, LOGGER_PREFIX);
+  private error: (msg: any) => void = logger.error.bind(logger, LOGGER_PREFIX);
 
   constructor(hls: Hls) {
-    super('eme', hls.logger);
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -104,9 +113,13 @@ class EMEController extends Logger implements ComponentAPI {
     config.licenseXhrSetup = config.licenseResponseCallback = undefined;
     config.drmSystems = config.drmSystemOptions = {};
     // @ts-ignore
-    this.hls = this.config = this.keyIdToKeySessionPromise = null;
+    this.hls =
+      this.onMediaEncrypted =
+      this.onWaitingForKey =
+      this.keyIdToKeySessionPromise =
+        null as any;
     // @ts-ignore
-    this.onMediaEncrypted = this.onWaitingForKey = null;
+    this.config = null;
   }
 
   private registerListeners() {
@@ -510,7 +523,7 @@ class EMEController extends Logger implements ComponentAPI {
     return this.attemptKeySystemAccess(keySystemsToAttempt);
   }
 
-  private onMediaEncrypted = (event: MediaEncryptedEvent) => {
+  private _onMediaEncrypted(event: MediaEncryptedEvent) {
     const { initDataType, initData } = event;
     this.debug(`"${event.type}" event: init data type: "${initDataType}"`);
 
@@ -626,11 +639,11 @@ class EMEController extends Logger implements ComponentAPI {
         );
     }
     keySessionContextPromise.catch((error) => this.handleError(error));
-  };
+  }
 
-  private onWaitingForKey = (event: Event) => {
+  private _onWaitingForKey(event: Event) {
     this.log(`"${event.type}" event`);
-  };
+  }
 
   private attemptSetMediaKeys(
     keySystem: KeySystems,

package/src/controller/error-controller.ts

@@ -8,7 +8,7 @@ import {
 } from '../utils/error-helper';
 import { findFragmentByPTS } from './fragment-finders';
 import { HdcpLevel, HdcpLevels } from '../types/level';
-import { Logger } from '../utils/logger';
+import { logger } from '../utils/logger';
 import type Hls from '../hls';
 import type { RetryConfig } from '../config';
 import type { NetworkComponentAPI } from '../types/component-api';
@@ -50,17 +50,19 @@ type PenalizedRendition = {
 
 type PenalizedRenditions = { [key: number]: PenalizedRendition };
 
-export default class ErrorController
-  extends Logger
-  implements NetworkComponentAPI
-{
+export default class ErrorController implements NetworkComponentAPI {
   private readonly hls: Hls;
   private playlistError: number = 0;
   private penalizedRenditions: PenalizedRenditions = {};
+  private log: (msg: any) => void;
+  private warn: (msg: any) => void;
+  private error: (msg: any) => void;
 
   constructor(hls: Hls) {
-    super('error-controller', hls.logger);
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[info]:`);
+    this.warn = logger.warn.bind(logger, `[warning]:`);
+    this.error = logger.error.bind(logger, `[error]:`);
     this.registerListeners();
   }
 

package/src/controller/fps-controller.ts

@@ -1,4 +1,5 @@
 import { Events } from '../events';
+import { logger } from '../utils/logger';
 import type { ComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 import type { MediaAttachingData } from '../types/events';
@@ -27,12 +28,10 @@ class FPSController implements ComponentAPI {
 
   protected registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
-    this.hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
   }
 
   protected unregisterListeners() {
     this.hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
-    this.hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
   }
 
   destroy() {
@@ -66,10 +65,6 @@ class FPSController implements ComponentAPI {
     }
   }
 
-  private onMediaDetaching() {
-    this.media = null;
-  }
-
   checkFPS(
     video: HTMLVideoElement,
     decodedFrames: number,
@@ -89,13 +84,13 @@ class FPSController implements ComponentAPI {
           totalDroppedFrames: droppedFrames,
         });
         if (droppedFPS > 0) {
-          // hls.logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
+          // logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
           if (
             currentDropped >
             hls.config.fpsDroppedMonitoringThreshold * currentDecoded
           ) {
             let currentLevel = hls.currentLevel;
-            hls.logger.warn(
+            logger.warn(
               'drop FPS ratio greater than max allowed value for currentLevel: ' +
                 currentLevel,
             );

package/src/controller/fragment-tracker.ts

@@ -107,23 +107,12 @@ export class FragmentTracker implements ComponentAPI {
   public getBufferedFrag(
     position: number,
     levelType: PlaylistLevelType,
-  ): Fragment | null {
-    return this.getFragAtPos(position, levelType, true);
-  }
-
-  public getFragAtPos(
-    position: number,
-    levelType: PlaylistLevelType,
-    buffered?: boolean,
   ): Fragment | null {
     const { fragments } = this;
     const keys = Object.keys(fragments);
     for (let i = keys.length; i--; ) {
       const fragmentEntity = fragments[keys[i]];
-      if (
-        fragmentEntity?.body.type === levelType &&
-        (!buffered || fragmentEntity.buffered)
-      ) {
+      if (fragmentEntity?.body.type === levelType && fragmentEntity.buffered) {
         const frag = fragmentEntity.body;
         if (frag.start <= position && position <= frag.end) {
           return frag;
@@ -412,7 +401,7 @@ export class FragmentTracker implements ComponentAPI {
     event: Events.BUFFER_APPENDED,
     data: BufferAppendedData,
   ) {
-    const { frag, part, timeRanges, type } = data;
+    const { frag, part, timeRanges } = data;
     if (frag.sn === 'initSegment') {
       return;
     }
@@ -426,8 +415,15 @@ export class FragmentTracker implements ComponentAPI {
     }
     // Store the latest timeRanges loaded in the buffer
     this.timeRanges = timeRanges;
-    const timeRange = timeRanges[type] as TimeRanges;
-    this.detectEvictedFragments(type, timeRange, playlistType, part);
+    Object.keys(timeRanges).forEach((elementaryStream: SourceBufferName) => {
+      const timeRange = timeRanges[elementaryStream] as TimeRanges;
+      this.detectEvictedFragments(
+        elementaryStream,
+        timeRange,
+        playlistType,
+        part,
+      );
+    });
   }
 
   private onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {

package/src/controller/gap-controller.ts

@@ -1,22 +1,20 @@
-import { State } from './base-stream-controller';
+import type { BufferInfo } from '../utils/buffer-helper';
 import { BufferHelper } from '../utils/buffer-helper';
 import { ErrorTypes, ErrorDetails } from '../errors';
 import { PlaylistLevelType } from '../types/loader';
 import { Events } from '../events';
-import { Logger } from '../utils/logger';
+import { logger } from '../utils/logger';
 import type Hls from '../hls';
-import type { BufferInfo } from '../utils/buffer-helper';
 import type { HlsConfig } from '../config';
 import type { Fragment } from '../loader/fragment';
 import type { FragmentTracker } from './fragment-tracker';
-import type { LevelDetails } from '../loader/level-details';
 
 export const STALL_MINIMUM_DURATION_MS = 250;
 export const MAX_START_GAP_JUMP = 2.0;
 export const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
 export const SKIP_BUFFER_RANGE_START = 0.05;
 
-export default class GapController extends Logger {
+export default class GapController {
   private config: HlsConfig;
   private media: HTMLMediaElement | null = null;
   private fragmentTracker: FragmentTracker;
@@ -26,15 +24,8 @@ export default class GapController extends Logger {
   private stalled: number | null = null;
   private moved: boolean = false;
   private seeking: boolean = false;
-  private ended: number = 0;
 
-  constructor(
-    config: HlsConfig,
-    media: HTMLMediaElement,
-    fragmentTracker: FragmentTracker,
-    hls: Hls,
-  ) {
-    super('gap-controller', hls.logger);
+  constructor(config, media, fragmentTracker, hls) {
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -53,12 +44,7 @@ export default class GapController extends Logger {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  public poll(
-    lastCurrentTime: number,
-    activeFrag: Fragment | null,
-    levelDetails: LevelDetails | undefined,
-    state: string,
-  ) {
+  public poll(lastCurrentTime: number, activeFrag: Fragment | null) {
     const { config, media, stalled } = this;
     if (media === null) {
       return;
@@ -71,7 +57,6 @@ export default class GapController extends Logger {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
-      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -80,7 +65,7 @@ export default class GapController extends Logger {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const stalledDuration = self.performance.now() - stalled;
-          this.warn(
+          logger.warn(
             `playback not stuck anymore @${currentTime}, after ${Math.round(
               stalledDuration,
             )}ms`,
@@ -143,9 +128,12 @@ export default class GapController extends Logger {
       // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
       // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
       // that begins over 1 target duration after the video start position.
-      const isLive = !!levelDetails?.live;
+      const level = this.hls.levels
+        ? this.hls.levels[this.hls.currentLevel]
+        : null;
+      const isLive = level?.details?.live;
       const maxStartGapJump = isLive
-        ? levelDetails!.targetduration * 2
+        ? level!.details!.targetduration * 2
         : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
@@ -165,21 +153,6 @@ export default class GapController extends Logger {
 
     const stalledDuration = tnow - stalled;
     if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
-      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
-      if (
-        state === State.ENDED &&
-        !levelDetails?.live &&
-        Math.abs(currentTime - (levelDetails?.edge || 0)) < 1
-      ) {
-        if (stalledDuration < 1000 || this.ended) {
-          return;
-        }
-        this.ended = currentTime;
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: true,
-        });
-        return;
-      }
       // Report stalling after trying to fix
       this._reportStall(bufferInfo);
       if (!this.media) {
@@ -233,7 +206,7 @@ export default class GapController extends Logger {
           bufferInfo.nextStart - currentTime < config.maxBufferHole)) &&
       stalledDurationMs > config.highBufferWatchdogPeriod * 1000
     ) {
-      this.warn('Trying to nudge playhead over buffer-hole');
+      logger.warn('Trying to nudge playhead over buffer-hole');
       // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
       // We only try to jump the hole if it's under the configured size
       // Reset stalled so to rearm watchdog timer
@@ -257,7 +230,7 @@ export default class GapController extends Logger {
           media.currentTime
         } due to low buffer (${JSON.stringify(bufferInfo)})`,
       );
-      this.warn(error.message);
+      logger.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -332,7 +305,7 @@ export default class GapController extends Logger {
           startTime + SKIP_BUFFER_RANGE_START,
           currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS,
         );
-        this.warn(
+        logger.warn(
           `skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`,
         );
         this.moved = true;
@@ -375,7 +348,7 @@ export default class GapController extends Logger {
       const error = new Error(
         `Nudging 'currentTime' from ${currentTime} to ${targetTime}`,
       );
-      this.warn(error.message);
+      logger.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -387,7 +360,7 @@ export default class GapController extends Logger {
       const error = new Error(
         `Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`,
       );
-      this.error(error.message);
+      logger.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,

package/src/controller/id3-track-controller.ts

@@ -4,6 +4,7 @@ import {
   clearCurrentCues,
   removeCuesInRange,
 } from '../utils/texttrack-utils';
+import * as ID3 from '../demux/id3';
 import {
   DateRange,
   isDateRangeCueAttribute,
@@ -18,8 +19,6 @@ import type {
 } from '../types/events';
 import type { ComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
-import { getId3Frames } from '@svta/common-media-library/id3/getId3Frames';
-import { isId3TimestampFrame } from '@svta/common-media-library/id3/isId3TimestampFrame';
 
 declare global {
   interface Window {
@@ -138,10 +137,11 @@ class ID3TrackController implements ComponentAPI {
   }
 
   protected onMediaDetaching(): void {
-    if (this.id3Track) {
-      clearCurrentCues(this.id3Track);
-      this.id3Track = null;
+    if (!this.id3Track) {
+      return;
     }
+    clearCurrentCues(this.id3Track);
+    this.id3Track = null;
     this.media = null;
     this.dateRangeCuesAppended = {};
   }
@@ -211,7 +211,7 @@ class ID3TrackController implements ComponentAPI {
         continue;
       }
 
-      const frames = getId3Frames(samples[i].data);
+      const frames = ID3.getID3Frames(samples[i].data);
       if (frames) {
         const startTime = samples[i].pts;
         let endTime: number = startTime + samples[i].duration;
@@ -228,7 +228,7 @@ class ID3TrackController implements ComponentAPI {
         for (let j = 0; j < frames.length; j++) {
           const frame = frames[j];
           // Safari doesn't put the timestamp frame in the TextTrack
-          if (!isId3TimestampFrame(frame)) {
+          if (!ID3.isTimeStampFrame(frame)) {
             // add a bounds to any unbounded cues
             this.updateId3CueEnds(startTime, type);
             const cue = createCueWithDataFields(