shaka-player 4.4.3 → 4.6.0

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/lcevc/lcevc_dec.js

@@ -0,0 +1,220 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.lcevc.Dec');
+goog.require('shaka.log');
+goog.require('shaka.Deprecate');
+goog.require('shaka.util.IReleasable');
+
+/**
+ * @summary
+ *  lcevcDec - (MPEG-5 Part 2 LCEVC - Decoder) provides
+ *  all the operations related to the enhancement and rendering
+ *  of LCEVC enabled streams and on to a canvas.
+ * @implements {shaka.util.IReleasable}
+ * @export
+ */
+shaka.lcevc.Dec = class {
+  /**
+   * @param {HTMLVideoElement} media The video element that will be attached to
+   * LCEVC Decoder for input.
+   * @param {HTMLCanvasElement} canvas The canvas element that will be attached
+   * to LCEVC Decoder to render the enhanced frames.
+   * @param {shaka.extern.LcevcConfiguration} lcevcConfig LCEVC configuration
+   * object to initialize the LCEVC Decoder.
+   */
+  constructor(media, canvas, lcevcConfig) {
+    /**
+     * LCEVC Decoder library based on availability, to check if either
+     * lcevc_dil or lcevc_dec is present.
+     * @private {LCEVCmodule}
+     */
+    this.lcevcLib_;
+
+    /** @private {?LCEVCdec.LCEVCdec} */
+    this.dec_ = null;
+
+    /** @private {number} */
+    this.variantId_ = -1;
+
+    /** @private {HTMLVideoElement} */
+    this.media_ = media;
+
+    /** @private {HTMLCanvasElement} */
+    this.canvas_ = canvas;
+
+    /** @private {shaka.extern.LcevcConfiguration} */
+    this.decConfig_ = lcevcConfig;
+
+    /** @private {boolean} */
+    this.toBeDeprecated_ = false;
+
+    this.create_();
+  }
+
+  /**
+   * Append data to the LCEVC Dec.
+   * @param {BufferSource} data
+   * @param {number} timestampOffset
+   */
+  appendBuffer(data, timestampOffset) {
+    if (this.dec_) {
+      // Timestamp offset describes how much offset should be applied to the
+      // LCEVC enhancement to match the decoded video frame, as such it needs
+      // to be negated.
+      this.dec_.appendBuffer(data, 'video', this.variantId_, -timestampOffset);
+    }
+  }
+
+  /**
+   * Hide the canvas specifically in the case of a DRM Content
+   */
+  hideCanvas() {
+    if (this.dec_) {
+      this.canvas_.classList.add('shaka-hidden');
+    }
+  }
+
+  /**
+   * Create LCEVC Decoder.
+   * @private
+   */
+  create_() {
+    if (this.isSupported_() && !this.dec_) {
+      if (this.lcevcLib_.SupportObject.webGLSupport(this.canvas_)) {
+        // Make sure the canvas is not hidden from a previous playback session.
+        this.canvas_.classList.remove('shaka-hidden');
+        // Initiate LCEVC Dec Library based on the type of module available.
+        if (this.toBeDeprecated_) {
+          this.dec_ = new this.lcevcLib_.LcevcDil(
+              this.media_,
+              this.canvas_,
+              this.decConfig_);
+        } else {
+          this.dec_ = new this.lcevcLib_.LCEVCdec(
+              this.media_,
+              this.canvas_,
+              this.decConfig_);
+        }
+      }
+    }
+  }
+
+  /**
+   * Close LCEVC Decoder.
+   * @override
+   * @export
+   */
+  release() {
+    if (this.dec_) {
+      this.dec_.close();
+      this.dec_ = null;
+    }
+  }
+
+  /**
+   * Check if the LCEVC Decoder lib is present and is supported by the browser.
+   * @return {boolean}
+   * @private
+   */
+  isSupported_() {
+    if (typeof libDPIModule === 'undefined') {
+      shaka.log.alwaysWarn(
+          'Could not find LCEVC Library dependencies on this page');
+    }
+
+    // This is a check to make the LCEVC Dec Integration is backwards compatible
+    // with previous Integration. This logic checks for both implementations
+    // and uses the one available.
+    if (typeof LCEVCdec !== 'undefined') {
+      this.lcevcLib_ = LCEVCdec;
+    } else {
+      if (typeof LcevcDil !== 'undefined') {
+        this.lcevcLib_ = LcevcDil;
+        this.toBeDeprecated_ = true;
+        shaka.Deprecate.deprecateFeature(5,
+            'LcevcDil',
+            'lcevc_dil.js is deprecated, please use lcevc_dec.js instead');
+      } else {
+        shaka.log.alwaysWarn('Could not find LCEVC Library on this page');
+        return false;
+      }
+    }
+
+    // Making Sure if there is a valid LCEVC Dec Library exists.
+    if (typeof this.lcevcLib_.SupportObject === 'undefined') {
+      shaka.log.alwaysWarn('Could not find LCEVC Library on this page');
+      return false;
+    } else {
+      if (!this.lcevcLib_.SupportObject.SupportStatus) {
+        shaka.log.alwaysWarn(this.lcevcLib_.SupportObject.SupportError);
+      }
+    }
+
+    return typeof this.lcevcLib_ !== 'undefined' &&
+      typeof libDPIModule !== 'undefined' &&
+      this.canvas_ instanceof HTMLCanvasElement &&
+      this.lcevcLib_.SupportObject.SupportStatus;
+  }
+
+  /**
+   * Update current active variant
+   * @param {shaka.extern.Track} track
+   */
+  updateVariant(track, manifestType) {
+    let containerFormat = shaka.lcevc.Dec.ContainerFormat.MPEG2_TS;
+    let streamingFormat = shaka.lcevc.Dec.StreamingFormat.OTHER;
+    switch (track.mimeType) {
+      case 'video/webm': {
+        containerFormat = shaka.lcevc.Dec.ContainerFormat.WEBM;
+        break;
+      }
+      case 'video/mp4': {
+        containerFormat = shaka.lcevc.Dec.ContainerFormat.MP4;
+        break;
+      }
+    }
+    switch (manifestType) {
+      case 'DASH': {
+        streamingFormat = shaka.lcevc.Dec.StreamingFormat.DASH;
+        break;
+      }
+      case 'HLS': {
+        streamingFormat = shaka.lcevc.Dec.StreamingFormat.HLS;
+        break;
+      }
+    }
+    if (this.dec_) {
+      this.variantId_ = track.id;
+      this.dec_.setLevelSwitching(track.id, true);
+      this.dec_.setContainerFormat(containerFormat);
+      // This functionality is only available on the LCEVC Dec Library.
+      if (!this.toBeDeprecated_) {
+        this.dec_.setStreamingFormat(streamingFormat);
+      }
+    }
+  }
+};
+
+/**
+ * Container Formats.
+ * @const @enum {number}
+ */
+shaka.lcevc.Dec.ContainerFormat = {
+  MPEG2_TS: 0,
+  WEBM: 1,
+  MP4: 2,
+};
+
+/**
+ * Streaming Formats.
+ * @const @enum {number}
+ */
+shaka.lcevc.Dec.StreamingFormat = {
+  HLS: 0,
+  DASH: 1,
+  OTHER: -1,
+};

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,16 +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} enableAudioGroups
    * @return {boolean}
    */
