hls.js 1.5.13 → 1.5.14-0.canary.10415

package/src/controller/cmcd-controller.ts

@@ -1,15 +1,15 @@
 import { Events } from '../events';
-import Hls from '../hls';
+import type 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 } from '../loader/fragment';
+import type { Fragment, Part } 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 = null;
+    this.onWaiting = this.onPlaying = this.media = null;
   }
 
   private onMediaAttached(
@@ -165,7 +165,7 @@ export default class CMCDController implements ComponentAPI {
       data.su = this.buffering;
     }
 
-    // TODO: Implement rtp, nrr, nor, dl
+    // TODO: Implement rtp, nrr, dl
 
     const { includeKeys } = this;
     if (includeKeys) {
@@ -175,14 +175,18 @@ export default class CMCDController implements ComponentAPI {
       }, {});
     }
 
+    const options: CmcdEncodeOptions = {
+      baseUrl: context.url,
+    };
+
     if (this.useHeaders) {
       if (!context.headers) {
         context.headers = {};
       }
 
-      appendCmcdHeaders(context.headers, data);
+      appendCmcdHeaders(context.headers, data, options);
     } else {
-      context.url = appendCmcdQuery(context.url, data);
+      context.url = appendCmcdQuery(context.url, data, options);
     }
   }
 
@@ -196,7 +200,7 @@ export default class CMCDController implements ComponentAPI {
         su: !this.initialized,
       });
     } catch (error) {
-      logger.warn('Could not generate manifest CMCD data.', error);
+      this.hls.logger.warn('Could not generate manifest CMCD data.', error);
     }
   };
 
