hls.js 1.5.14-0.canary.10559 → 1.5.15

package/src/loader/date-range.ts

@@ -1,12 +1,10 @@
 import { AttrList } from '../utils/attr-list';
 import { logger } from '../utils/logger';
-import type { Fragment } from './fragment';
 
 // Avoid exporting const enum so that these values can be inlined
 const enum DateRangeAttribute {
   ID = 'ID',
   CLASS = 'CLASS',
-  CUE = 'CUE',
   START_DATE = 'START-DATE',
   DURATION = 'DURATION',
   END_DATE = 'END-DATE',
@@ -14,22 +12,12 @@ const enum DateRangeAttribute {
   PLANNED_DURATION = 'PLANNED-DURATION',
   SCTE35_OUT = 'SCTE35-OUT',
   SCTE35_IN = 'SCTE35-IN',
-  SCTE35_CMD = 'SCTE35-CMD',
 }
 
-export type DateRangeCue = {
-  pre: boolean;
-  post: boolean;
-  once: boolean;
-};
-
-const CLASS_INTERSTITIAL = 'com.apple.hls.interstitial';
-
 export function isDateRangeCueAttribute(attrName: string): boolean {
   return (
     attrName !== DateRangeAttribute.ID &&
     attrName !== DateRangeAttribute.CLASS &&
-    attrName !== DateRangeAttribute.CUE &&
     attrName !== DateRangeAttribute.START_DATE &&
     attrName !== DateRangeAttribute.DURATION &&
     attrName !== DateRangeAttribute.END_DATE &&
@@ -40,27 +28,17 @@ export function isDateRangeCueAttribute(attrName: string): boolean {
 export function isSCTE35Attribute(attrName: string): boolean {
   return (
     attrName === DateRangeAttribute.SCTE35_OUT ||
-    attrName === DateRangeAttribute.SCTE35_IN ||
-    attrName === DateRangeAttribute.SCTE35_CMD
+    attrName === DateRangeAttribute.SCTE35_IN
   );
 }
 
 export class DateRange {
   public attr: AttrList;
-  public tagAnchor: Fragment | null;
-  public tagOrder: number;
   private _startDate: Date;
   private _endDate?: Date;
-  private _cue?: DateRangeCue;
   private _badValueForSameId?: string;
 
-  constructor(
-    dateRangeAttr: AttrList,
-    dateRangeWithSameId?: DateRange | undefined,
-    tagCount: number = 0,
-  ) {
-    this.tagAnchor = dateRangeWithSameId?.tagAnchor || null;
-    this.tagOrder = dateRangeWithSameId?.tagOrder ?? tagCount;
+  constructor(dateRangeAttr: AttrList, dateRangeWithSameId?: DateRange) {
     if (dateRangeWithSameId) {
       const previousAttr = dateRangeWithSameId.attr;
       for (const key in previousAttr) {
@@ -83,13 +61,9 @@ export class DateRange {
       );
     }
     this.attr = dateRangeAttr;
-    this._startDate = dateRangeWithSameId
-      ? dateRangeWithSameId.startDate
-      : new Date(dateRangeAttr[DateRangeAttribute.START_DATE]);
+    this._startDate = new Date(dateRangeAttr[DateRangeAttribute.START_DATE]);
     if (DateRangeAttribute.END_DATE in this.attr) {
-      const endDate =
-        dateRangeWithSameId?.endDate ||
-        new Date(this.attr[DateRangeAttribute.END_DATE]);
+      const endDate = new Date(this.attr[DateRangeAttribute.END_DATE]);
       if (Number.isFinite(endDate.getTime())) {
         this._endDate = endDate;
       }
@@ -104,36 +78,6 @@ export class DateRange {
     return this.attr.CLASS;
   }
 
-  get cue(): DateRangeCue {
-    const _cue = this._cue;
-    if (_cue === undefined) {
-      return (this._cue = this.attr.enumeratedStringList(
-        this.attr.CUE ? 'CUE' : 'X-CUE',
-        {
-          pre: false,
-          post: false,
-          once: false,
-        },
-      ));
-    }
-    return _cue;
-  }
-
-  get startTime(): number {
-    const { tagAnchor } = this;
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
-    if (tagAnchor === null || tagAnchor.programDateTime === null) {
-      logger.warn(
-        `Expected tagAnchor Fragment with PDT set for DateRange "${this.id}": ${tagAnchor}`,
-      );
-      return NaN;
-    }
-    return (
-      tagAnchor.start +
-      (this.startDate.getTime() - tagAnchor.programDateTime) / 1000
-    );
-  }
-
   get startDate(): Date {
     return this._startDate;
   }
@@ -176,23 +120,13 @@ export class DateRange {
     return this.attr.bool(DateRangeAttribute.END_ON_NEXT);
   }
 
-  get isInterstitial(): boolean {
-    return this.class === CLASS_INTERSTITIAL;
-  }
-
   get isValid(): boolean {
     return (
       !!this.id &&
       !this._badValueForSameId &&
       Number.isFinite(this.startDate.getTime()) &&
       (this.duration === null || this.duration >= 0) &&
-      (!this.endOnNext || !!this.class) &&
-      (!this.attr.CUE ||
-        (!this.cue.pre && !this.cue.post) ||
-        this.cue.pre !== this.cue.post) &&
-      (!this.isInterstitial ||
-        'X-ASSET-URI' in this.attr ||
-        'X-ASSET-LIST' in this.attr)
+      (!this.endOnNext || !!this.class)
     );
   }
 }

package/src/loader/fragment-loader.ts

@@ -1,17 +1,18 @@
 import { ErrorTypes, ErrorDetails } from '../errors';
+import { Fragment } from './fragment';
+import {
+  Loader,
+  LoaderConfiguration,
+  FragmentLoaderContext,
+} from '../types/loader';
 import { getLoaderConfigWithoutReties } from '../utils/error-helper';
 import type { HlsConfig } from '../config';
-import type { BaseSegment, Fragment, Part } from './fragment';
+import type { BaseSegment, Part } from './fragment';
 import type {
   ErrorData,
   FragLoadedData,
   PartsLoadedData,
 } from '../types/events';
-import type {
-  Loader,
-  LoaderConfiguration,
-  FragmentLoaderContext,
-} from '../types/loader';
 
 const MIN_CHUNK_SIZE = Math.pow(2, 17); // 128kb
 
@@ -76,11 +77,13 @@ export default class FragmentLoader {
           frag.gap = false;
         }
       }
-      const loader = (this.loader = FragmentILoader
-        ? new FragmentILoader(config)
-        : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
+      const loader =
+        (this.loader =
+        frag.loader =
+          FragmentILoader
+            ? new FragmentILoader(config)
+            : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
       const loaderContext = createLoaderContext(frag);
-      frag.loader = loader;
       const loadPolicy = getLoaderConfigWithoutReties(
         config.fragLoadPolicy.default,
       );
@@ -185,11 +188,13 @@ export default class FragmentLoader {
         reject(createGapLoadError(frag, part));
         return;
       }
-      const loader = (this.loader = FragmentILoader
-        ? new FragmentILoader(config)
-        : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
+      const loader =
+        (this.loader =
+        frag.loader =
+          FragmentILoader
+            ? new FragmentILoader(config)
+            : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
       const loaderContext = createLoaderContext(frag, part);
-      frag.loader = loader;
       // Should we define another load policy for parts?
       const loadPolicy = getLoaderConfigWithoutReties(
         config.fragLoadPolicy.default,
@@ -331,11 +336,8 @@ function createLoaderContext(
   if (Number.isFinite(start) && Number.isFinite(end)) {
     let byteRangeStart = start;
     let byteRangeEnd = end;
-    if (
-      frag.sn === 'initSegment' &&
-      isMethodFullSegmentAesCbc(frag.decryptdata?.method)
-    ) {
-      // MAP segment encrypted with method 'AES-128' or 'AES-256' (cbc), when served with HTTP Range,
+    if (frag.sn === 'initSegment' && frag.decryptdata?.method === 'AES-128') {
+      // MAP segment encrypted with method 'AES-128', when served with HTTP Range,
       // has the unencrypted size specified in the range.
       // Ref: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
       const fragmentLen = end - start;
@@ -370,10 +372,6 @@ function createGapLoadError(frag: Fragment, part?: Part): LoadError {
   return new LoadError(errorData);
 }
 
-function isMethodFullSegmentAesCbc(method) {
-  return method === 'AES-128' || method === 'AES-256';
-}
-
 export class LoadError extends Error {
   public readonly data: FragLoadFailResult;
   constructor(data: FragLoadFailResult) {

package/src/loader/fragment.ts

@@ -90,10 +90,6 @@ export class BaseSegment {
   }
 }
 
-export interface MediaFragment extends Fragment {
-  sn: number;
-}
-
 /**
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
  */
@@ -127,9 +123,9 @@ export class Fragment extends BaseSegment {
   // The ending Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
   public endPTS?: number;
   // The starting Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
-  public startDTS?: number;
+  public startDTS!: number;
   // The ending Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
-  public endDTS?: number;
+  public endDTS!: number;
   // The start time of the fragment, as listed in the manifest. Updated after transmux complete.
   public start: number = 0;
   // Set by `updateFragPTSDTS` in level-helper
@@ -278,13 +274,13 @@ export class Part extends BaseSegment {
   public readonly gap: boolean = false;
   public readonly independent: boolean = false;
   public readonly relurl: string;
-  public readonly fragment: MediaFragment;
+  public readonly fragment: Fragment;
   public readonly index: number;
   public stats: LoadStats = new LoadStats();
 
   constructor(
     partAttrs: AttrList,
-    frag: MediaFragment,
+    frag: Fragment,
     baseurl: string,
     index: number,
     previous?: Part,

package/src/loader/key-loader.ts

@@ -1,5 +1,5 @@
 import { ErrorTypes, ErrorDetails } from '../errors';
-import type {
+import {
   LoaderStats,
   LoaderResponse,
   LoaderConfiguration,
@@ -194,8 +194,6 @@ export default class KeyLoader implements ComponentAPI {
         }
         return this.loadKeyEME(keyInfo, frag);
       case 'AES-128':
-      case 'AES-256':
-      case 'AES-256-CTR':
         return this.loadKeyHTTP(keyInfo, frag);
       default:
         return Promise.reject(

package/src/loader/level-details.ts

@@ -1,6 +1,7 @@
-import type { Fragment, MediaFragment, Part } from './fragment';
-import type { DateRange } from './date-range';
+import { Part } from './fragment';
+import type { Fragment } from './fragment';
 import type { AttrList } from '../utils/attr-list';
+import type { DateRange } from './date-range';
 import type { VariableMap } from '../types/level';
 
 const DEFAULT_TARGET_DURATION = 10;
@@ -14,11 +15,10 @@ export class LevelDetails {
   public averagetargetduration?: number;
   public endCC: number = 0;
   public endSN: number = 0;
-  public fragments: MediaFragment[];
-  public fragmentHint?: MediaFragment;
+  public fragments: Fragment[];
+  public fragmentHint?: Fragment;
   public partList: Part[] | null = null;
   public dateRanges: Record<string, DateRange>;
-  public dateRangeTagCount: number = 0;
   public live: boolean = true;
   public ageHeader: number = 0;
   public advancedDateTime?: number;
@@ -148,7 +148,7 @@ export class LevelDetails {
 
   get lastPartSn(): number {
     if (this.partList?.length) {
-      return this.partList[this.partList.length - 1].fragment.sn;
+      return this.partList[this.partList.length - 1].fragment.sn as number;
     }
     return this.endSN;
   }

package/src/loader/level-key.ts

@@ -2,7 +2,6 @@ import {
   changeEndianness,
   convertDataUriToArrayBytes,
 } from '../utils/keysystem-util';
-import { isFullSegmentEncryption } from '../utils/encryption-methods-util';
 import { KeySystemFormats } from '../utils/mediakeys-helper';
 import { mp4pssh } from '../utils/mp4-tools';
 import { logger } from '../utils/logger';
@@ -52,14 +51,13 @@ export class LevelKey implements DecryptData {
     this.keyFormatVersions = formatversions;
     this.iv = iv;
     this.encrypted = method ? method !== 'NONE' : false;
-    this.isCommonEncryption =
-      this.encrypted && !isFullSegmentEncryption(method);
+    this.isCommonEncryption = this.encrypted && method !== 'AES-128';
   }
 
   public isSupported(): boolean {
     // If it's Segment encryption or No encryption, just select that key system
     if (this.method) {
-      if (isFullSegmentEncryption(this.method) || this.method === 'NONE') {
+      if (this.method === 'AES-128' || this.method === 'NONE') {
         return true;
       }
       if (this.keyFormat === 'identity') {
@@ -90,15 +88,16 @@ export class LevelKey implements DecryptData {
       return null;
     }
 
-    if (isFullSegmentEncryption(this.method) && this.uri && !this.iv) {
+    if (this.method === 'AES-128' && this.uri && !this.iv) {
       if (typeof sn !== 'number') {
         // We are fetching decryption data for a initialization segment
-        // If the segment was encrypted with AES-128/256
+        // If the segment was encrypted with AES-128
         // It must have an IV defined. We cannot substitute the Segment Number in.
-        logger.warn(
-          `missing IV for initialization segment with method="${this.method}" - compliance issue`,
-        );
-
+        if (this.method === 'AES-128' && !this.iv) {
+          logger.warn(
+            `missing IV for initialization segment with method="${this.method}" - compliance issue`,
+          );
+        }
         // Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
         sn = 0;
       }