-  add(variant) {
-    if (this.canInclude(variant)) {
+  add(variant, compareCodecs, enableAudioGroups) {
+    if (this.canInclude(variant, compareCodecs, enableAudioGroups)) {
       this.variants_.add(variant);
       return true;
     }
@@ -62,18 +67,23 @@ shaka.media.AdaptationSet = class {
    * |false|, calling |add| will result in it being ignored.
    *
    * @param {shaka.extern.Variant} variant
+   * @param {boolean=} compareCodecs
+   * @param {boolean=} enableAudioGroups
    * @return {boolean}
    */
-  canInclude(variant) {
-    return shaka.media.AdaptationSet.areAdaptable(this.root_, variant);
+  canInclude(variant, compareCodecs = true, enableAudioGroups = false) {
+    return shaka.media.AdaptationSet
+        .areAdaptable(this.root_, variant, compareCodecs, enableAudioGroups);
   }
 
   /**
    * @param {shaka.extern.Variant} a
    * @param {shaka.extern.Variant} b
+   * @param {boolean} compareCodecs
+   * @param {boolean} enableAudioGroups
    * @return {boolean}
    */
-  static areAdaptable(a, b) {
+  static areAdaptable(a, b, compareCodecs, enableAudioGroups) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // All variants should have audio or should all not have audio.
@@ -94,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)) {
+    if (a.audio && b.audio && !AdaptationSet.areAudiosCompatible_(
+        a.audio, b.audio, compareCodecs, enableAudioGroups)) {
       return false;
     }
 
@@ -103,7 +113,7 @@ shaka.media.AdaptationSet = class {
         !!a.video == !!b.video,
         'Both should either have video or not have video.');
     if (a.video && b.video &&
-        !AdaptationSet.areVideosCompatible_(a.video, b.video)) {
+        !AdaptationSet.areVideosCompatible_(a.video, b.video, compareCodecs)) {
       return false;
     }
 
@@ -122,10 +132,12 @@ 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) {
+  static areAudiosCompatible_(a, b, compareCodecs, enableAudioGroups) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // Don't adapt between channel counts, which could annoy the user
@@ -139,7 +151,7 @@ shaka.media.AdaptationSet = class {
     }
 
     // We can only adapt between base-codecs.
-    if (!AdaptationSet.canTransitionBetween_(a, b)) {
+    if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
       return false;
     }
 
@@ -148,6 +160,11 @@ shaka.media.AdaptationSet = class {
       return false;
     }
 
+    // We can only adapt between the same groupId.
+    if (enableAudioGroups && a.groupId !== b.groupId) {
+      return false;
+    }
+
     return true;
   }
 
@@ -156,14 +173,15 @@ shaka.media.AdaptationSet = class {
    *
    * @param {shaka.extern.Stream} a
    * @param {shaka.extern.Stream} b
+   * @param {boolean} compareCodecs
    * @return {boolean}
    * @private
    */
-  static areVideosCompatible_(a, b) {
+  static areVideosCompatible_(a, b, compareCodecs) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // We can only adapt between base-codecs.
-    if (!AdaptationSet.canTransitionBetween_(a, b)) {
+    if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
       return false;
     }