shaka-player 4.5.0 → 4.6.1

package/lib/hls/hls_utils.js

@@ -6,6 +6,8 @@
 
 goog.provide('shaka.hls.Utils');
 
+goog.require('shaka.log');
+goog.require('shaka.util.Error');
 goog.require('shaka.util.ManifestParserUtils');
 goog.requireType('shaka.hls.Tag');
 
@@ -68,17 +70,74 @@ shaka.hls.Utils = class {
     return value;
   }
 
+  /**
+   * @param {!Array.<string>} baseUris
+   * @param {?string} relativeUri
+   * @param {?Map.<string, string>=} variables
+   * @return {!Array.<string>}
+   */
+  static constructSegmentUris(baseUris, relativeUri, variables) {
+    if (!relativeUri) {
+      return [];
+    }
+    return shaka.hls.Utils.constructUris(baseUris, [relativeUri], variables);
+  }
+
+
+  /**
+   * @param {!Array.<string>} baseUris
+   * @param {!Array.<string>} relativeUris
+   * @param {?Map.<string, string>=} variables
+   * @return {!Array.<string>}
+   */
+  static constructUris(baseUris, relativeUris, variables) {
+    if (!relativeUris.length) {
+      return [];
+    }
+    const resolvedUris = shaka.util.ManifestParserUtils.resolveUris(
+        baseUris, relativeUris);
+
+    const uris = [];
+    for (const uri of resolvedUris) {
+      uris.push(shaka.hls.Utils.variableSubstitution(uri, variables));
+    }
+
+    return uris;
+  }
 
   /**
-   * @param {string} parentAbsoluteUri
+   * Replaces the variables of a given URI.
+   *
    * @param {string} uri
+   * @param {?Map.<string, string>=} variables
    * @return {string}
    */
-  static constructAbsoluteUri(parentAbsoluteUri, uri) {
-    const uris = shaka.util.ManifestParserUtils.resolveUris(
-        [parentAbsoluteUri], [uri]);
+  static variableSubstitution(uri, variables) {
+    if (!variables || !variables.size) {
+      return uri;
+    }
+    let newUri = String(uri).replace(/%7B/g, '{').replace(/%7D/g, '}');
 
-    return uris[0];
+    const uriVariables = newUri.match(/{\$\w*}/g);
+    if (uriVariables) {
+      for (const variable of uriVariables) {
+        // Note: All variables have the structure {$...}
+        const variableName = variable.slice(2, variable.length - 1);
+        const replaceValue = variables.get(variableName);
+        if (replaceValue) {
+          newUri = newUri.replace(variable, replaceValue);
+        } else {
+          shaka.log.error('A variable has been found that is not declared',
+              variableName);
+          throw new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.MANIFEST,
+              shaka.util.Error.Code.HLS_VARIABLE_NOT_FOUND,
+              variableName);
+        }
+      }
+    }
+    return newUri;
   }
 
 

package/lib/hls/manifest_text_parser.js

@@ -29,10 +29,9 @@ shaka.hls.ManifestTextParser = class {
 
   /**
    * @param {BufferSource} data
-   * @param {string} absolutePlaylistUri An absolute, final URI after redirects.
    * @return {!shaka.hls.Playlist}
    */
-  parsePlaylist(data, absolutePlaylistUri) {
+  parsePlaylist(data) {
     const MEDIA_PLAYLIST_TAGS =
         shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS;
     const SEGMENT_TAGS = shaka.hls.ManifestTextParser.SEGMENT_TAGS;
@@ -101,10 +100,8 @@ shaka.hls.ManifestTextParser = class {
         }
 
         const segmentsData = lines.splice(i, lines.length - i);
-        const segments = this.parseSegments_(
-            absolutePlaylistUri, segmentsData, tags);
-        return new shaka.hls.Playlist(
-            absolutePlaylistUri, playlistType, tags, segments);
+        const segments = this.parseSegments_(segmentsData, tags);
+        return new shaka.hls.Playlist(playlistType, tags, segments);
       }
 
       tags.push(tag);
@@ -118,19 +115,18 @@ shaka.hls.ManifestTextParser = class {
       }
     }
 
-    return new shaka.hls.Playlist(absolutePlaylistUri, playlistType, tags);
+    return new shaka.hls.Playlist(playlistType, tags);
   }
 
   /**
    * Parses an array of strings into an array of HLS Segment objects.
    *
-   * @param {string} absoluteMediaPlaylistUri
    * @param {!Array.<string>} lines
    * @param {!Array.<!shaka.hls.Tag>} playlistTags
    * @return {!Array.<shaka.hls.Segment>}
    * @private
    */
