shaka-player 4.6.3 → 4.7.0

package/lib/media/adaptation_set_criteria.js

@@ -58,8 +58,10 @@ shaka.media.ExampleBasedCriteria = class {
     // We can't know if role and label are really important, so we don't use
     // role and label for this.
     const role = '';
-    const label = '';
+    const audioLabel = '';
+    const videoLabel = '';
     const hdrLevel = '';
+    const spatialAudio = false;
     const videoLayout = '';
     const channelCount = example.audio && example.audio.channelsCount ?
                          example.audio.channelsCount :
@@ -67,7 +69,8 @@ shaka.media.ExampleBasedCriteria = class {
 
     /** @private {!shaka.media.AdaptationSetCriteria} */
     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
-        example.language, role, channelCount, hdrLevel, videoLayout, label,
+        example.language, role, channelCount, hdrLevel, spatialAudio,
+        videoLayout, audioLabel, videoLabel,
         codecSwitchingStrategy, enableAudioGroups);
   }
 
@@ -106,12 +109,15 @@ shaka.media.PreferenceBasedCriteria = class {
    * @param {string} role
    * @param {number} channelCount
    * @param {string} hdrLevel
+   * @param {boolean} spatialAudio
    * @param {string} videoLayout
-   * @param {string=} label
+   * @param {string=} audioLabel
+   * @param {string=} videoLabel
    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    * @param {boolean=} enableAudioGroups
    */
-  constructor(language, role, channelCount, hdrLevel, videoLayout, label = '',
+  constructor(language, role, channelCount, hdrLevel, spatialAudio,
+      videoLayout, audioLabel = '', videoLabel = '',
       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
       enableAudioGroups = false) {
     /** @private {string} */
@@ -122,10 +128,14 @@ shaka.media.PreferenceBasedCriteria = class {
     this.channelCount_ = channelCount;
     /** @private {string} */
     this.hdrLevel_ = hdrLevel;
+    /** @private {boolean} */
+    this.spatialAudio_ = spatialAudio;
     /** @private {string} */
     this.videoLayout_ = videoLayout;
     /** @private {string} */
-    this.label_ = label;
+    this.audioLabel_ = audioLabel;
+    /** @private {string} */
+    this.videoLabel_ = videoLabel;
     /** @private {shaka.config.CodecSwitchingStrategy} */
     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
     /** @private {boolean} */
@@ -191,15 +201,34 @@ shaka.media.PreferenceBasedCriteria = class {
       }
     }
 
-    if (this.label_) {
-      const byLabel = Class.filterVariantsByLabel_(current, this.label_);
+    if (this.audioLabel_) {
+      const byLabel = Class.filterVariantsByAudioLabel_(
+          current, this.audioLabel_);
+      if (byLabel.length) {
+        current = byLabel;
+      } else {
+        shaka.log.warning('No exact match for audio label could be found.');
+      }
+    }
+
+    if (this.videoLabel_) {
+      const byLabel = Class.filterVariantsByVideoLabel_(
+          current, this.videoLabel_);
       if (byLabel.length) {
         current = byLabel;
       } else {
-        shaka.log.warning('No exact match for variant label could be found.');
+        shaka.log.warning('No exact match for video label could be found.');
       }
     }
 
+    const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
+        current, this.spatialAudio_);
+    if (bySpatialAudio.length) {
+      current = bySpatialAudio;
+    } else {
+      shaka.log.warning('No exact match for spatial audio could be found.');
+    }
+
     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
       shaka.config.CodecSwitchingStrategy.SMOOTH &&
         shaka.media.Capabilities.isChangeTypeSupported();
@@ -259,14 +288,14 @@ shaka.media.PreferenceBasedCriteria = class {
   }
 
   /**
-   * Filter Variants by label.
+   * Filter Variants by audio label.
    *
    * @param {!Array.<shaka.extern.Variant>} variants
    * @param {string} preferredLabel
    * @return {!Array.<shaka.extern.Variant>}
    * @private
    */
-  static filterVariantsByLabel_(variants, preferredLabel) {
+  static filterVariantsByAudioLabel_(variants, preferredLabel) {
     return variants.filter((variant) => {
       if (!variant.audio || !variant.audio.label) {
         return false;
@@ -278,6 +307,26 @@ shaka.media.PreferenceBasedCriteria = class {
     });
   }
 
+  /**
+   * Filter Variants by video label.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {string} preferredLabel
+   * @return {!Array.<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByVideoLabel_(variants, preferredLabel) {
+    return variants.filter((variant) => {
+      if (!variant.video || !variant.video.label) {
+        return false;
+      }
+
+      const label1 = variant.video.label.toLowerCase();
+      const label2 = preferredLabel.toLowerCase();
+      return label1 == label2;
+    });
+  }
+
   /**
    * Filter Variants by channelCount.
    *
@@ -337,4 +386,21 @@ shaka.media.PreferenceBasedCriteria = class {
       return true;
     });
   }
+
+
+  /**
+   * Filters variants according to the given spatial audio config.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {boolean} spatialAudio
+   * @private
+   */
+  static filterVariantsBySpatialAudio_(variants, spatialAudio) {
+    return variants.filter((variant) => {
+      if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
+        return false;
+      }
+      return true;
+    });
+  }
 };

package/lib/media/drm_engine.js

@@ -2038,9 +2038,6 @@ shaka.media.DrmEngine = class {
 
     for (const drm1 of drms1) {
       for (const drm2 of drms2) {
-        // This method is only called to compare drmInfos of a video and an
-        // audio adaptations, so we shouldn't have to worry about checking
-        // robustness.
         if (drm1.keySystem == drm2.keySystem) {
           const initDataMap = new Map();
           const bothInitDatas = (drm1.initData || [])

package/lib/media/media_source_engine.js

@@ -148,6 +148,9 @@ shaka.media.MediaSourceEngine = class {
 
     /** @private {boolean} */
     this.streamingAllowed_ = true;
+
+    /** @private {?number} */
+    this.lastDuration_ = null;
   }
 
   /**
@@ -1088,7 +1091,8 @@ shaka.media.MediaSourceEngine = class {
    *   value will be dropped.
    * @param {boolean} ignoreTimestampOffset  If true, the timestampOffset will
    *   not be applied in this step.
-   * @param {shaka.extern.Stream} stream The current stream.
+   * @param {string} mimeType
+   * @param {string} codecs
    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
    *               shaka.extern.Stream>} streamsByType
    *   A map of content types to streams.  All streams must be supported
@@ -1098,7 +1102,7 @@ shaka.media.MediaSourceEngine = class {
    */
   async setStreamProperties(
       contentType, timestampOffset, appendWindowStart, appendWindowEnd,
-      ignoreTimestampOffset, stream, streamsByType) {
+      ignoreTimestampOffset, mimeType, codecs, streamsByType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       if (!ignoreTimestampOffset) {
@@ -1109,8 +1113,8 @@ shaka.media.MediaSourceEngine = class {
     }
     const operations = [];
 
-    const hasChangedCodecs =
-        await this.codecSwitchIfNecessary_(contentType, stream, streamsByType);
+    const hasChangedCodecs = await this.codecSwitchIfNecessary_(
+        contentType, mimeType, codecs, streamsByType);
 
     if (!hasChangedCodecs) {
       // Queue an abort() to help MSE splice together overlapping segments.
@@ -1241,6 +1245,7 @@ shaka.media.MediaSourceEngine = class {
       }
 
       this.mediaSource_.duration = duration;
+      this.lastDuration_ = duration;
     });
   }
 
@@ -1758,7 +1763,11 @@ shaka.media.MediaSourceEngine = class {
       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
       await this.mediaSourceOpen_;
-      this.mediaSource_.duration = previousDuration;
+      if (!isNaN(previousDuration) && previousDuration) {
+        this.mediaSource_.duration = previousDuration;
+      } else if (!isNaN(this.lastDuration_) && this.lastDuration_) {
+        this.mediaSource_.duration = this.lastDuration_;
+      }
 
       const sourceBufferAdded = new shaka.util.PublicPromise();
       const sourceBuffers =
@@ -1819,15 +1828,17 @@ shaka.media.MediaSourceEngine = class {
    * Codec switch if necessary, this will not resolve until the codec
    * switch is over.
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
    *               shaka.extern.Stream>} streamsByType
    * @return {!Promise.<boolean>} true if there was a codec switch,
    *                              false otherwise.
    * @private
    */
-  async codecSwitchIfNecessary_(contentType, stream, streamsByType) {
-    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (contentType == ContentType.TEXT) {
       return false;
     }
     const MimeUtils = shaka.util.MimeUtils;
@@ -1838,30 +1849,43 @@ shaka.media.MediaSourceEngine = class {
 
     /** @type {?shaka.extern.Transmuxer} */
     let transmuxer;
-    let newMimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
+    let transmuxerMuxed = false;
+    let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
       needTransmux = true;
     }
-    const newMimeTypeWithAllCodecs =
-        shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            stream.mimeType, stream.codecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
+      const newMimeTypeWithAllCodecs =
+          shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codecs);
       const transmuxerPlugin =
           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
       if (transmuxerPlugin) {
         transmuxer = transmuxerPlugin();
-        newMimeType =
-            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+        const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+            ContentType.AUDIO, (codecs || '').split(','));
+        const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+            ContentType.VIDEO, (codecs || '').split(','));
+        if (audioCodec && videoCodec) {
+          transmuxerMuxed = true;
+          let codec = videoCodec;
+          if (contentType == ContentType.AUDIO) {
+            codec = audioCodec;
+          }
+          newMimeType = transmuxer.convertCodecs(contentType,
+              shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec));
+        } else {
+          newMimeType =
+              transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+        }
       }
     }
 
-    const newAllCodecs = MimeUtils.getCodecs(newMimeType);
-    const newCodec = MimeUtils.getCodecBase(newAllCodecs);
+    const newCodec = MimeUtils.getCodecBase(
+        MimeUtils.getCodecs(newMimeType));
     const newBasicType = MimeUtils.getBasicType(newMimeType);
 
     // Current/new codecs base and basic type match then no need to switch
@@ -1870,7 +1894,7 @@ shaka.media.MediaSourceEngine = class {
     }
 
     let allowChangeType = true;
-    if (this.needSplitMuxedContent_ || (newAllCodecs.split(',').length &&
+    if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
         transmuxer && !this.transmuxers_[contentType])) {
       allowChangeType = false;
     }

package/lib/media/segment_reference.js

@@ -57,6 +57,12 @@ shaka.media.InitSegmentReference = class {
 
     /** @type {?shaka.extern.aes128Key} */
     this.aes128Key = aes128Key;
+
+    /** @type {?string} */
+    this.codecs = null;
+
+    /** @type {?string} */
+    this.mimeType = null;
   }
 
   /**
@@ -305,6 +311,12 @@ shaka.media.SegmentReference = class {
           this.partialReferences[this.partialReferences.length - 1];
       lastPartial.markAsLastPartial();
     }
+
+    /** @type {?string} */
+    this.codecs = null;
+
+    /** @type {?string} */
+    this.mimeType = null;
   }
 
   /**

package/lib/media/streaming_engine.js

@@ -6,7 +6,6 @@
 
 /**
  * @fileoverview
- * @suppress {missingRequire} TODO(b/152540451): this shouldn't be needed
  */
 
 goog.provide('shaka.media.StreamingEngine');
@@ -14,12 +13,14 @@ goog.provide('shaka.media.StreamingEngine');
 goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
+goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.MediaSourceEngine');
 goog.require('shaka.media.SegmentIterator');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.SegmentPrefetch');
 goog.require('shaka.net.Backoff');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.DelayedTick');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
@@ -28,6 +29,7 @@ goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Networking');
 
@@ -117,6 +119,9 @@ shaka.media.StreamingEngine = class {
 
     /** @private {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
+
+    /** @private {number} */
+    this.lastMediaSourceReset_ = 0;
   }
 
   /** @override */
@@ -1088,8 +1093,8 @@ shaka.media.StreamingEngine = class {
         this.config_.rebufferingGoal,
         this.config_.bufferingGoal);
 
-    const scaledBufferingGoal =
-        unscaledBufferingGoal * this.bufferingGoalScale_;
+    const scaledBufferingGoal = Math.max(1,
+        unscaledBufferingGoal * this.bufferingGoalScale_);
 
     // Check if we've buffered to the end of the presentation.
     const timeUntilEnd =
@@ -1634,6 +1639,13 @@ shaka.media.StreamingEngine = class {
     });
 
     if (!waitingForAnotherStreamToRecover) {
+      if (this.config_.maxDisabledTime > 0) {
+        const handled = this.playerInterface_.disableStream(
+            mediaState.stream, this.config_.maxDisabledTime);
+        if (handled) {
+          return;
+        }
+      }
       // Reduction schedule: 80%, 60%, 40%, 20%, 16%, 12%, 8%, 4%, fail.
       // Note: percentages are used for comparisons to avoid rounding errors.
       const percentBefore = Math.round(100 * this.bufferingGoalScale_);
@@ -1759,7 +1771,8 @@ shaka.media.StreamingEngine = class {
           await this.playerInterface_.mediaSourceEngine.setStreamProperties(
               mediaState.type, timestampOffset, appendWindowStart,
               appendWindowEnd, ignoreTimestampOffset,
-              mediaState.stream, streamsByType);
+              reference.mimeType || mediaState.stream.mimeType,
+              reference.codecs || mediaState.stream.codecs, streamsByType);
           if (isResetMediaSourceNecessary) {
             let otherState = null;
             if (mediaState.type === ContentType.VIDEO) {
@@ -2203,7 +2216,6 @@ shaka.media.StreamingEngine = class {
    *
    * @return {!Promise.<BufferSource>}
    * @private
-   * @suppress {strictMissingProperties}
    */
   async fetch_(mediaState, reference, streamDataCallback) {
     if (reference instanceof shaka.media.InitSegmentReference) {
@@ -2452,6 +2464,47 @@ shaka.media.StreamingEngine = class {
     return this.config_.maxDisabledTime;
   }
 
+  /**
+   * Reset Media Source
+   *
+   * @return {!Promise.<boolean>}
+   */
+  async resetMediaSource() {
+    const now = (Date.now() / 1000);
+    const minTimeBetweenRecoveries = this.config_.minTimeBetweenRecoveries;
+    if (!this.config_.allowMediaSourceRecoveries ||
+        (now - this.lastMediaSourceReset_) < minTimeBetweenRecoveries) {
+      return false;
+    }
+    this.lastMediaSourceReset_ = now;
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const audioMediaState = this.mediaStates_.get(ContentType.AUDIO);
+    if (audioMediaState) {
+      audioMediaState.lastInitSegmentReference = null;
+      this.forceClearBuffer_(audioMediaState);
+      this.abortOperations_(audioMediaState).catch(() => {});
+    }
+    const videoMediaState = this.mediaStates_.get(ContentType.VIDEO);
+    if (videoMediaState) {
+      videoMediaState.lastInitSegmentReference = null;
+      this.forceClearBuffer_(videoMediaState);
+      this.abortOperations_(videoMediaState).catch(() => {});
+    }
+    /**
+     * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
+     *              shaka.extern.Stream>}
+     */
+    const streamsByType = new Map();
+    if (this.currentVariant_.audio) {
+      streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
+    }
+    if (this.currentVariant_.video) {
+      streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
+    }
+    await this.playerInterface_.mediaSourceEngine.reset(streamsByType);
+    return true;
+  }
+
   /**
    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
    * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,

package/lib/media/video_wrapper.js

@@ -183,8 +183,8 @@ shaka.media.VideoWrapper = class {
 
 /**
  * A class used to move the playhead away from its current time.  Sometimes,
- * Edge ignores re-seeks. After changing the current time, check every 100ms,
- * retrying if the change was not accepted.
+ * legacy Edge ignores re-seeks. After changing the current time, check every
+ * 100ms, retrying if the change was not accepted.
  *
  * Delay stats over 100 runs of a re-seeking integration test:
  *   Edge   -   0ms -   2%
@@ -194,7 +194,8 @@ shaka.media.VideoWrapper = class {
  *   Edge   - 400ms -   2%
  *   Chrome -   0ms - 100%
  *
- * TODO: File a bug on Edge about this.
+ * Unfortunately, legacy Edge is not receiving updates anymore, but it still
+ * must be supported as it is used for web browsers on XBox.
  *
  * @implements {shaka.util.IReleasable}
  * @final