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

package/src/utils/rendition-helper.ts

@@ -13,6 +13,7 @@ export type CodecSetTier = {
   minBitrate: number;
   minHeight: number;
   minFramerate: number;
+  minIndex: number;
   maxScore: number;
   videoRanges: Record<string, number>;
   channels: Record<string, number>;
@@ -32,6 +33,7 @@ type StartParameters = {
   preferHDR: boolean;
   minFramerate: number;
   minBitrate: number;
+  minIndex: number;
 };
 
 export function getStartCodecTier(
@@ -44,13 +46,15 @@ export function getStartCodecTier(
   const codecSets = Object.keys(codecTiers);
   const channelsPreference = audioPreference?.channels;
   const audioCodecPreference = audioPreference?.audioCodec;
+  const videoCodecPreference = videoPreference?.videoCodec;
   const preferStereo = channelsPreference && parseInt(channelsPreference) === 2;
   // Use first level set to determine stereo, and minimum resolution and framerate
-  let hasStereo = true;
+  let hasStereo = false;
   let hasCurrentVideoRange = false;
   let minHeight = Infinity;
   let minFramerate = Infinity;
   let minBitrate = Infinity;
+  let minIndex = Infinity;
   let selectedScore = 0;
   let videoRanges: Array<VideoRange> = [];
 
@@ -61,7 +65,7 @@ export function getStartCodecTier(
 
   for (let i = codecSets.length; i--; ) {
     const tier = codecTiers[codecSets[i]];
-    hasStereo = tier.channels[2] > 0;
+    hasStereo ||= tier.channels[2] > 0;
     minHeight = Math.min(minHeight, tier.minHeight);
     minFramerate = Math.min(minFramerate, tier.minFramerate);
     minBitrate = Math.min(minBitrate, tier.minBitrate);
@@ -70,7 +74,6 @@ export function getStartCodecTier(
     );
     if (matchingVideoRanges.length > 0) {
       hasCurrentVideoRange = true;
-      videoRanges = matchingVideoRanges;
     }
   }
   minHeight = Number.isFinite(minHeight) ? minHeight : 0;
@@ -82,8 +85,8 @@ export function getStartCodecTier(
   // If there are no variants with matching preference, set currentVideoRange to undefined
   if (!hasCurrentVideoRange) {
     currentVideoRange = undefined;
-    videoRanges = [];
   }
+  const hasMultipleSets = codecSets.length > 1;
   const codecSet = codecSets.reduce(
     (selected: string | undefined, candidate: string) => {
       // Remove candiates which do not meet bitrate, default audio, stereo or channels preference, 1080p or lower, 30fps or lower, or SDR/HDR selection if present
@@ -91,80 +94,99 @@ export function getStartCodecTier(
       if (candidate === selected) {
         return selected;
       }
-      if (candidateTier.minBitrate > currentBw) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`,
-        );
-        return selected;
-      }
-      if (!candidateTier.hasDefaultAudio) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `no renditions with default or auto-select sound found`,
-        );
-        return selected;
-      }
-      if (
-        audioCodecPreference &&
-        candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0
-      ) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `audio codec preference "${audioCodecPreference}" not found`,
-        );
-        return selected;
-      }
-      if (channelsPreference && !preferStereo) {
-        if (!candidateTier.channels[channelsPreference]) {
+      videoRanges = hasCurrentVideoRange
+        ? allowedVideoRanges.filter(
+            (range) => candidateTier.videoRanges[range] > 0,
+          )
+        : [];
+      if (hasMultipleSets) {
+        if (candidateTier.minBitrate > currentBw) {
           logStartCodecCandidateIgnored(
             candidate,
-            `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(
-              candidateTier.channels,
-            )})`,
+            `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`,
+          );
+          return selected;
+        }
+        if (!candidateTier.hasDefaultAudio) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `no renditions with default or auto-select sound found`,
+          );
+          return selected;
+        }
+        if (
+          audioCodecPreference &&
+          candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0
+        ) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `audio codec preference "${audioCodecPreference}" not found`,
+          );
+          return selected;
+        }
+        if (channelsPreference && !preferStereo) {
+          if (!candidateTier.channels[channelsPreference]) {
+            logStartCodecCandidateIgnored(
+              candidate,
+              `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(
+                candidateTier.channels,
+              )})`,
+            );
+            return selected;
+          }
+        } else if (
+          (!audioCodecPreference || preferStereo) &&
+          hasStereo &&
+          candidateTier.channels['2'] === 0
+        ) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `no renditions with stereo sound found`,
+          );
+          return selected;
+        }
+        if (candidateTier.minHeight > maxHeight) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`,
+          );
+          return selected;
+        }
+        if (candidateTier.minFramerate > maxFramerate) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`,
+          );
+          return selected;
+        }
+        if (
+          !videoRanges.some((range) => candidateTier.videoRanges[range] > 0)
+        ) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `no variants with VIDEO-RANGE of ${JSON.stringify(
+              videoRanges,
+            )} found`,
+          );
+          return selected;
+        }
+        if (
+          videoCodecPreference &&
+          candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0
+        ) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `video codec preference "${videoCodecPreference}" not found`,
+          );
+          return selected;
+        }
+        if (candidateTier.maxScore < selectedScore) {
+          logStartCodecCandidateIgnored(
+            candidate,
+            `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`,
           );
           return selected;
         }
-      } else if (
-        (!audioCodecPreference || preferStereo) &&
-        hasStereo &&
-        candidateTier.channels['2'] === 0
-      ) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `no renditions with stereo sound found`,
-        );
-        return selected;
-      }
-      if (candidateTier.minHeight > maxHeight) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`,
-        );
-        return selected;
-      }
-      if (candidateTier.minFramerate > maxFramerate) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`,
-        );
-        return selected;
-      }
-      if (!videoRanges.some((range) => candidateTier.videoRanges[range] > 0)) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `no variants with VIDEO-RANGE of ${JSON.stringify(
-            videoRanges,
-          )} found`,
-        );
-        return selected;
-      }
-      if (candidateTier.maxScore < selectedScore) {
-        logStartCodecCandidateIgnored(
-          candidate,
-          `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`,
-        );
-        return selected;
       }
       // Remove candiates with less preferred codecs or more errors
       if (
@@ -175,6 +197,7 @@ export function getStartCodecTier(
       ) {
         return selected;
       }
+      minIndex = candidateTier.minIndex;
       selectedScore = candidateTier.maxScore;
       return candidate;
     },
@@ -186,6 +209,7 @@ export function getStartCodecTier(
     preferHDR,
     minFramerate,
     minBitrate,
+    minIndex,
   };
 }
 
@@ -243,7 +267,7 @@ export function getCodecTiers(
 ): Record<string, CodecSetTier> {
   return levels
     .slice(minAutoLevel, maxAutoLevel + 1)
-    .reduce((tiers: Record<string, CodecSetTier>, level) => {
+    .reduce((tiers: Record<string, CodecSetTier>, level, index) => {
       if (!level.codecSet) {
         return tiers;
       }
@@ -254,6 +278,7 @@ export function getCodecTiers(
           minBitrate: Infinity,
           minHeight: Infinity,
           minFramerate: Infinity,
+          minIndex: index,
           maxScore: 0,
           videoRanges: { SDR: 0 },
           channels: { '2': 0 },
@@ -265,6 +290,7 @@ export function getCodecTiers(
       const lesserWidthOrHeight = Math.min(level.height, level.width);
       tier.minHeight = Math.min(tier.minHeight, lesserWidthOrHeight);
       tier.minFramerate = Math.min(tier.minFramerate, level.frameRate);
+      tier.minIndex = Math.min(tier.minIndex, index);
       tier.maxScore = Math.max(tier.maxScore, level.score);
       tier.fragmentError += level.fragmentError;
       tier.videoRanges[level.videoRange] =

package/src/utils/utf8-utils.ts

@@ -0,0 +1,18 @@
+// breaking up those two types in order to clarify what is happening in the decoding path.
+type DecodedFrame<T> = { key: string; data: T; info?: any };
+export type Frame = DecodedFrame<ArrayBuffer | string>;
+// http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
+// http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
+/* utf.js - UTF-8 <=> UTF-16 convertion
+ *
+ * Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
+ * Version: 1.0
+ * LastModified: Dec 25 1999
+ * This library is free.  You can redistribute it and/or modify it.
+ */
+
+export function strToUtf8array(str: string): Uint8Array {
+  return Uint8Array.from(unescape(encodeURIComponent(str)), (c) =>
+    c.charCodeAt(0),
+  );
+}

package/src/utils/variable-substitution.ts

@@ -9,25 +9,6 @@ export function hasVariableReferences(str: string): boolean {
   return VARIABLE_REPLACEMENT_REGEX.test(str);
 }
 
-export function substituteVariablesInAttributes(
-  parsed: Pick<
-    ParsedMultivariantPlaylist | LevelDetails,
-    'variableList' | 'hasVariableRefs' | 'playlistParsingError'
-  >,
-  attr: AttrList,
-  attributeNames: string[],
-) {
-  if (parsed.variableList !== null || parsed.hasVariableRefs) {
-    for (let i = attributeNames.length; i--; ) {
-      const name = attributeNames[i];
-      const value = attr[name];
-      if (value) {
-        attr[name] = substituteVariables(parsed, value);
-      }
-    }
-  }
-}
-
 export function substituteVariables(
   parsed: Pick<
     ParsedMultivariantPlaylist | LevelDetails,

package/src/utils/webvtt-parser.ts

@@ -1,5 +1,6 @@
 import { VTTParser } from './vttparser';
-import { utf8ArrayToStr } from '../demux/id3';
+import { utf8ArrayToStr } from '@svta/common-media-library/utils/utf8ArrayToStr';
+import { hash } from './hash';
 import {
   RationalTimestamp,
   toMpegTsClockFromTimescale,
@@ -45,17 +46,6 @@ const cueString2millis = function (timeString: string) {
   return ts;
 };
 
-// From https://github.com/darkskyapp/string-hash
-const hash = function (text: string) {
-  let hash = 5381;
-  let i = text.length;
-  while (i) {
-    hash = (hash * 33) ^ text.charCodeAt(--i);
-  }
-
-  return (hash >>> 0).toString();
-};
-
 // Create a unique hash id for a cue based on start/end times and text.
 // This helps timeline-controller to avoid showing repeated captions.
 export function generateCueId(