@@ -205,11 +209,11 @@ export default class CMCDController implements ComponentAPI {
    */
   private applyFragmentData = (context: FragmentLoaderContext) => {
     try {
-      const fragment = context.frag;
-      const level = this.hls.levels[fragment.level];
-      const ot = this.getObjectType(fragment);
+      const { frag, part } = context;
+      const level = this.hls.levels[frag.level];
+      const ot = this.getObjectType(frag);
       const data: Cmcd = {
-        d: fragment.duration * 1000,
+        d: (part || frag).duration * 1000,
         ot,
       };
 
@@ -223,12 +227,45 @@ 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) {
-      logger.warn('Could not generate segment CMCD data.', error);
+      this.hls.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.
    */
@@ -287,7 +324,7 @@ export default class CMCDController implements ComponentAPI {
    * Get the buffer length for a media type in milliseconds
    */
   private getBufferLength(type: CmcdObjectType) {
-    const media = this.hls.media;
+    const media = this.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,13 +48,15 @@ export type UriReplacement = {
 
 const PATHWAY_PENALTY_DURATION_MS = 300000;
 
-export default class ContentSteeringController implements NetworkComponentAPI {
+export default class ContentSteeringController
+  extends Logger
+  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;
@@ -66,8 +68,8 @@ export default class ContentSteeringController implements NetworkComponentAPI {
   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();
   }
 
@@ -90,6 +92,23 @@ export default class ContentSteeringController implements NetworkComponentAPI {
     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();
@@ -176,7 +195,7 @@ export default class ContentSteeringController implements NetworkComponentAPI {
       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;
@@ -191,19 +210,14 @@ export default class ContentSteeringController implements NetworkComponentAPI {
       }
       if (!pathwayPriority && levels) {
         // If PATHWAY-PRIORITY was not provided, list pathways for error handling
-        pathwayPriority = levels.reduce((pathways, level) => {
-          if (pathways.indexOf(level.pathwayId) === -1) {
-            pathways.push(level.pathwayId);
-          }
-          return pathways;
-        }, [] as string[]);
+        pathwayPriority = this.pathways();
       }
       if (pathwayPriority && pathwayPriority.length > 1) {
         this.updatePathwayPriority(pathwayPriority);
         errorAction.resolved = this.pathwayId !== errorPathway;
       }
       if (!errorAction.resolved) {
-        logger.warn(
+        this.warn(
           `Could not resolve ${data.details} ("${
             data.error.message
           }") with content-steering for Pathway: ${errorPathway} levels: ${
@@ -245,7 +259,7 @@ export default class ContentSteeringController implements NetworkComponentAPI {
   }
 
   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
@@ -442,7 +456,7 @@ export default class ContentSteeringController implements NetworkComponentAPI {
       ) => {
         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/keysystem-util';
+import { strToUtf8array } from '../utils/utf8-utils';
 import { base64Decode } from '../utils/numeric-encoding-utils';
 import { DecryptData, LevelKey } from '../loader/level-key';
 import Hex from '../utils/hex';
@@ -41,9 +41,6 @@ import type {
   LoaderConfiguration,
   LoaderContext,
 } from '../types/loader';
-
-const LOGGER_PREFIX = '[eme]';
-
 interface KeySystemAccessPromises {
   keySystemAccess: Promise<MediaKeySystemAccess>;
   mediaKeys?: Promise<MediaKeys>;
@@ -68,7 +65,7 @@ export interface MediaKeySessionContext {
  * @class
  * @constructor
  */
-class EMEController implements ComponentAPI {
+class EMEController extends Logger implements ComponentAPI {
   public static CDMCleanupPromise: Promise<void> | void;
 
   private readonly hls: Hls;
@@ -90,15 +87,9 @@ class EMEController 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();
@@ -113,13 +104,9 @@ class EMEController implements ComponentAPI {
     config.licenseXhrSetup = config.licenseResponseCallback = undefined;
     config.drmSystems = config.drmSystemOptions = {};
     // @ts-ignore
-    this.hls =
-      this.onMediaEncrypted =
-      this.onWaitingForKey =
-      this.keyIdToKeySessionPromise =
-        null as any;
+    this.hls = this.config = this.keyIdToKeySessionPromise = null;
     // @ts-ignore
-    this.config = null;
+    this.onMediaEncrypted = this.onWaitingForKey = null;
   }
 
   private registerListeners() {
@@ -523,7 +510,7 @@ class EMEController 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}"`);
 
@@ -639,11 +626,11 @@ class EMEController 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,12 +8,12 @@ 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';
 import type { ErrorData } from '../types/events';
-import type { Fragment } from '../loader/fragment';
+import type { Fragment, MediaFragment } from '../loader/fragment';
 import type { LevelDetails } from '../loader/level-details';
 
 export const enum NetworkErrorAction {
@@ -50,19 +50,17 @@ type PenalizedRendition = {
 
 type PenalizedRenditions = { [key: number]: PenalizedRendition };
 
-export default class ErrorController implements NetworkComponentAPI {
+export default class ErrorController
+  extends Logger
+  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();
   }
 
@@ -129,10 +127,7 @@ export default class ErrorController implements NetworkComponentAPI {
       case ErrorDetails.FRAG_PARSING_ERROR:
         // ignore empty segment errors marked as gap
         if (data.frag?.gap) {
-          data.errorAction = {
-            action: NetworkErrorAction.DoNothing,
-            flags: ErrorActionFlags.None,
-          };
+          data.errorAction = createDoNothingErrorAction();
           return;
         }
       // falls through
@@ -220,10 +215,13 @@ export default class ErrorController implements NetworkComponentAPI {
       case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
       case ErrorDetails.REMUX_ALLOC_ERROR:
       case ErrorDetails.BUFFER_APPEND_ERROR:
-        data.errorAction = this.getLevelSwitchAction(
-          data,
-          data.level ?? hls.loadLevel,
-        );
+        // Buffer-controller can set errorAction when append errors can be ignored or resolved locally
+        if (!data.errorAction) {
+          data.errorAction = this.getLevelSwitchAction(
+            data,
+            data.level ?? hls.loadLevel,
+          );
+        }
         return;
       case ErrorDetails.INTERNAL_EXCEPTION:
       case ErrorDetails.BUFFER_APPENDING_ERROR:
@@ -232,10 +230,7 @@ export default class ErrorController implements NetworkComponentAPI {
       case ErrorDetails.BUFFER_STALLED_ERROR:
       case ErrorDetails.BUFFER_SEEK_OVER_HOLE:
       case ErrorDetails.BUFFER_NUDGE_ON_STALL:
-        data.errorAction = {
-          action: NetworkErrorAction.DoNothing,
-          flags: ErrorActionFlags.None,
-        };
+        data.errorAction = createDoNothingErrorAction();
         return;
     }
 
@@ -389,7 +384,7 @@ export default class ErrorController implements NetworkComponentAPI {
             const levelDetails = levels[candidate].details;
             if (levelDetails) {
               const fragCandidate = findFragmentByPTS(
-                data.frag,
+                data.frag as MediaFragment,
                 levelDetails.fragments,
                 data.frag.start,
               );
@@ -513,3 +508,14 @@ export default class ErrorController implements NetworkComponentAPI {
     }
   }
 }
+
+export function createDoNothingErrorAction(resolved?: boolean): IErrorAction {
+  const errorAction: IErrorAction = {
+    action: NetworkErrorAction.DoNothing,
+    flags: ErrorActionFlags.None,
+  };
+  if (resolved) {
+    errorAction.resolved = true;
+  }
+  return errorAction;
+}

package/src/controller/fps-controller.ts

@@ -1,5 +1,4 @@
 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';
@@ -28,10 +27,12 @@ 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() {
@@ -65,6 +66,10 @@ class FPSController implements ComponentAPI {
     }
   }
 
+  private onMediaDetaching() {
+    this.media = null;
+  }
+
   checkFPS(
     video: HTMLVideoElement,
     decodedFrames: number,
@@ -84,13 +89,13 @@ class FPSController implements ComponentAPI {
           totalDroppedFrames: droppedFrames,
         });
         if (droppedFPS > 0) {
-          // logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
+          // hls.logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
           if (
             currentDropped >
             hls.config.fpsDroppedMonitoringThreshold * currentDecoded
           ) {
             let currentLevel = hls.currentLevel;
-            logger.warn(
+            hls.logger.warn(
               'drop FPS ratio greater than max allowed value for currentLevel: ' +
                 currentLevel,
             );

package/src/controller/fragment-finders.ts

@@ -1,5 +1,6 @@
 import BinarySearch from '../utils/binary-search';
-import { Fragment } from '../loader/fragment';
+import type { Fragment, MediaFragment } from '../loader/fragment';
+import type { LevelDetails } from '../loader/level-details';
 
 /**
  * Returns first fragment whose endPdt value exceeds the given PDT, or null.
@@ -8,10 +9,10 @@ import { Fragment } from '../loader/fragment';
  * @param maxFragLookUpTolerance - The amount of time that a fragment's start/end can be within in order to be considered contiguous
  */
 export function findFragmentByPDT(
-  fragments: Array<Fragment>,
+  fragments: MediaFragment[],
   PDTValue: number | null,
   maxFragLookUpTolerance: number,
-): Fragment | null {
+): MediaFragment | null {
   if (
     PDTValue === null ||
     !Array.isArray(fragments) ||
@@ -54,23 +55,27 @@ export function findFragmentByPDT(
  * @returns a matching fragment or null
  */
 export function findFragmentByPTS(
-  fragPrevious: Fragment | null,
-  fragments: Array<Fragment>,
+  fragPrevious: MediaFragment | null,
+  fragments: MediaFragment[],
   bufferEnd: number = 0,
   maxFragLookUpTolerance: number = 0,
   nextFragLookupTolerance: number = 0.005,
-): Fragment | null {
-  let fragNext: Fragment | null = null;
+): MediaFragment | null {
+  let fragNext: MediaFragment | null = null;
   if (fragPrevious) {
-    fragNext =
-      fragments[
-        (fragPrevious.sn as number) - (fragments[0].sn as number) + 1
-      ] || null;
+    fragNext = fragments[1 + fragPrevious.sn - fragments[0].sn] || null;
     // check for buffer-end rounding error
-    const bufferEdgeError = fragPrevious.endDTS - bufferEnd;
+    const bufferEdgeError = (fragPrevious.endDTS as number) - bufferEnd;
     if (bufferEdgeError > 0 && bufferEdgeError < 0.0000015) {
       bufferEnd += 0.0000015;
     }
+    if (
+      fragNext &&
+      fragPrevious.level !== fragNext.level &&
+      fragNext.end <= fragPrevious.end
+    ) {
+      fragNext = fragments[2 + fragPrevious.sn - fragments[0].sn] || null;
+    }
   } else if (bufferEnd === 0 && fragments[0].start === 0) {
     fragNext = fragments[0];
   }
@@ -135,7 +140,7 @@ function fragmentWithinFastStartSwitch(
 export function fragmentWithinToleranceTest(
   bufferEnd = 0,
   maxFragLookUpTolerance = 0,
-  candidate: Fragment,
+  candidate: MediaFragment,
 ) {
   // eagerly accept an accurate match (no tolerance)
   if (
@@ -189,7 +194,7 @@ export function fragmentWithinToleranceTest(
 export function pdtWithinToleranceTest(
   pdtBufferEnd: number,
   maxFragLookUpTolerance: number,
-  candidate: Fragment,
+  candidate: MediaFragment,
 ): boolean {
   const candidateLookupTolerance =
     Math.min(
@@ -203,9 +208,9 @@ export function pdtWithinToleranceTest(
 }
 
 export function findFragWithCC(
-  fragments: Fragment[],
+  fragments: MediaFragment[],
   cc: number,
-): Fragment | null {
+): MediaFragment | null {
   return BinarySearch.search(fragments, (candidate) => {
     if (candidate.cc < cc) {
       return 1;
@@ -216,3 +221,26 @@ export function findFragWithCC(
     }
   });
 }
+
+export function findNearestWithCC(
+  details: LevelDetails | undefined,
+  cc: number,
+  fragment: MediaFragment,
+): MediaFragment | null {
+  if (details) {
+    if (details.startCC <= cc && details.endCC >= cc) {
+      const start = fragment.start;
+      const end = fragment.end;
+      return BinarySearch.search(details.fragments, (candidate) => {
+        if (candidate.cc < cc || candidate.end <= start) {
+          return 1;
+        } else if (candidate.cc > cc || candidate.start >= end) {
+          return -1;
+        } else {
+          return 0;
+        }
+      });
+    }
+  }
+  return null;
+}