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

package/dist/hls.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();
@@ -1391,12 +1391,12 @@ function createMediaKeySystemConfigurations(initDataTypes, audioCodecs, videoCod
     distinctiveIdentifier: drmSystemOptions.distinctiveIdentifier || 'optional',
     sessionTypes: drmSystemOptions.sessionTypes || [drmSystemOptions.sessionType || 'temporary'],
     audioCapabilities: audioCodecs.map(codec => ({
-      contentType: `audio/mp4; codecs="${codec}"`,
+      contentType: `audio/mp4; codecs=${codec}`,
       robustness: drmSystemOptions.audioRobustness || '',
       encryptionScheme: drmSystemOptions.audioEncryptionScheme || null
     })),
     videoCapabilities: videoCodecs.map(codec => ({
-      contentType: `video/mp4; codecs="${codec}"`,
+      contentType: `video/mp4; codecs=${codec}`,
       robustness: drmSystemOptions.videoRobustness || '',
       encryptionScheme: drmSystemOptions.videoEncryptionScheme || null
     }))
@@ -2926,7 +2926,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) {
@@ -2977,15 +2977,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) {
@@ -2997,6 +3010,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
@@ -6965,10 +6990,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 {
@@ -7001,6 +7043,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 = [];
@@ -7036,10 +7084,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);
     }
@@ -10768,7 +10813,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
@@ -12521,7 +12566,7 @@ class HevcVideoParser extends BaseVideoParser {
                 track.params[prop] = config[prop];
               }
             }
-            if (this.initVPS !== null || track.pps.length === 0) {
+            if (track.vps !== undefined && track.vps[0] === this.initVPS) {
               track.pps.push(unit.data);
             }
           }
@@ -12572,6 +12617,12 @@ class HevcVideoParser extends BaseVideoParser {
     }
     return new Uint8Array(dst.buffer, 0, dstIdx);
   }
+  pushAccessUnit(VideoSample, videoTrack) {
+    super.pushAccessUnit(VideoSample, videoTrack);
+    if (this.initVPS) {
+      this.initVPS = null; // null initVPS to prevent possible track's sps/pps growth until next VPS
+    }
+  }
   readVPS(vps) {
     const eg = new ExpGolomb(vps);
     // remove header
@@ -15610,7 +15661,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);
     }
@@ -15765,20 +15816,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;
@@ -18244,7 +18288,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) {
@@ -18279,7 +18329,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) {
@@ -18601,26 +18668,29 @@ function requiresMediaCapabilitiesDecodingInfo(level, audioTracksByGroup, curren
 function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities) {
   const videoCodecs = level.videoCodec;
   const audioCodecs = level.audioCodec;
-  if (!videoCodecs || !audioCodecs || !mediaCapabilities) {
+  if (!videoCodecs && !audioCodecs || !mediaCapabilities) {
     return Promise.resolve(SUPPORTED_INFO_DEFAULT);
   }
-  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();
-  }
-  const configurations = videoCodecs.split(',').map(videoCodec => ({
-    type: 'media-source',
-    video: _objectSpread2(_objectSpread2({}, baseVideoConfiguration), {}, {
-      contentType: mimeTypeForCodec(videoCodec, 'video')
-    })
-  }));
+  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;
@@ -22362,7 +22432,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;
         }
@@ -23045,7 +23115,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);
@@ -33700,6 +33770,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;