shaka-player 4.7.12 → 4.8.0

package/lib/media/media_source_engine.js

@@ -31,6 +31,7 @@ goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PublicPromise');
+goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.lcevc.Dec');
 
@@ -237,18 +238,61 @@ shaka.media.MediaSourceEngine = class {
    * Checks if a certain type is supported.
    *
    * @param {shaka.extern.Stream} stream
-   * @return {boolean}
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @return {!Promise.<boolean>}
    */
-  static isStreamSupported(stream) {
+  static async isStreamSupported(stream, contentType) {
+    if (stream.createSegmentIndex) {
+      await stream.createSegmentIndex();
+    }
+    if (!stream.segmentIndex) {
+      return false;
+    }
+    if (stream.segmentIndex.isEmpty()) {
+      return true;
+    }
     const MimeUtils = shaka.util.MimeUtils;
-    const fullMimeType = MimeUtils.getFullType(stream.mimeType, stream.codecs);
-    const extendedMimeType = MimeUtils.getExtendedType(stream);
-    const fullMimeTypeWithAllCodecs = MimeUtils.getFullTypeWithAllCodecs(
-        stream.mimeType, stream.codecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
-    return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
-        shaka.media.Capabilities.isTypeSupported(extendedMimeType) ||
-        TransmuxerEngine.isSupported(fullMimeTypeWithAllCodecs, stream.type);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const StreamUtils = shaka.util.StreamUtils;
+    const seenCombos = new Set();
+    // Check each combination of mimeType and codecs within the segment index.
+    // Unfortunately we cannot use fullMimeTypes, as we ALSO need to check the
+    // getFullTypeWithAllCodecs (for the sake of the transmuxer) and we have no
+    // way of going from a full mimeType to a full mimeType with all codecs.
+    // As this function is only called in debug mode, a little inefficiency is
+    // acceptable.
+    for (const ref of stream.segmentIndex) {
+      const mimeType = ref.mimeType || stream.mimeType || '';
+      let codecs = ref.codecs || stream.codecs || '';
+      // Don't check the same combination of mimetype + codecs twice.
+      const combo = mimeType + ':' + codecs;
+      if (seenCombos.has(combo)) {
+        continue;
+      }
+      seenCombos.add(combo);
+      if (contentType == ContentType.TEXT) {
+        const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
+        if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
+          return false;
+        }
+      } else {
+        if (contentType == ContentType.VIDEO) {
+          codecs = StreamUtils.getCorrectVideoCodecs(codecs);
+        } else if (contentType == ContentType.AUDIO) {
+          codecs = StreamUtils.getCorrectAudioCodecs(codecs);
+        }
+        const extendedMimeType = MimeUtils.getExtendedType(
+            stream, mimeType, codecs);
+        const fullMimeType = MimeUtils.getFullTypeWithAllCodecs(
+            mimeType, codecs);
+        if (!shaka.media.Capabilities.isTypeSupported(extendedMimeType) &&
+            !TransmuxerEngine.isSupported(fullMimeType, stream.type)) {
+          return false;
+        }
+      }
+    }
+    return true;
   }
 
   /**
@@ -451,7 +495,8 @@ shaka.media.MediaSourceEngine = class {
 
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
-      this.initSourceBuffer_(contentType, stream, stream.codecs);
+      // eslint-disable-next-line no-await-in-loop
+      await this.initSourceBuffer_(contentType, stream, stream.codecs);
       if (this.needSplitMuxedContent_) {
         this.queues_[ContentType.AUDIO] = [];
         this.queues_[ContentType.VIDEO] = [];
@@ -467,13 +512,15 @@ shaka.media.MediaSourceEngine = class {
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
    * @param {string} codecs
+   * @return {!Promise}
    * @private
    */
-  initSourceBuffer_(contentType, stream, codecs) {
+  async initSourceBuffer_(contentType, stream, codecs) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(
-        shaka.media.MediaSourceEngine.isStreamSupported(stream),
+        await shaka.media.MediaSourceEngine.isStreamSupported(
+            stream, contentType),
         'Type negotiation should happen before MediaSourceEngine.init!');
 
     let mimeType = shaka.util.MimeUtils.getFullType(
@@ -490,7 +537,6 @@ shaka.media.MediaSourceEngine = class {
       const mimeTypeWithAllCodecs =
           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
               stream.mimeType, codecs);
-      const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
       if (needTransmux) {
         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
             ContentType.AUDIO, (codecs || '').split(','));
@@ -498,12 +544,12 @@ shaka.media.MediaSourceEngine = class {
             ContentType.VIDEO, (codecs || '').split(','));
         if (audioCodec && videoCodec) {
           this.needSplitMuxedContent_ = true;
-          this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
-          this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
+          await this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
+          await this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
           return;
         }
-        const transmuxerPlugin =
-            TransmuxerEngine.findTransmuxer(mimeTypeWithAllCodecs);
+        const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
+            .findTransmuxer(mimeTypeWithAllCodecs);
         if (transmuxerPlugin) {
           const transmuxer = transmuxerPlugin();
           this.transmuxers_[contentType] = transmuxer;
@@ -511,7 +557,7 @@ shaka.media.MediaSourceEngine = class {
               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
         }
       }
-      const type = mimeType + this.config_.sourceBufferExtraFeatures;
+      const type = this.addExtraFeaturesToMimeType_(mimeType);
 
       this.destroyer_.ensureNotDestroyed();
 
@@ -554,6 +600,9 @@ shaka.media.MediaSourceEngine = class {
    */
   configure(config) {
     this.config_ = config;
+    if (this.textEngine_) {
+      this.textEngine_.setModifyCueCallback(config.modifyCueCallback);
+    }
   }
 
   /**
@@ -575,6 +624,9 @@ shaka.media.MediaSourceEngine = class {
   reinitText(mimeType, sequenceMode, external) {
     if (!this.textEngine_) {
       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
+      if (this.textEngine_) {
+        this.textEngine_.setModifyCueCallback(this.config_.modifyCueCallback);
+      }
     }
     this.textEngine_.initParser(mimeType, sequenceMode,
         external || this.segmentRelativeVttTiming_, this.manifestType_);
@@ -1689,7 +1741,7 @@ shaka.media.MediaSourceEngine = class {
       if (transmuxer) {
         this.transmuxers_[contentType] = transmuxer;
       }
-      const type = mimeType + this.config_.sourceBufferExtraFeatures;
+      const type = this.addExtraFeaturesToMimeType_(mimeType);
       this.sourceBuffers_[contentType].changeType(type);
       this.sourceBufferTypes_[contentType] = mimeType;
     } else {
@@ -1793,16 +1845,22 @@ shaka.media.MediaSourceEngine = class {
 
       const totalOfBuffers = streamsByType.size;
       let numberOfSourceBufferAdded = 0;
-      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer', (event) => {
+      const onSourceBufferAdded = () => {
         numberOfSourceBufferAdded++;
         if (numberOfSourceBufferAdded === totalOfBuffers) {
           sourceBufferAdded.resolve();
+          this.eventManager_.unlisten(sourceBuffers, 'addsourcebuffer',
+              onSourceBufferAdded);
         }
-      });
+      };
+
+      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer',
+          onSourceBufferAdded);
 
       for (const contentType of streamsByType.keys()) {
         const stream = streamsByType.get(contentType);
-        this.initSourceBuffer_(contentType, stream, stream.codecs);
+        // eslint-disable-next-line no-await-in-loop
+        await this.initSourceBuffer_(contentType, stream, stream.codecs);
         if (this.needSplitMuxedContent_) {
           this.queues_[ContentType.AUDIO] = [];
           this.queues_[ContentType.VIDEO] = [];
@@ -1821,7 +1879,12 @@ shaka.media.MediaSourceEngine = class {
       this.destroyer_.ensureNotDestroyed();
 
       this.eventManager_.listenOnce(this.video_, 'canplaythrough', () => {
-        this.destroyer_.ensureNotDestroyed();
+        // Don't use ensureNotDestroyed() from this event listener, because
+        // that results in an uncaught exception.  Instead, just check the
+        // flag.
+        if (this.destroyer_.destroyed()) {
+          return;
+        }
 
         this.video_.autoplay = previousAutoPlayState;
         if (!previousPausedState) {
@@ -1935,10 +1998,12 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} refMimeType
+   * @param {string} refCodecs
    * @return {boolean}
    * @private
    */
-  isCodecSwitchNecessary_(contentType, stream) {
+  isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
       return false;
     }
@@ -1948,8 +2013,7 @@ shaka.media.MediaSourceEngine = class {
     const currentBasicType = MimeUtils.getBasicType(
         this.sourceBufferTypes_[contentType]);
 
-    let newMimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
+    let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
@@ -1958,7 +2022,7 @@ shaka.media.MediaSourceEngine = class {
     }
     const newMimeTypeWithAllCodecs =
         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            stream.mimeType, stream.codecs);
+            refMimeType, refCodecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
       const transmuxerPlugin =
@@ -1984,10 +2048,12 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, stream) {
-    if (!this.isCodecSwitchNecessary_(contentType, stream)) {
+  isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
+    if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
       return false;
     }
 
@@ -2004,6 +2070,19 @@ shaka.media.MediaSourceEngine = class {
   updateLcevcDec(lcevcDec) {
     this.lcevcDec_ = lcevcDec;
   }
+
+  /**
+   * @param {string} mimeType
+   * @return {string}
+   * @private
+   */
+  addExtraFeaturesToMimeType_(mimeType) {
+    const extraFeatures = this.config_.addExtraFeaturesToSourceBuffer(mimeType);
+    const extendedType = mimeType + extraFeatures;
+    shaka.log.debug('Using full mime type', extendedType);
+
+    return extendedType;
+  }
 };
 
 

package/lib/media/playhead.js

@@ -382,10 +382,10 @@ shaka.media.MediaSourcePlayhead = class {
       seekStart = seekEnd - this.minSeekRange_;
     }
 
-    if (currentTime < seekStart) {
-      // The seek range has moved past the playhead.  Move ahead to catch up.
+    if (currentTime < seekStart || currentTime > seekEnd) {
+      // playhead is outside of the seekrange.  Move playhead to catch up.
       const targetTime = this.reposition_(currentTime);
-      shaka.log.info('Jumping forward ' + (targetTime - currentTime) +
+      shaka.log.info('Jumping by ' + (targetTime - currentTime) +
                      ' seconds to catch up with the seek range.');
       this.mediaElement_.currentTime = targetTime;
     }