hls.js 1.5.14-0.canary.10668 → 1.5.14-0.canary.10670

package/dist/hls.light.mjs

@@ -440,7 +440,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.14-0.canary.10668"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.14-0.canary.10670"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -2490,7 +2490,7 @@ function isCodecMediaSourceSupported(codec, type, preferManagedMediaSource = tru
   return (_MediaSource$isTypeSu = MediaSource == null ? void 0 : MediaSource.isTypeSupported(mimeTypeForCodec(codec, type))) != null ? _MediaSource$isTypeSu : false;
 }
 function mimeTypeForCodec(codec, type) {
-  return `${type}/mp4;codecs="${codec}"`;
+  return `${type}/mp4;codecs=${codec}`;
 }
 function videoCodecPreferenceValue(videoCodec) {
   if (videoCodec) {
@@ -2541,15 +2541,28 @@ function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
 function pickMostCompleteCodecName(parsedCodec, levelCodec) {
   // Parsing of mp4a codecs strings in mp4-tools from media is incomplete as of d8c6c7a
   // so use level codec is parsed codec is unavailable or incomplete
-  if (parsedCodec && parsedCodec !== 'mp4a') {
+  if (parsedCodec && (parsedCodec.length > 4 || ['ac-3', 'ec-3', 'alac', 'fLaC', 'Opus'].indexOf(parsedCodec) !== -1)) {
     return parsedCodec;
   }
-  return levelCodec ? levelCodec.split(',')[0] : levelCodec;
+  if (levelCodec) {
+    const levelCodecs = levelCodec.split(',');
+    if (levelCodecs.length > 1) {
+      if (parsedCodec) {
+        for (let i = levelCodecs.length; i--;) {
+          if (levelCodecs[i].substring(0, 4) === parsedCodec.substring(0, 4)) {
+            return levelCodecs[i];
+          }
+        }
+      }
+      return levelCodecs[0];
+    }
+  }
+  return levelCodec || parsedCodec;
 }
-function convertAVC1ToAVCOTI(codec) {
+function convertAVC1ToAVCOTI(videoCodecs) {
   // Convert avc1 codec string from RFC-4281 to RFC-6381 for MediaSource.isTypeSupported
   // Examples: avc1.66.30 to avc1.42001e and avc1.77.30,avc1.66.30 to avc1.4d001e,avc1.42001e.
-  const codecs = codec.split(',');
+  const codecs = videoCodecs.split(',');
   for (let i = 0; i < codecs.length; i++) {
     const avcdata = codecs[i].split('.');
     if (avcdata.length > 2) {
@@ -2561,6 +2574,18 @@ function convertAVC1ToAVCOTI(codec) {
   }
   return codecs.join(',');
 }
+function fillInMissingAV01Params(videoCodec) {
+  // Used to fill in incomplete AV1 playlist CODECS strings for mediaCapabilities.decodingInfo queries
+  if (videoCodec.startsWith('av01.')) {
+    const av1params = videoCodec.split('.');
+    const placeholders = ['0', '111', '01', '01', '01', '0'];
+    for (let i = av1params.length; i > 4 && i < 10; i++) {
+      av1params[i] = placeholders[i - 4];
+    }
+    return av1params.join('.');
+  }
+  return videoCodec;
+}
 function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
   const MediaSource = getMediaSource(preferManagedMediaSource) || {
     isTypeSupported: () => false
@@ -6375,10 +6400,27 @@ class LevelController extends BasePlaylistController {
         height,
         unknownCodecs
       } = levelParsed;
+      let unknownUnsupportedCodecCount = unknownCodecs ? unknownCodecs.length : 0;
+      if (unknownCodecs) {
+        // Treat unknown codec as audio or video codec based on passing `isTypeSupported` check
+        // (allows for playback of any supported codec even if not indexed in utils/codecs)
+        for (let i = unknownUnsupportedCodecCount; i--;) {
+          const unknownCodec = unknownCodecs[i];
+          if (this.isAudioSupported(unknownCodec)) {
+            levelParsed.audioCodec = audioCodec = audioCodec ? `${audioCodec},${unknownCodec}` : unknownCodec;
+            unknownUnsupportedCodecCount--;
+            sampleEntryCodesISO.audio[audioCodec.substring(0, 4)] = 2;
+          } else if (this.isVideoSupported(unknownCodec)) {
+            levelParsed.videoCodec = videoCodec = videoCodec ? `${videoCodec},${unknownCodec}` : unknownCodec;
+            unknownUnsupportedCodecCount--;
+            sampleEntryCodesISO.video[videoCodec.substring(0, 4)] = 2;
+          }
+        }
+      }
       resolutionFound || (resolutionFound = !!(width && height));
       videoCodecFound || (videoCodecFound = !!videoCodec);
       audioCodecFound || (audioCodecFound = !!audioCodec);
-      if (unknownCodecs != null && unknownCodecs.length || audioCodec && !areCodecsMediaSourceSupported(audioCodec, 'audio', preferManagedMediaSource) || videoCodec && !areCodecsMediaSourceSupported(videoCodec, 'video', preferManagedMediaSource)) {
+      if (unknownUnsupportedCodecCount || audioCodec && !this.isAudioSupported(audioCodec) || videoCodec && !this.isVideoSupported(videoCodec)) {
         return;
       }
       const {
@@ -6411,6 +6453,12 @@ class LevelController extends BasePlaylistController {
     });
     this.filterAndSortMediaOptions(levels, data, resolutionFound, videoCodecFound, audioCodecFound);
   }
+  isAudioSupported(codec) {
+    return areCodecsMediaSourceSupported(codec, 'audio', this.hls.config.preferManagedMediaSource);
+  }
+  isVideoSupported(codec) {
+    return areCodecsMediaSourceSupported(codec, 'video', this.hls.config.preferManagedMediaSource);
+  }
   filterAndSortMediaOptions(filteredLevels, data, resolutionFound, videoCodecFound, audioCodecFound) {
     let audioTracks = [];
     let subtitleTracks = [];
@@ -6446,10 +6494,7 @@ class LevelController extends BasePlaylistController {
       return;
     }
     if (data.audioTracks) {
-      const {
-        preferManagedMediaSource
-      } = this.hls.config;
-      audioTracks = data.audioTracks.filter(track => !track.audioCodec || areCodecsMediaSourceSupported(track.audioCodec, 'audio', preferManagedMediaSource));
+      audioTracks = data.audioTracks.filter(track => !track.audioCodec || this.isAudioSupported(track.audioCodec));
       // Assign ids after filtering as array indices by group-id
       assignTrackIdsByGroup(audioTracks);
     }
@@ -10153,7 +10198,7 @@ function changeTypeSupported() {
   return typeof (sourceBuffer == null ? void 0 : (_sourceBuffer$prototy = sourceBuffer.prototype) == null ? void 0 : _sourceBuffer$prototy.changeType) === 'function';
 }
 
-const version = "1.5.14-0.canary.10668";
+const version = "1.5.14-0.canary.10670";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -14235,7 +14280,7 @@ class PassThroughRemuxer {
     }
     const initData = this.initData = parseInitSegment(initSegment);
 
-    // Get codec from initSegment or fallback to default
+    // Get codec from initSegment
     if (initData.audio) {
       audioCodec = getParsedTrackCodec(initData.audio, ElementaryStreamTypes.AUDIO);
     }
@@ -14390,20 +14435,13 @@ function getParsedTrackCodec(track, type) {
       const preferManagedMediaSource = false;
       return getCodecCompatibleName(parsedCodec, preferManagedMediaSource);
     }
-    const result = 'mp4a.40.5';
-    this.logger.info(`Parsed audio codec "${parsedCodec}" or audio object type not handled. Using "${result}"`);
-    return result;
+    logger.warn(`Unhandled audio codec "${parsedCodec}" in mp4 MAP`);
+    return parsedCodec || 'mp4a';
   }
   // Provide defaults based on codec type
   // This allows for some playback of some fmp4 playlists without CODECS defined in manifest
-  this.logger.warn(`Unhandled video codec "${parsedCodec}"`);
-  if (parsedCodec === 'hvc1' || parsedCodec === 'hev1') {
-    return 'hvc1.1.6.L120.90';
-  }
-  if (parsedCodec === 'av01') {
-    return 'av01.0.04M.08';
-  }
-  return 'avc1.42e01e';
+  logger.warn(`Unhandled video codec "${parsedCodec}" in mp4 MAP`);
+  return parsedCodec || 'avc1';
 }
 
 let now;
@@ -16863,7 +16901,13 @@ class StreamController extends BaseStreamController {
       audiovideo
     } = tracks;
     if (audio) {
-      let audioCodec = currentLevel.audioCodec;
+      let audioCodec = pickMostCompleteCodecName(audio.codec, currentLevel.audioCodec);
+      // Add level and profile to make up for passthrough-remuxer not being able to parse full codec
+      // (logger warning "Unhandled audio codec...")
+      if (audioCodec === 'mp4a') {
+        audioCodec = 'mp4a.40.5';
+      }
+      // Handle `audioCodecSwitch`
       const ua = navigator.userAgent.toLowerCase();
       if (this.audioCodecSwitch) {
         if (audioCodec) {
@@ -16898,7 +16942,24 @@ class StreamController extends BaseStreamController {
     if (video) {
       video.levelCodec = currentLevel.videoCodec;
       video.id = 'main';
-      this.log(`Init video buffer, container:${video.container}, codecs[level/parsed]=[${currentLevel.videoCodec || ''}/${video.codec}]`);
+      const parsedVideoCodec = video.codec;
+      if ((parsedVideoCodec == null ? void 0 : parsedVideoCodec.length) === 4) {
+        // Make up for passthrough-remuxer not being able to parse full codec
+        // (logger warning "Unhandled video codec...")
+        switch (parsedVideoCodec) {
+          case 'hvc1':
+          case 'hev1':
+            video.codec = 'hvc1.1.6.L120.90';
+            break;
+          case 'av01':
+            video.codec = 'av01.0.04M.08';
+            break;
+          case 'avc1':
+            video.codec = 'avc1.42e01e';
+            break;
+        }
+      }
+      this.log(`Init video buffer, container:${video.container}, codecs[level/parsed]=[${currentLevel.videoCodec || ''}/${parsedVideoCodec}${video.codec !== parsedVideoCodec ? ' parsed-corrected=' + video.codec : ''}}]`);
       delete tracks.audiovideo;
     }
     if (audiovideo) {
@@ -18685,7 +18746,7 @@ transfer tracks: ${JSON.stringify(transferredTracks, (key, value) => key === 'in
         if (trackName.slice(0, 5) === 'audio') {
           trackCodec = getCodecCompatibleName(trackCodec, this.appendSource);
         }
-        this.log(`switching codec ${sbCodec} to ${codec}`);
+        this.log(`switching codec ${sbCodec} to ${trackCodec}`);
         if (trackCodec !== (track.pendingCodec || track.codec)) {
           track.pendingCodec = trackCodec;
         }
@@ -19368,7 +19429,7 @@ transfer tracks: ${JSON.stringify(transferredTracks, (key, value) => key === 'in
     }
   }
   getTrackCodec(track, trackName) {
-    const codec = track.codec || track.levelCodec;
+    const codec = pickMostCompleteCodecName(track.codec, track.levelCodec);
     if (codec) {
       if (trackName.slice(0, 5) === 'audio') {
         return getCodecCompatibleName(codec, this.appendSource);
@@ -21319,6 +21380,100 @@ function enableStreamingMode(config, logger) {
   }
 }
 
+const SUPPORTED_INFO_DEFAULT = {
+  supported: true,
+  configurations: [],
+  decodingInfoResults: [{
+    supported: true,
+    powerEfficient: true,
+    smooth: true
+  }]
+};
+const SUPPORTED_INFO_CACHE = {};
+function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities) {
+  const videoCodecs = level.videoCodec;
+  const audioCodecs = level.audioCodec;
+  if (!videoCodecs && !audioCodecs || !mediaCapabilities) {
+    return Promise.resolve(SUPPORTED_INFO_DEFAULT);
+  }
+  const configurations = [];
+  if (videoCodecs) {
+    const baseVideoConfiguration = {
+      width: level.width,
+      height: level.height,
+      bitrate: Math.ceil(Math.max(level.bitrate * 0.9, level.averageBitrate)),
+      // Assume a framerate of 30fps since MediaCapabilities will not accept Level default of 0.
+      framerate: level.frameRate || 30
+    };
+    const videoRange = level.videoRange;
+    if (videoRange !== 'SDR') {
+      baseVideoConfiguration.transferFunction = videoRange.toLowerCase();
+    }
+    configurations.push.apply(configurations, videoCodecs.split(',').map(videoCodec => ({
+      type: 'media-source',
+      video: _objectSpread2(_objectSpread2({}, baseVideoConfiguration), {}, {
+        contentType: mimeTypeForCodec(fillInMissingAV01Params(videoCodec), 'video')
+      })
+    })));
+  }
+  if (audioCodecs && level.audioGroups) {
+    level.audioGroups.forEach(audioGroupId => {
+      var _audioTracksByGroup$g;
+      if (!audioGroupId) {
+        return;
+      }
+      (_audioTracksByGroup$g = audioTracksByGroup.groups[audioGroupId]) == null ? void 0 : _audioTracksByGroup$g.tracks.forEach(audioTrack => {
+        if (audioTrack.groupId === audioGroupId) {
+          const channels = audioTrack.channels || '';
+          const channelsNumber = parseFloat(channels);
+          if (isFiniteNumber(channelsNumber) && channelsNumber > 2) {
+            configurations.push.apply(configurations, audioCodecs.split(',').map(audioCodec => ({
+              type: 'media-source',
+              audio: {
+                contentType: mimeTypeForCodec(audioCodec, 'audio'),
+                channels: '' + channelsNumber
+                // spatialRendering:
+                //   audioCodec === 'ec-3' && channels.indexOf('JOC'),
+              }
+            })));
+          }
+        }
+      });
+    });
+  }
+  return Promise.all(configurations.map(configuration => {
+    // Cache MediaCapabilities promises
+    const decodingInfoKey = getMediaDecodingInfoKey(configuration);
+    return SUPPORTED_INFO_CACHE[decodingInfoKey] || (SUPPORTED_INFO_CACHE[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration));
+  })).then(decodingInfoResults => ({
+    supported: !decodingInfoResults.some(info => !info.supported),
+    configurations,
+    decodingInfoResults
+  })).catch(error => ({
+    supported: false,
+    configurations,
+    decodingInfoResults: [],
+    error
+  }));
+}
+function getMediaDecodingInfoKey(config) {
+  const {
+    audio,
+    video
+  } = config;
+  const mediaConfig = video || audio;
+  if (mediaConfig) {
+    const codec = mediaConfig.contentType.split('"')[1];
+    if (video) {
+      return `r${video.height}x${video.width}f${Math.ceil(video.framerate)}${video.transferFunction || 'sd'}_${codec}_${Math.ceil(video.bitrate / 1e5)}`;
+    }
+    if (audio) {
+      return `c${audio.channels}${audio.spatialRendering ? 's' : 'n'}_${codec}`;
+    }
+  }
+  return '';
+}
+
 /**
  * The `Hls` class is the core of the HLS.js library used to instantiate player instances.
  * @public
@@ -22264,6 +22419,14 @@ class Hls {
     var _this$interstitialsCo;
     return ((_this$interstitialsCo = this.interstitialsController) == null ? void 0 : _this$interstitialsCo.interstitialsManager) || null;
   }
+
+  /**
+   * returns mediaCapabilities.decodingInfo for a variant/rendition
+   */
+  getMediaDecodingInfo(level, audioTracks = this.allAudioTracks) {
+    const audioTracksByGroup = getAudioTracksByGroup(audioTracks);
+    return getMediaDecodingInfoPromise(level, audioTracksByGroup, navigator.mediaCapabilities);
+  }
 }
 Hls.defaultConfig = void 0;