shaka-player 4.4.3 → 4.6.0

package/lib/media/adaptation_set_criteria.js

@@ -8,10 +8,11 @@ goog.provide('shaka.media.AdaptationSetCriteria');
 goog.provide('shaka.media.ExampleBasedCriteria');
 goog.provide('shaka.media.PreferenceBasedCriteria');
 
+goog.require('shaka.config.CodecSwitchingStrategy');
 goog.require('shaka.log');
 goog.require('shaka.media.AdaptationSet');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.util.LanguageUtils');
-goog.require('shaka.util.StreamUtils');
 
 
 /**
@@ -40,38 +41,54 @@ shaka.media.AdaptationSetCriteria = class {
 shaka.media.ExampleBasedCriteria = class {
   /**
    * @param {shaka.extern.Variant} example
+   * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
+   * @param {boolean=} enableAudioGroups
    */
-  constructor(example) {
+  constructor(example,
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
+      enableAudioGroups = false) {
     /** @private {shaka.extern.Variant} */
     this.example_ = example;
+    /** @private {shaka.config.CodecSwitchingStrategy} */
+    this.codecSwitchingStrategy_ = codecSwitchingStrategy;
+    /** @private {boolean} */
+    this.enableAudioGroups_ = enableAudioGroups;
+
 
     // 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 hdrLevel = '';
+    const videoLayout = '';
     const channelCount = example.audio && example.audio.channelsCount ?
                          example.audio.channelsCount :
                          0;
 
     /** @private {!shaka.media.AdaptationSetCriteria} */
     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
-        example.language, role, channelCount, hdrLevel, label);
+        example.language, role, channelCount, hdrLevel, videoLayout, label,
+        codecSwitchingStrategy, enableAudioGroups);
   }
 
   /** @override */
   create(variants) {
+    const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
+      shaka.config.CodecSwitchingStrategy.SMOOTH &&
+        shaka.media.Capabilities.isChangeTypeSupported();
     // We can't assume that the example is in |variants| because it could
     // actually be from another period.
     const shortList = variants.filter((variant) => {
-      return shaka.media.AdaptationSet.areAdaptable(this.example_, variant);
+      return shaka.media.AdaptationSet.areAdaptable(this.example_, variant,
+          !supportsSmoothCodecTransitions, this.enableAudioGroups_);
     });
 
     if (shortList.length) {
       // Use the first item in the short list as the root. It should not matter
       // which element we use as all items in the short list should already be
       // compatible.
-      return new shaka.media.AdaptationSet(shortList[0], shortList);
+      return new shaka.media.AdaptationSet(shortList[0], shortList,
+          !supportsSmoothCodecTransitions, this.enableAudioGroups_);
     } else {
       return this.fallback_.create(variants);
     }
@@ -89,9 +106,14 @@ shaka.media.PreferenceBasedCriteria = class {
    * @param {string} role
    * @param {number} channelCount
    * @param {string} hdrLevel
+   * @param {string} videoLayout
    * @param {string=} label
+   * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
+   * @param {boolean=} enableAudioGroups
    */
-  constructor(language, role, channelCount, hdrLevel, label = '') {
+  constructor(language, role, channelCount, hdrLevel, videoLayout, label = '',
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
+      enableAudioGroups = false) {
     /** @private {string} */
     this.language_ = language;
     /** @private {string} */
@@ -101,13 +123,18 @@ shaka.media.PreferenceBasedCriteria = class {
     /** @private {string} */
     this.hdrLevel_ = hdrLevel;
     /** @private {string} */
+    this.videoLayout_ = videoLayout;
+    /** @private {string} */
     this.label_ = label;
+    /** @private {shaka.config.CodecSwitchingStrategy} */
+    this.codecSwitchingStrategy_ = codecSwitchingStrategy;
+    /** @private {boolean} */
+    this.enableAudioGroups_ = enableAudioGroups;
   }
 
   /** @override */
   create(variants) {
     const Class = shaka.media.PreferenceBasedCriteria;
-    const StreamUtils = shaka.util.StreamUtils;
 
     let current = [];
 
@@ -131,6 +158,17 @@ shaka.media.PreferenceBasedCriteria = class {
       shaka.log.warning('No exact match for variant role could be found.');
     }
 
+    if (this.videoLayout_) {
+      const byVideoLayout = Class.filterVariantsByVideoLayout_(
+          current, this.videoLayout_);
+      if (byVideoLayout.length) {
+        current = byVideoLayout;
+      } else {
+        shaka.log.warning(
+            'No exact match for the video layout could be found.');
+      }
+    }
+
     if (this.hdrLevel_) {
       const byHdrLevel = Class.filterVariantsByHDRLevel_(
           current, this.hdrLevel_);
@@ -143,7 +181,7 @@ shaka.media.PreferenceBasedCriteria = class {
     }
 
     if (this.channelCount_) {
-      const byChannel = StreamUtils.filterVariantsByAudioChannelCount(
+      const byChannel = Class.filterVariantsByAudioChannelCount_(
           current, this.channelCount_);
       if (byChannel.length) {
         current = byChannel;
@@ -162,15 +200,12 @@ shaka.media.PreferenceBasedCriteria = class {
       }
     }
 
-    // Make sure we only return a valid adaptation set.
-    const set = new shaka.media.AdaptationSet(current[0]);
-    for (const variant of current) {
-      if (set.canInclude(variant)) {
-        set.add(variant);
-      }
-    }
+    const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
+      shaka.config.CodecSwitchingStrategy.SMOOTH &&
+        shaka.media.Capabilities.isChangeTypeSupported();
 
-    return set;
+    return new shaka.media.AdaptationSet(current[0], current,
+        !supportsSmoothCodecTransitions, this.enableAudioGroups_);
   }
 
   /**
@@ -243,6 +278,23 @@ shaka.media.PreferenceBasedCriteria = class {
     });
   }
 
+  /**
+   * Filter Variants by channelCount.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {number} channelCount
+   * @return {!Array.<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByAudioChannelCount_(variants, channelCount) {
+    return variants.filter((variant) => {
+      if (variant.audio && variant.audio.channelsCount &&
+          variant.audio.channelsCount != channelCount) {
+        return false;
+      }
+      return true;
+    });
+  }
 
   /**
    * Filters variants according to the given hdr level config.
@@ -267,4 +319,22 @@ shaka.media.PreferenceBasedCriteria = class {
       return true;
     });
   }
+
+
+  /**
+   * Filters variants according to the given video layout config.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {string} videoLayout
+   * @private
+   */
+  static filterVariantsByVideoLayout_(variants, videoLayout) {
+    return variants.filter((variant) => {
+      if (variant.video && variant.video.videoLayout &&
+          variant.video.videoLayout != videoLayout) {
+        return false;
+      }
+      return true;
+    });
+  }
 };

package/lib/media/closed_caption_parser.js

@@ -42,6 +42,12 @@ shaka.media.IClosedCaptionParser = class {
    * Resets the CaptionStream.
    */
   reset() {}
+
+  /**
+   * Returns the streams that the CEA decoder found.
+   * @return {!Array.<string>}
+   */
+  getStreams() {}
 };
 
 /**
@@ -112,6 +118,13 @@ shaka.media.ClosedCaptionParser = class {
     this.ceaDecoder_.clear();
   }
 
+  /**
+   * @override
+   */
+  getStreams() {
+    return this.ceaDecoder_.getStreams();
+  }
+
   /**
    * @param {string} mimeType
    * @param {!shaka.extern.CeaParserPlugin} plugin

package/lib/media/content_workarounds.js

@@ -105,6 +105,12 @@ shaka.media.ContentWorkarounds = class {
             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
           });
         })
+        .fullBox('ac-4', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+          });
+        })
         .fullBox('mp4a', (box) => {
           boxesToModify.push({
             box,

package/lib/media/drm_engine.js

@@ -715,11 +715,8 @@ shaka.media.DrmEngine = class {
 
     const metadatas = this.activeSessions_.values();
     for (const metadata of metadatas) {
-      // Tizen 2015 and 2016 models will send multiple webkitneedkey events
-      // with the same init data. If the duplicates are supressed, playback
-      // will stall without errors.
       if (shaka.util.BufferUtils.equal(initData, metadata.initData) &&
-          !shaka.util.Platform.isTizen2()) {
+          this.config_.ignoreDuplicateInitData) {
         shaka.log.debug('Ignoring duplicate init data.');
         return;
       }
@@ -2045,15 +2042,13 @@ shaka.media.DrmEngine = class {
         // audio adaptations, so we shouldn't have to worry about checking
         // robustness.
         if (drm1.keySystem == drm2.keySystem) {
-          /** @type {Array<shaka.extern.InitDataOverride>} */
-          let initData = [];
-          initData = initData.concat(drm1.initData || []);
-          initData = initData.concat(drm2.initData || []);
-          initData = initData.filter((d, i) => {
-            return d.keyId === undefined || i === initData.findIndex((d2) => {
-              return d2.keyId === d.keyId;
-            });
-          });
+          const initDataMap = new Map();
+          const bothInitDatas = (drm1.initData || [])
+              .concat(drm2.initData || []);
+          for (const d of bothInitDatas) {
+            initDataMap.set(d.keyId, d);
+          }
+          const initData = Array.from(initDataMap.values());
 
           const keyIds = drm1.keyIds && drm2.keyIds ?
               new Set([...drm1.keyIds, ...drm2.keyIds]) :

package/lib/media/manifest_parser.js

@@ -6,9 +6,8 @@
 
 goog.provide('shaka.media.ManifestParser');
 
-goog.require('goog.Uri');
+goog.require('shaka.Deprecate');
 goog.require('shaka.log');
-goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Platform');
 
@@ -28,7 +27,9 @@ shaka.media.ManifestParser = class {
    * @export
    */
   static registerParserByExtension(extension, parserFactory) {
-    shaka.media.ManifestParser.parsersByExtension[extension] = parserFactory;
+    shaka.Deprecate.deprecateFeature(5,
+        'ManifestParser',
+        'Please use an ManifestParser with registerParserByMime function.');
   }
 
 
@@ -70,9 +71,6 @@ shaka.media.ManifestParser = class {
       for (const type in ManifestParser.parsersByMime) {
         support[type] = true;
       }
-      for (const type in ManifestParser.parsersByExtension) {
-        support[type] = true;
-      }
     }
 
     // Make sure all well-known types are tested as well, just to show an
@@ -86,14 +84,6 @@ shaka.media.ManifestParser = class {
       // SmoothStreaming
       'application/vnd.ms-sstr+xml',
     ];
-    const testExtensions = {
-      // DASH
-      'mpd': 'application/dash+xml',
-      // HLS
-      'm3u8': 'application/x-mpegurl',
-      // SmoothStreaming
-      'ism': 'application/vnd.ms-sstr+xml',
-    };
 
     for (const type of testMimeTypes) {
       // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
@@ -105,18 +95,6 @@ shaka.media.ManifestParser = class {
       }
     }
 
-    for (const extension in testExtensions) {
-      // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
-      // temporary media element for native support for these MIME type for the
-      // extension.
-      if (shaka.util.Platform.supportsMediaSource()) {
-        support[extension] = !!ManifestParser.parsersByExtension[extension];
-      } else {
-        const type = testExtensions[extension];
-        support[extension] = shaka.util.Platform.supportsMediaType(type);
-      }
-    }
-
     return support;
   }
 
@@ -126,12 +104,10 @@ shaka.media.ManifestParser = class {
    * parse the manifest at |uri|.
    *
    * @param {string} uri
-   * @param {!shaka.net.NetworkingEngine} netEngine
-   * @param {shaka.extern.RetryParameters} retryParams
    * @param {?string} mimeType
-   * @return {!Promise.<shaka.extern.ManifestParser.Factory>}
+   * @return {shaka.extern.ManifestParser.Factory}
    */
-  static async getFactory(uri, netEngine, retryParams, mimeType) {
+  static getFactory(uri, mimeType) {
     const ManifestParser = shaka.media.ManifestParser;
 
     // Try using the MIME type we were given.
@@ -145,33 +121,6 @@ shaka.media.ManifestParser = class {
           'Could not determine manifest type using MIME type ', mimeType);
     }
 
-    const extension = ManifestParser.getExtension(uri);
-    if (extension) {
-      const factory = ManifestParser.parsersByExtension[extension];
-      if (factory) {
-        return factory;
-      }
-
-      shaka.log.warning(
-          'Could not determine manifest type for extension ', extension);
-    } else {
-      shaka.log.warning('Could not find extension for ', uri);
-    }
-
-    if (!mimeType) {
-      mimeType = await ManifestParser.getMimeType(uri, netEngine, retryParams);
-
-      if (mimeType) {
-        const factory = shaka.media.ManifestParser.parsersByMime[mimeType];
-        if (factory) {
-          return factory;
-        }
-
-        shaka.log.warning('Could not determine manifest type using MIME type',
-            mimeType);
-      }
-    }
-
     throw new shaka.util.Error(
         shaka.util.Error.Severity.CRITICAL,
         shaka.util.Error.Category.MANIFEST,
@@ -181,56 +130,15 @@ shaka.media.ManifestParser = class {
 
 
   /**
-   * @param {string} uri
-   * @param {!shaka.net.NetworkingEngine} netEngine
-   * @param {shaka.extern.RetryParameters} retryParams
-   * @return {!Promise.<string>}
-   */
-  static async getMimeType(uri, netEngine, retryParams) {
-    const type = shaka.net.NetworkingEngine.RequestType.MANIFEST;
-
-    const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
-    request.method = 'HEAD';
-
-    const response = await netEngine.request(type, request).promise;
-
-    // https://bit.ly/2K9s9kf says this header should always be available,
-    // but just to be safe:
-    const mimeType = response.headers['content-type'];
-    return mimeType ? mimeType.toLowerCase().split(';').shift() : '';
-  }
-
-
-  /**
-   * @param {string} uri
-   * @return {string}
-   */
-  static getExtension(uri) {
-    const uriObj = new goog.Uri(uri);
-    const uriPieces = uriObj.getPath().split('/');
-    const uriFilename = uriPieces.pop();
-    const filenamePieces = uriFilename.split('.');
-
-    // Only one piece means there is no extension.
-    if (filenamePieces.length == 1) {
-      return '';
-    }
-
-    return filenamePieces.pop().toLowerCase();
-  }
-
-
-  /**
-   * Determines whether or not this URI and MIME type are supported by our own
+   * Determines whether or not the MIME type is supported by our own
    * manifest parsers on this platform.  This takes into account whether or not
    * MediaSource is available, as well as which parsers are registered to the
    * system.
    *
-   * @param {string} uri
    * @param {string} mimeType
    * @return {boolean}
    */
-  static isSupported(uri, mimeType) {
+  static isSupported(mimeType) {
     // Without MediaSource, our own parsers are useless.
     if (!shaka.util.Platform.supportsMediaSource()) {
       return false;
@@ -240,11 +148,6 @@ shaka.media.ManifestParser = class {
       return true;
     }
 
-    const extension = shaka.media.ManifestParser.getExtension(uri);
-    if (extension in shaka.media.ManifestParser.parsersByExtension) {
-      return true;
-    }
-
     return false;
   }
 };
@@ -292,11 +195,3 @@ shaka.media.ManifestParser.AccessibilityPurpose = {
 shaka.media.ManifestParser.parsersByMime = {};
 
 
-/**
- * Contains the parser factory functions indexed by file extension.
- *
- * @type {!Object.<string, shaka.extern.ManifestParser.Factory>}
- */
-shaka.media.ManifestParser.parsersByExtension = {};
-
-

package/lib/media/media_source_capabilities.js

@@ -23,9 +23,16 @@ shaka.media.Capabilities = class {
     if (supportMap.has(type)) {
       return supportMap.get(type);
     }
-    const currentSupport = MediaSource.isTypeSupported(type);
-    supportMap.set(type, currentSupport);
-    return currentSupport;
+    if (window.ManagedMediaSource) {
+      const currentSupport = ManagedMediaSource.isTypeSupported(type);
+      supportMap.set(type, currentSupport);
+      return currentSupport;
+    } else if (window.MediaSource) {
+      const currentSupport = MediaSource.isTypeSupported(type);
+      supportMap.set(type, currentSupport);
+      return currentSupport;
+    }
+    return false;
   }
 
   /**