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

package/dist/hls.light.js

@@ -513,7 +513,7 @@
       // 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();
@@ -2664,7 +2664,7 @@
     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) {
@@ -2723,15 +2723,28 @@
   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) {
+      var levelCodecs = levelCodec.split(',');
+      if (levelCodecs.length > 1) {
+        if (parsedCodec) {
+          for (var 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.
-    var codecs = codec.split(',');
+    var codecs = videoCodecs.split(',');
     for (var i = 0; i < codecs.length; i++) {
       var avcdata = codecs[i].split('.');
       if (avcdata.length > 2) {
@@ -2743,6 +2756,18 @@
     }
     return codecs.join(',');
   }
+  function fillInMissingAV01Params(videoCodec) {
+    // Used to fill in incomplete AV1 playlist CODECS strings for mediaCapabilities.decodingInfo queries
+    if (videoCodec.startsWith('av01.')) {
+      var av1params = videoCodec.split('.');
+      var placeholders = ['0', '111', '01', '01', '01', '0'];
+      for (var i = av1params.length; i > 4 && i < 10; i++) {
+        av1params[i] = placeholders[i - 4];
+      }
+      return av1params.join('.');
+    }
+    return videoCodec;
+  }
   function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
     var MediaSource = getMediaSource(preferManagedMediaSource) || {
       isTypeSupported: function isTypeSupported() {
@@ -6614,6 +6639,7 @@
       this.resetLevels();
     };
     _proto.onManifestLoaded = function onManifestLoaded(event, data) {
+      var _this2 = this;
       var preferManagedMediaSource = this.hls.config.preferManagedMediaSource;
       var levels = [];
       var redundantSet = {};
@@ -6638,10 +6664,27 @@
         var width = levelParsed.width,
           height = levelParsed.height,
           unknownCodecs = levelParsed.unknownCodecs;
+        var 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 (var i = unknownUnsupportedCodecCount; i--;) {
+            var unknownCodec = unknownCodecs[i];
+            if (_this2.isAudioSupported(unknownCodec)) {
+              levelParsed.audioCodec = audioCodec = audioCodec ? audioCodec + "," + unknownCodec : unknownCodec;
+              unknownUnsupportedCodecCount--;
+              sampleEntryCodesISO.audio[audioCodec.substring(0, 4)] = 2;
+            } else if (_this2.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 && !_this2.isAudioSupported(audioCodec) || videoCodec && !_this2.isVideoSupported(videoCodec)) {
           return;
         }
         var CODECS = attributes.CODECS,
@@ -6672,8 +6715,14 @@
       });
       this.filterAndSortMediaOptions(levels, data, resolutionFound, videoCodecFound, audioCodecFound);
     };
+    _proto.isAudioSupported = function isAudioSupported(codec) {
+      return areCodecsMediaSourceSupported(codec, 'audio', this.hls.config.preferManagedMediaSource);
+    };
+    _proto.isVideoSupported = function isVideoSupported(codec) {
+      return areCodecsMediaSourceSupported(codec, 'video', this.hls.config.preferManagedMediaSource);
+    };
     _proto.filterAndSortMediaOptions = function filterAndSortMediaOptions(filteredLevels, data, resolutionFound, videoCodecFound, audioCodecFound) {
-      var _this2 = this;
+      var _this3 = this;
       var audioTracks = [];
       var subtitleTracks = [];
       var levels = filteredLevels;
@@ -6691,12 +6740,12 @@
       if (levels.length === 0) {
         // Dispatch error after MANIFEST_LOADED is done propagating
         Promise.resolve().then(function () {
-          if (_this2.hls) {
+          if (_this3.hls) {
             if (data.levels.length) {
-              _this2.warn("One or more CODECS in variant not supported: " + JSON.stringify(data.levels[0].attrs));
+              _this3.warn("One or more CODECS in variant not supported: " + JSON.stringify(data.levels[0].attrs));
             }
             var error = new Error('no level with compatible codecs found in manifest');
-            _this2.hls.trigger(Events.ERROR, {
+            _this3.hls.trigger(Events.ERROR, {
               type: ErrorTypes.MEDIA_ERROR,
               details: ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
               fatal: true,
@@ -6709,9 +6758,8 @@
         return;
       }
       if (data.audioTracks) {
-        var preferManagedMediaSource = this.hls.config.preferManagedMediaSource;
         audioTracks = data.audioTracks.filter(function (track) {
-          return !track.audioCodec || areCodecsMediaSourceSupported(track.audioCodec, 'audio', preferManagedMediaSource);
+          return !track.audioCodec || _this3.isAudioSupported(track.audioCodec);
         });
         // Assign ids after filtering as array indices by group-id
         assignTrackIdsByGroup(audioTracks);
@@ -6907,18 +6955,18 @@
       }
     };
     _proto.removeLevel = function removeLevel(levelIndex) {
-      var _this3 = this,
+      var _this4 = this,
         _this$currentLevel;
       var levels = this._levels.filter(function (level, index) {
         if (index !== levelIndex) {
           return true;
         }
-        if (_this3.steering) {
-          _this3.steering.removeLevel(level);
+        if (_this4.steering) {
+          _this4.steering.removeLevel(level);
         }
-        if (level === _this3.currentLevel) {
-          _this3.currentLevel = null;
-          _this3.currentLevelIndex = -1;
+        if (level === _this4.currentLevel) {
+          _this4.currentLevel = null;
+          _this4.currentLevelIndex = -1;
           if (level.details) {
             level.details.fragments.forEach(function (f) {
               return f.level = -1;
@@ -14552,7 +14600,7 @@
       }
       var 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);
       }
@@ -14706,20 +14754,13 @@
         var preferManagedMediaSource = false;
         return getCodecCompatibleName(parsedCodec, preferManagedMediaSource);
       }
-      var 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';
   }
 
   var now;
@@ -15590,7 +15631,7 @@
     return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
   }
 
-  var version = "1.5.14-0.canary.10668";
+  var 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
@@ -17317,7 +17358,13 @@
         video = tracks.video,
         audiovideo = tracks.audiovideo;
       if (audio) {
-        var audioCodec = currentLevel.audioCodec;
+        var 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`
         var ua = navigator.userAgent.toLowerCase();
         if (this.audioCodecSwitch) {
           if (audioCodec) {
@@ -17352,7 +17399,24 @@
       if (video) {
         video.levelCodec = currentLevel.videoCodec;
         video.id = 'main';
-        this.log("Init video buffer, container:" + video.container + ", codecs[level/parsed]=[" + (currentLevel.videoCodec || '') + "/" + video.codec + "]");
+        var 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) {
@@ -19163,7 +19227,7 @@
           if (trackName.slice(0, 5) === 'audio') {
             trackCodec = getCodecCompatibleName(trackCodec, _this9.appendSource);
           }
-          _this9.log("switching codec " + sbCodec + " to " + codec);
+          _this9.log("switching codec " + sbCodec + " to " + trackCodec);
           if (trackCodec !== (track.pendingCodec || track.codec)) {
             track.pendingCodec = trackCodec;
           }
@@ -19827,7 +19891,7 @@
       }
     };
     _proto.getTrackCodec = function getTrackCodec(track, trackName) {
-      var codec = track.codec || track.levelCodec;
+      var codec = pickMostCompleteCodecName(track.codec, track.levelCodec);
       if (codec) {
         if (trackName.slice(0, 5) === 'audio') {
           return getCodecCompatibleName(codec, this.appendSource);
@@ -21867,6 +21931,108 @@
     }
   }
 
+  var SUPPORTED_INFO_DEFAULT = {
+    supported: true,
+    configurations: [],
+    decodingInfoResults: [{
+      supported: true,
+      powerEfficient: true,
+      smooth: true
+    }]
+  };
+  var SUPPORTED_INFO_CACHE = {};
+  function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities) {
+    var videoCodecs = level.videoCodec;
+    var audioCodecs = level.audioCodec;
+    if (!videoCodecs && !audioCodecs || !mediaCapabilities) {
+      return Promise.resolve(SUPPORTED_INFO_DEFAULT);
+    }
+    var configurations = [];
+    if (videoCodecs) {
+      var 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
+      };
+      var videoRange = level.videoRange;
+      if (videoRange !== 'SDR') {
+        baseVideoConfiguration.transferFunction = videoRange.toLowerCase();
+      }
+      configurations.push.apply(configurations, videoCodecs.split(',').map(function (videoCodec) {
+        return {
+          type: 'media-source',
+          video: _objectSpread2(_objectSpread2({}, baseVideoConfiguration), {}, {
+            contentType: mimeTypeForCodec(fillInMissingAV01Params(videoCodec), 'video')
+          })
+        };
+      }));
+    }
+    if (audioCodecs && level.audioGroups) {
+      level.audioGroups.forEach(function (audioGroupId) {
+        var _audioTracksByGroup$g;
+        if (!audioGroupId) {
+          return;
+        }
+        (_audioTracksByGroup$g = audioTracksByGroup.groups[audioGroupId]) == null ? void 0 : _audioTracksByGroup$g.tracks.forEach(function (audioTrack) {
+          if (audioTrack.groupId === audioGroupId) {
+            var channels = audioTrack.channels || '';
+            var channelsNumber = parseFloat(channels);
+            if (isFiniteNumber(channelsNumber) && channelsNumber > 2) {
+              configurations.push.apply(configurations, audioCodecs.split(',').map(function (audioCodec) {
+                return {
+                  type: 'media-source',
+                  audio: {
+                    contentType: mimeTypeForCodec(audioCodec, 'audio'),
+                    channels: '' + channelsNumber
+                    // spatialRendering:
+                    //   audioCodec === 'ec-3' && channels.indexOf('JOC'),
+                  }
+                };
+              }));
+            }
+          }
+        });
+      });
+    }
+    return Promise.all(configurations.map(function (configuration) {
+      // Cache MediaCapabilities promises
+      var decodingInfoKey = getMediaDecodingInfoKey(configuration);
+      return SUPPORTED_INFO_CACHE[decodingInfoKey] || (SUPPORTED_INFO_CACHE[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration));
+    })).then(function (decodingInfoResults) {
+      return {
+        supported: !decodingInfoResults.some(function (info) {
+          return !info.supported;
+        }),
+        configurations: configurations,
+        decodingInfoResults: decodingInfoResults
+      };
+    }).catch(function (error) {
+      return {
+        supported: false,
+        configurations: configurations,
+        decodingInfoResults: [],
+        error: error
+      };
+    });
+  }
+  function getMediaDecodingInfoKey(config) {
+    var audio = config.audio,
+      video = config.video;
+    var mediaConfig = video || audio;
+    if (mediaConfig) {
+      var 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
@@ -22281,6 +22447,16 @@
     /**
      * Get the complete list of audio tracks across all media groups
      */;
+    /**
+     * returns mediaCapabilities.decodingInfo for a variant/rendition
+     */
+    _proto.getMediaDecodingInfo = function getMediaDecodingInfo(level, audioTracks) {
+      if (audioTracks === void 0) {
+        audioTracks = this.allAudioTracks;
+      }
+      var audioTracksByGroup = getAudioTracksByGroup(audioTracks);
+      return getMediaDecodingInfoPromise(level, audioTracksByGroup, navigator.mediaCapabilities);
+    };
     return _createClass(Hls, [{
       key: "url",
       get: function get() {