shaka-player 4.4.2 → 4.5.0

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

@@ -43,10 +43,11 @@ shaka.media.AdaptationSet = class {
 
   /**
    * @param {shaka.extern.Variant} variant
+   * @param {boolean=} compareCodecs
    * @return {boolean}
    */
-  add(variant) {
-    if (this.canInclude(variant)) {
+  add(variant, compareCodecs = true) {
+    if (this.canInclude(variant, compareCodecs)) {
       this.variants_.add(variant);
       return true;
     }
@@ -62,18 +63,21 @@ shaka.media.AdaptationSet = class {
    * |false|, calling |add| will result in it being ignored.
    *
    * @param {shaka.extern.Variant} variant
+   * @param {boolean=} compareCodecs
    * @return {boolean}
    */
-  canInclude(variant) {
-    return shaka.media.AdaptationSet.areAdaptable(this.root_, variant);
+  canInclude(variant, compareCodecs = true) {
+    return shaka.media.AdaptationSet
+        .areAdaptable(this.root_, variant, compareCodecs);
   }
 
   /**
    * @param {shaka.extern.Variant} a
    * @param {shaka.extern.Variant} b
+   * @param {boolean=} compareCodecs
    * @return {boolean}
    */
-  static areAdaptable(a, b) {
+  static areAdaptable(a, b, compareCodecs = true) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // All variants should have audio or should all not have audio.
@@ -95,7 +99,7 @@ shaka.media.AdaptationSet = class {
         !!a.audio == !!b.audio,
         'Both should either have audio or not have audio.');
     if (a.audio && b.audio &&
-        !AdaptationSet.areAudiosCompatible_(a.audio, b.audio)) {
+        !AdaptationSet.areAudiosCompatible_(a.audio, b.audio, compareCodecs)) {
       return false;
     }
 
@@ -103,7 +107,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 +126,11 @@ shaka.media.AdaptationSet = class {
    *
    * @param {shaka.extern.Stream} a
    * @param {shaka.extern.Stream} b
+   * @param {boolean} compareCodecs
    * @return {boolean}
    * @private
    */
-  static areAudiosCompatible_(a, b) {
+  static areAudiosCompatible_(a, b, compareCodecs) {
     const AdaptationSet = shaka.media.AdaptationSet;
 
     // Don't adapt between channel counts, which could annoy the user
@@ -139,7 +144,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 +153,11 @@ shaka.media.AdaptationSet = class {
       return false;
     }
 
+    // We can only adapt between the same groupId.
+    if (a.groupId !== b.groupId) {
+      return false;
+    }
+
     return true;
   }
 
@@ -156,14 +166,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;
     }
 

package/lib/media/adaptation_set_criteria.js

@@ -8,8 +8,10 @@ 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,10 +42,14 @@ shaka.media.AdaptationSetCriteria = class {
 shaka.media.ExampleBasedCriteria = class {
   /**
    * @param {shaka.extern.Variant} example
+   * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    */
-  constructor(example) {
+  constructor(example,
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD) {
     /** @private {shaka.extern.Variant} */
     this.example_ = example;
+    /** @private {shaka.config.CodecSwitchingStrategy} */
+    this.codecSwitchingStrategy_ = codecSwitchingStrategy;
 
     // We can't know if role and label are really important, so we don't use
     // role and label for this.
@@ -56,15 +62,20 @@ shaka.media.ExampleBasedCriteria = class {
 
     /** @private {!shaka.media.AdaptationSetCriteria} */
     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
-        example.language, role, channelCount, hdrLevel, label);
+        example.language, role, channelCount, hdrLevel, label,
+        codecSwitchingStrategy);
   }
 
   /** @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);
     });
 
     if (shortList.length) {
@@ -90,8 +101,10 @@ shaka.media.PreferenceBasedCriteria = class {
    * @param {number} channelCount
    * @param {string} hdrLevel
    * @param {string=} label
+   * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    */
-  constructor(language, role, channelCount, hdrLevel, label = '') {
+  constructor(language, role, channelCount, hdrLevel, label = '',
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD) {
     /** @private {string} */
     this.language_ = language;
     /** @private {string} */
@@ -102,6 +115,8 @@ shaka.media.PreferenceBasedCriteria = class {
     this.hdrLevel_ = hdrLevel;
     /** @private {string} */
     this.label_ = label;
+    /** @private {shaka.config.CodecSwitchingStrategy} */
+    this.codecSwitchingStrategy_ = codecSwitchingStrategy;
   }
 
   /** @override */
@@ -162,12 +177,15 @@ shaka.media.PreferenceBasedCriteria = class {
       }
     }
 
+    const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
+      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) {
-      if (set.canInclude(variant)) {
-        set.add(variant);
-      }
+      // `add` checks combatability by calling `canInclude` internally.
+      set.add(variant, !supportsSmoothCodecTransitions);
     }
 
     return set;