-  parseSegments_(absoluteMediaPlaylistUri, lines, playlistTags) {
+  parseSegments_(lines, playlistTags) {
     /** @type {!Array.<shaka.hls.Segment>} */
     const segments = [];
     /** @type {!Array.<shaka.hls.Tag>} */
@@ -177,7 +173,7 @@ shaka.hls.ManifestTextParser = class {
           segmentTags.push(currentMapTag);
         }
         // The URI appears after all of the tags describing the segment.
-        const segment = new shaka.hls.Segment(absoluteMediaPlaylistUri,
+        const segment = new shaka.hls.Segment(
             verbatimSegmentUri, segmentTags, partialSegmentTags);
         segments.push(segment);
         segmentTags = [];
@@ -193,7 +189,7 @@ shaka.hls.ManifestTextParser = class {
       if (currentMapTag) {
         segmentTags.push(currentMapTag);
       }
-      const segment = new shaka.hls.Segment('', '', segmentTags,
+      const segment = new shaka.hls.Segment('', segmentTags,
           partialSegmentTags);
       segments.push(segment);
     }

package/lib/media/adaptation_set.js

@@ -26,8 +26,11 @@ shaka.media.AdaptationSet = class {
    *    Variants that may be compatible with the root and should be added if
    *    compatible. If a candidate is not compatible, it will not end up in the
    *    adaptation set.
+   * @param {boolean=} compareCodecs
+   * @param {boolean=} enableAudioGroups
    */
-  constructor(root, candidates) {
+  constructor(root, candidates, compareCodecs = true,
+      enableAudioGroups = false) {
     /** @private {shaka.extern.Variant} */
     this.root_ = root;
     /** @private {!Set.<shaka.extern.Variant>} */
@@ -37,17 +40,18 @@ shaka.media.AdaptationSet = class {
     // are not compatible with the root, they will be rejected by |add|.
     candidates = candidates || [];
     for (const candidate of candidates) {
-      this.add(candidate);
+      this.add(candidate, compareCodecs, enableAudioGroups);
     }
   }
 
   /**
    * @param {shaka.extern.Variant} variant
-   * @param {boolean=} compareCodecs
+   * @param {boolean} compareCodecs
+   * @param {boolean} enableAudioGroups
    * @return {boolean}
    */
-  add(variant, compareCodecs = true) {
-    if (this.canInclude(variant, compareCodecs)) {
+  add(variant, compareCodecs, enableAudioGroups) {
+    if (this.canInclude(variant, compareCodecs, enableAudioGroups)) {
       this.variants_.add(variant);
       return true;
     }
@@ -64,20 +68,22 @@ shaka.media.AdaptationSet = class {
    *
    * @param {shaka.extern.Variant} variant
    * @param {boolean=} compareCodecs
+   * @param {boolean=} enableAudioGroups
    * @return {boolean}
    */
-  canInclude(variant, compareCodecs = true) {
+  canInclude(variant, compareCodecs = true, enableAudioGroups = false) {
     return shaka.media.AdaptationSet
-        .areAdaptable(this.root_, variant, compareCodecs);
+        .areAdaptable(this.root_, variant, compareCodecs, enableAudioGroups);
   }
 
   /**
    * @param {shaka.extern.Variant} a
    * @param {shaka.extern.Variant} b
-   * @param {boolean=} compareCodecs
+   * @param {boolean} compareCodecs
+   * @param {boolean} enableAudioGroups
    * @return {boolean}
    */
-  static areAdaptable(a, b, compareCodecs = true) {
+  static areAdaptable(a, b, compareCodecs, enableAudioGroups) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // All variants should have audio or should all not have audio.
@@ -98,8 +104,8 @@ shaka.media.AdaptationSet = class {
     goog.asserts.assert(
         !!a.audio == !!b.audio,
         'Both should either have audio or not have audio.');
-    if (a.audio && b.audio &&
-        !AdaptationSet.areAudiosCompatible_(a.audio, b.audio, compareCodecs)) {
+    if (a.audio && b.audio && !AdaptationSet.areAudiosCompatible_(
+        a.audio, b.audio, compareCodecs, enableAudioGroups)) {
       return false;
     }
 
@@ -127,10 +133,11 @@ shaka.media.AdaptationSet = class {
    * @param {shaka.extern.Stream} a
    * @param {shaka.extern.Stream} b
    * @param {boolean} compareCodecs
+   * @param {boolean} enableAudioGroups
    * @return {boolean}
    * @private
    */
-  static areAudiosCompatible_(a, b, compareCodecs) {
+  static areAudiosCompatible_(a, b, compareCodecs, enableAudioGroups) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // Don't adapt between channel counts, which could annoy the user
@@ -154,7 +161,7 @@ shaka.media.AdaptationSet = class {
     }
 
     // We can only adapt between the same groupId.
-    if (a.groupId !== b.groupId) {
+    if (enableAudioGroups && a.groupId !== b.groupId) {
       return false;
     }
 

package/lib/media/adaptation_set_criteria.js

@@ -13,7 +13,6 @@ goog.require('shaka.log');
 goog.require('shaka.media.AdaptationSet');
 goog.require('shaka.media.Capabilities');
 goog.require('shaka.util.LanguageUtils');
-goog.require('shaka.util.StreamUtils');
 
 
 /**
@@ -43,27 +42,33 @@ shaka.media.ExampleBasedCriteria = class {
   /**
    * @param {shaka.extern.Variant} example
    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
+   * @param {boolean=} enableAudioGroups
    */
   constructor(example,
-      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD) {
+      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,
-        codecSwitchingStrategy);
+        example.language, role, channelCount, hdrLevel, videoLayout, label,
+        codecSwitchingStrategy, enableAudioGroups);
   }
 
   /** @override */
@@ -75,14 +80,15 @@ shaka.media.ExampleBasedCriteria = class {
     // actually be from another period.
     const shortList = variants.filter((variant) => {
       return shaka.media.AdaptationSet.areAdaptable(this.example_, variant,
-          !supportsSmoothCodecTransitions);
+          !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);
     }
@@ -100,11 +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 = '',
-      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD) {
+  constructor(language, role, channelCount, hdrLevel, videoLayout, label = '',
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
+      enableAudioGroups = false) {
     /** @private {string} */
     this.language_ = language;
     /** @private {string} */
@@ -114,15 +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 = [];
 
@@ -146,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_);
@@ -158,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;
@@ -181,14 +204,8 @@ shaka.media.PreferenceBasedCriteria = class {
       shaka.config.CodecSwitchingStrategy.SMOOTH &&
         shaka.media.Capabilities.isChangeTypeSupported();
 
-    // Make sure we only return a valid adaptation set.
-    const set = new shaka.media.AdaptationSet(current[0]);
-    for (const variant of current) {
-      // `add` checks combatability by calling `canInclude` internally.
-      set.add(variant, !supportsSmoothCodecTransitions);
-    }
-
-    return set;
+    return new shaka.media.AdaptationSet(current[0], current,
+        !supportsSmoothCodecTransitions, this.enableAudioGroups_);
   }
 
   /**
@@ -261,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.
@@ -285,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]) :