hls.js 1.5.17 → 1.5.19

package/src/utils/level-helper.ts

@@ -8,7 +8,12 @@ import { LevelDetails } from '../loader/level-details';
 import type { Level } from '../types/level';
 import { DateRange } from '../loader/date-range';
 
-type FragmentIntersection = (oldFrag: Fragment, newFrag: Fragment) => void;
+type FragmentIntersection = (
+  oldFrag: Fragment,
+  newFrag: Fragment,
+  newFragIndex: number,
+  newFragments: Fragment[],
+) => void;
 type PartIntersection = (oldPart: Part, newPart: Part) => void;
 
 export function updatePTS(
@@ -106,7 +111,7 @@ export function updateFragPTSDTS(
   if (!details || sn < details.startSN || sn > details.endSN) {
     return 0;
   }
-  let i;
+  let i: number;
   const fragIdx = sn - details.startSN;
   const fragments = details.fragments;
   // update frag reference in fragments array
@@ -152,18 +157,19 @@ export function mergeDetails(
     delete oldDetails.fragmentHint.endPTS;
   }
   // check if old/new playlists have fragments in common
-  // loop through overlapping SN and update startPTS , cc, and duration if any found
-  let ccOffset = 0;
-  let PTSFrag;
+  // loop through overlapping SN and update startPTS, cc, and duration if any found
+  let PTSFrag: Fragment | undefined;
   mapFragmentIntersection(
     oldDetails,
     newDetails,
-    (oldFrag: Fragment, newFrag: Fragment) => {
-      if (oldFrag.relurl) {
-        // Do not compare CC if the old fragment has no url. This is a level.fragmentHint used by LL-HLS parts.
-        // It maybe be off by 1 if it was created before any parts or discontinuity tags were appended to the end
-        // of the playlist.
-        ccOffset = oldFrag.cc - newFrag.cc;
+    (oldFrag, newFrag, newFragIndex, newFragments) => {
+      if (newDetails.skippedSegments) {
+        if (newFrag.cc !== oldFrag.cc) {
+          const ccOffset = oldFrag.cc - newFrag.cc;
+          for (let i = newFragIndex; i < newFragments.length; i++) {
+            newFragments[i].cc += ccOffset;
+          }
+        }
       }
       if (
         Number.isFinite(oldFrag.startPTS) &&
@@ -196,10 +202,11 @@ export function mergeDetails(
     },
   );
 
+  const newFragments = newDetails.fragments;
   if (currentInitSegment) {
     const fragmentsToCheck = newDetails.fragmentHint
-      ? newDetails.fragments.concat(newDetails.fragmentHint)
-      : newDetails.fragments;
+      ? newFragments.concat(newDetails.fragmentHint)
+      : newFragments;
     fragmentsToCheck.forEach((frag) => {
       if (
         frag &&
@@ -212,34 +219,26 @@ export function mergeDetails(
   }
 
   if (newDetails.skippedSegments) {
-    newDetails.deltaUpdateFailed = newDetails.fragments.some((frag) => !frag);
+    newDetails.deltaUpdateFailed = newFragments.some((frag) => !frag);
     if (newDetails.deltaUpdateFailed) {
       logger.warn(
         '[level-helper] Previous playlist missing segments skipped in delta playlist',
       );
       for (let i = newDetails.skippedSegments; i--; ) {
-        newDetails.fragments.shift();
+        newFragments.shift();
+      }
+      newDetails.startSN = newFragments[0].sn as number;
+    } else {
+      if (newDetails.canSkipDateRanges) {
+        newDetails.dateRanges = mergeDateRanges(
+          oldDetails.dateRanges,
+          newDetails.dateRanges,
+          newDetails.recentlyRemovedDateranges,
+        );
       }
-      newDetails.startSN = newDetails.fragments[0].sn as number;
-      newDetails.startCC = newDetails.fragments[0].cc;
-    } else if (newDetails.canSkipDateRanges) {
-      newDetails.dateRanges = mergeDateRanges(
-        oldDetails.dateRanges,
-        newDetails.dateRanges,
-        newDetails.recentlyRemovedDateranges,
-      );
-    }
-  }
-
-  const newFragments = newDetails.fragments;
-  if (ccOffset) {
-    logger.warn('discontinuity sliding from playlist, take drift into account');
-    for (let i = 0; i < newFragments.length; i++) {
-      newFragments[i].cc += ccOffset;
     }
-  }
-  if (newDetails.skippedSegments) {
     newDetails.startCC = newDetails.fragments[0].cc;
+    newDetails.endCC = newFragments[newFragments.length - 1].cc;
   }
 
   // Merge parts
@@ -257,10 +256,10 @@ export function mergeDetails(
     updateFragPTSDTS(
       newDetails,
       PTSFrag,
-      PTSFrag.startPTS,
-      PTSFrag.endPTS,
-      PTSFrag.startDTS,
-      PTSFrag.endDTS,
+      PTSFrag.startPTS as number,
+      PTSFrag.endPTS as number,
+      PTSFrag.startDTS as number,
+      PTSFrag.endDTS as number,
     );
   } else {
     // ensure that delta is within oldFragments range
@@ -371,7 +370,7 @@ export function mapFragmentIntersection(
       newFrag = newDetails.fragments[i] = oldFrag;
     }
     if (oldFrag && newFrag) {
-      intersectionFn(oldFrag, newFrag);
+      intersectionFn(oldFrag, newFrag, i, newFrags);
     }
   }
 }

package/src/utils/mediakeys-helper.ts

@@ -1,5 +1,7 @@
-import type { DRMSystemOptions, EMEControllerConfig } from '../config';
 import { optionalSelf } from './global';
+import { changeEndianness } from './keysystem-util';
+import { base64Decode } from './numeric-encoding-utils';
+import type { DRMSystemOptions, EMEControllerConfig } from '../config';
 
 /**
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMediaKeySystemAccess
@@ -163,3 +165,34 @@ function createMediaKeySystemConfigurations(
 
   return [baseConfig];
 }
+
+export function parsePlayReadyWRM(keyBytes: Uint8Array): Uint8Array | null {
+  const keyBytesUtf16 = new Uint16Array(
+    keyBytes.buffer,
+    keyBytes.byteOffset,
+    keyBytes.byteLength / 2,
+  );
+  const keyByteStr = String.fromCharCode.apply(null, Array.from(keyBytesUtf16));
+
+  // Parse Playready WRMHeader XML
+  const xmlKeyBytes = keyByteStr.substring(
+    keyByteStr.indexOf('<'),
+    keyByteStr.length,
+  );
+  const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(xmlKeyBytes, 'text/xml');
+  const keyData = xmlDoc.getElementsByTagName('KID')[0];
+  if (keyData) {
+    const keyId = keyData.childNodes[0]
+      ? keyData.childNodes[0].nodeValue
+      : keyData.getAttribute('VALUE');
+    if (keyId) {
+      const keyIdArray = base64Decode(keyId).subarray(0, 16);
+      // KID value in PRO is a base64-encoded little endian GUID interpretation of UUID
+      // KID value in ‘tenc’ is a big endian UUID GUID interpretation of UUID
+      changeEndianness(keyIdArray);
+      return keyIdArray;
+    }
+  }
+  return null;
+}

package/src/utils/xhr-loader.ts

@@ -203,59 +203,62 @@ class XhrLoader implements Loader<LoaderContext> {
         xhr.onprogress = null;
         const status = xhr.status;
         // http status between 200 to 299 are all successful
-        const useResponse = xhr.responseType !== 'text';
-        if (
-          status >= 200 &&
-          status < 300 &&
-          ((useResponse && xhr.response) || xhr.responseText !== null)
-        ) {
-          stats.loading.end = Math.max(
-            self.performance.now(),
-            stats.loading.first,
-          );
-          const data = useResponse ? xhr.response : xhr.responseText;
-          const len =
-            xhr.responseType === 'arraybuffer' ? data.byteLength : data.length;
-          stats.loaded = stats.total = len;
-          stats.bwEstimate =
-            (stats.total * 8000) / (stats.loading.end - stats.loading.first);
-          if (!this.callbacks) {
-            return;
-          }
-          const onProgress = this.callbacks.onProgress;
-          if (onProgress) {
-            onProgress(stats, context, data, xhr);
-          }
-          if (!this.callbacks) {
+        const useResponseText =
+          xhr.responseType === 'text' ? xhr.responseText : null;
+        if (status >= 200 && status < 300) {
+          const data = useResponseText ?? xhr.response;
+          if (data != null) {
+            stats.loading.end = Math.max(
+              self.performance.now(),
+              stats.loading.first,
+            );
+            const len =
+              xhr.responseType === 'arraybuffer'
+                ? data.byteLength
+                : data.length;
+            stats.loaded = stats.total = len;
+            stats.bwEstimate =
+              (stats.total * 8000) / (stats.loading.end - stats.loading.first);
+            if (!this.callbacks) {
+              return;
+            }
+            const onProgress = this.callbacks.onProgress;
+            if (onProgress) {
+              onProgress(stats, context, data, xhr);
+            }
+            if (!this.callbacks) {
+              return;
+            }
+            const response: LoaderResponse = {
+              url: xhr.responseURL,
+              data: data,
+              code: status,
+            };
+
+            this.callbacks.onSuccess(response, stats, context, xhr);
             return;
           }
-          const response: LoaderResponse = {
-            url: xhr.responseURL,
-            data: data,
-            code: status,
-          };
+        }
 
-          this.callbacks.onSuccess(response, stats, context, xhr);
+        // Handle bad status or nullish response
+        const retryConfig = config.loadPolicy.errorRetry;
+        const retryCount = stats.retry;
+        // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
+        const response: LoaderResponse = {
+          url: context.url,
+          data: undefined,
+          code: status,
+        };
+        if (shouldRetry(retryConfig, retryCount, false, response)) {
+          this.retry(retryConfig);
         } else {
-          const retryConfig = config.loadPolicy.errorRetry;
-          const retryCount = stats.retry;
-          // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
-          const response: LoaderResponse = {
-            url: context.url,
-            data: undefined,
-            code: status,
-          };
-          if (shouldRetry(retryConfig, retryCount, false, response)) {
-            this.retry(retryConfig);
-          } else {
-            logger.error(`${status} while loading ${context.url}`);
-            this.callbacks!.onError(
-              { code: status, text: xhr.statusText },
-              context,
-              xhr,
-              stats,
-            );
-          }
+          logger.error(`${status} while loading ${context.url}`);
+          this.callbacks!.onError(
+            { code: status, text: xhr.statusText },
+            context,
+            xhr,
+            stats,
+          );
         }
       }
     }