shaka-player 4.4.3 → 4.5.0

package/lib/dash/segment_template.js

@@ -36,17 +36,19 @@ shaka.dash.SegmentTemplate = class {
    * @param {number} segmentLimit The maximum number of segments to generate for
    *   a SegmentTemplate with fixed duration.
    * @param {!Object.<string, number>} periodDurationMap
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
       context, requestSegment, streamMap, isUpdate, segmentLimit,
-      periodDurationMap) {
+      periodDurationMap, aes128Key) {
     goog.asserts.assert(context.representation.segmentTemplate,
         'Should only be called with SegmentTemplate');
     const SegmentTemplate = shaka.dash.SegmentTemplate;
     const TimelineSegmentIndex = shaka.dash.TimelineSegmentIndex;
 
-    const initSegmentReference = SegmentTemplate.createInitSegment_(context);
+    const initSegmentReference =
+        SegmentTemplate.createInitSegment_(context, aes128Key);
 
     /** @type {shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
     const info = SegmentTemplate.parseSegmentTemplateInfo_(context);
@@ -82,7 +84,7 @@ shaka.dash.SegmentTemplate = class {
         generateSegmentIndex: () => {
           return SegmentTemplate.generateSegmentIndexFromDuration_(
               shallowCopyOfContext, info, segmentLimit, initSegmentReference,
-              periodDurationMap);
+              periodDurationMap, aes128Key);
         },
       };
     } else {
@@ -134,6 +136,7 @@ shaka.dash.SegmentTemplate = class {
             periodEnd,
             initSegmentReference,
             shouldFit,
+            aes128Key,
         );
       } else {
         const tsi = /** @type {!TimelineSegmentIndex} */(segmentIndex);
@@ -299,11 +302,13 @@ shaka.dash.SegmentTemplate = class {
    * @param {number} segmentLimit The maximum number of segments to generate.
    * @param {shaka.media.InitSegmentReference} initSegmentReference
    * @param {!Object.<string, number>} periodDurationMap
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {!Promise.<shaka.media.SegmentIndex>}
    * @private
    */
   static generateSegmentIndexFromDuration_(
-      context, info, segmentLimit, initSegmentReference, periodDurationMap) {
+      context, info, segmentLimit, initSegmentReference, periodDurationMap,
+      aes128Key) {
     goog.asserts.assert(info.mediaTemplate,
         'There should be a media template with duration');
 
@@ -419,9 +424,12 @@ shaka.dash.SegmentTemplate = class {
           info.scaledPresentationTimeOffset;
 
       const getUris = () => {
+        let time = segmentMediaTime * timescale;
+        if ('BigInt' in window && time > Number.MAX_SAFE_INTEGER) {
+          time = BigInt(segmentMediaTime) * BigInt(timescale);
+        }
         const mediaUri = MpdUtils.fillUriTemplate(
-            template, id, position, bandwidth,
-            segmentMediaTime * timescale);
+            template, id, position, bandwidth, time);
         return ManifestParserUtils.resolveUris(baseUris, [mediaUri]);
       };
 
@@ -446,7 +454,13 @@ shaka.dash.SegmentTemplate = class {
           initSegmentReference,
           timestampOffset,
           /* appendWindowStart= */ periodStart,
-          /* appendWindowEnd= */ getPeriodEnd());
+          /* appendWindowEnd= */ getPeriodEnd(),
+          /* partialReferences= */ [],
+          /* tilesLayout= */ '',
+          /* tileDuration= */ null,
+          /* syncTime= */ null,
+          shaka.media.SegmentReference.Status.AVAILABLE,
+          aes128Key);
       // This is necessary information for thumbnail streams:
       ref.trueEndTime = trueSegmentEnd;
       return ref;
@@ -505,87 +519,15 @@ shaka.dash.SegmentTemplate = class {
     return Promise.resolve(segmentIndex);
   }
 
-  /**
-   * Creates segment references from a timeline.
-   *
-   * @param {shaka.dash.DashParser.Context} context
-   * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
-   * @param {shaka.media.InitSegmentReference} initSegmentReference
-   * @return {!Array.<!shaka.media.SegmentReference>}
-   * @private
-   */
-  static createFromTimeline_(context, info, initSegmentReference) {
-    const MpdUtils = shaka.dash.MpdUtils;
-    const ManifestParserUtils = shaka.util.ManifestParserUtils;
-
-    const periodStart = context.periodInfo.start;
-    const periodDuration = context.periodInfo.duration;
-
-    const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
-    const appendWindowStart = periodStart;
-    const appendWindowEnd = periodDuration ?
-        periodStart + periodDuration : Infinity;
-
-    /** @type {!Array.<!shaka.media.SegmentReference>} */
-    const references = [];
-    for (let i = 0; i < info.timeline.length; i++) {
-      const {start, unscaledStart, end} = info.timeline[i];
-
-      // Note: i = k - 1, where k indicates the k'th segment listed in the MPD.
-      // (See section 5.3.9.5.3 of the DASH spec.)
-      const segmentReplacement = i + info.startNumber;
-
-      // Consider the presentation time offset in segment uri computation
-      const timeReplacement = unscaledStart +
-          info.unscaledPresentationTimeOffset;
-      const repId = context.representation.id;
-      const bandwidth = context.bandwidth || null;
-      const mediaTemplate = info.mediaTemplate;
-      const baseUris = context.representation.baseUris;
-
-      // This callback must not capture any non-local
-      // variables, such as info, context, etc.  Make
-      // sure any values you reference here have
-      // been assigned to local variables within the
-      // loop, or else we will end up with a leak.
-      const createUris =
-          () => {
-            goog.asserts.assert(
-                mediaTemplate,
-                'There should be a media template with a timeline');
-            const mediaUri = MpdUtils.fillUriTemplate(
-                mediaTemplate, repId,
-                segmentReplacement, bandwidth || null, timeReplacement);
-            return ManifestParserUtils
-                .resolveUris(baseUris, [mediaUri])
-                .map((g) => {
-                  return g.toString();
-                });
-          };
-
-      references.push(new shaka.media.SegmentReference(
-          periodStart + start,
-          periodStart + end,
-          createUris,
-          /* startByte= */ 0,
-          /* endByte= */ null,
-          initSegmentReference,
-          timestampOffset,
-          appendWindowStart,
-          appendWindowEnd));
-    }
-
-    return references;
-  }
-
   /**
    * Creates an init segment reference from a context object.
    *
    * @param {shaka.dash.DashParser.Context} context
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.media.InitSegmentReference}
    * @private
    */
-  static createInitSegment_(context) {
+  static createInitSegment_(context, aes128Key) {
     const MpdUtils = shaka.dash.MpdUtils;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const SegmentTemplate = shaka.dash.SegmentTemplate;
@@ -608,7 +550,14 @@ shaka.dash.SegmentTemplate = class {
       return resolvedUris;
     };
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
-    return new shaka.media.InitSegmentReference(getUris, 0, null, qualityInfo);
+    return new shaka.media.InitSegmentReference(
+        getUris,
+        /* startByte= */ 0,
+        /* endByte= */ null,
+        qualityInfo,
+        /* timescale= */ null,
+        /* segmentData= */ null,
+        aes128Key);
   }
 };
 
@@ -635,10 +584,11 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
    * @param {number} periodEnd
    * @param {shaka.media.InitSegmentReference} initSegmentReference
    * @param {boolean} shouldFit
-   *
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
   */
   constructor(templateInfo, representationId, bandwidth, baseUris,
-      periodStart, periodEnd, initSegmentReference, shouldFit) {
+      periodStart, periodEnd, initSegmentReference, shouldFit,
+      aes128Key) {
     super([]);
 
     /** @private {?shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
@@ -655,6 +605,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
     this.periodEnd_ = periodEnd;
     /** @private {shaka.media.InitSegmentReference} */
     this.initSegmentReference_ = initSegmentReference;
+    /** @private {shaka.extern.aes128Key|undefined} */
+    this.aes128Key_ = aes128Key;
 
 
     if (shouldFit) {
@@ -894,7 +846,13 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
           this.initSegmentReference_,
           timestampOffset,
           this.periodStart_,
-          this.periodEnd_);
+          this.periodEnd_,
+          /* partialReferences= */ [],
+          /* tilesLayout= */ '',
+          /* tileDuration= */ null,
+          /* syncTime= */ null,
+          shaka.media.SegmentReference.Status.AVAILABLE,
+          this.aes128Key_);
       this.references[correctedPosition] = ref;
     }
 

package/lib/dependencies/all.js

@@ -6,6 +6,8 @@
 
 goog.provide('shaka.dependencies');
 
+goog.require('shaka.Deprecate');
+
 /**
  * @export
  */
@@ -22,6 +24,12 @@ shaka.dependencies = class {
     if (!shaka.dependencies.Allowed[key]) {
       throw new Error(`${key} is not supported`);
     }
+    if (key == shaka.dependencies.Allowed.muxjs) {
+      shaka.Deprecate.deprecateFeature(5,
+          'mux.js',
+          'mux.js is no longer used in Shaka Player.');
+      return;
+    }
     shaka.dependencies.dependencies_.set(key, () => dep);
   }
 
@@ -36,12 +44,6 @@ shaka.dependencies = class {
     return shaka.dependencies.dependencies_.has(key);
   }
 
-  /** @return {?muxjs} */
-  static muxjs() {
-    return /** @type {?muxjs} */ (shaka.dependencies.dependencies_.get(
-        shaka.dependencies.Allowed.muxjs)());
-  }
-
   /** @return {?ISOBoxer} */
   static isoBoxer() {
     return /** @type {?ISOBoxer} */ (shaka.dependencies.dependencies_.get(
@@ -65,6 +67,5 @@ shaka.dependencies.Allowed = {
  * @private {!Map.<shaka.dependencies.Allowed, function():?>}
  */
 shaka.dependencies.dependencies_ = new Map([
-  [shaka.dependencies.Allowed.muxjs, () => window.muxjs],
   [shaka.dependencies.Allowed.ISOBoxer, () => window.ISOBoxer],
 ]);

package/lib/hls/hls_parser.js

@@ -9,6 +9,7 @@ goog.provide('shaka.hls.HlsParser');
 
 goog.require('goog.Uri');
 goog.require('goog.asserts');
+goog.require('shaka.abr.Ewma');
 goog.require('shaka.hls.ManifestTextParser');
 goog.require('shaka.hls.Playlist');
 goog.require('shaka.hls.PlaylistType');
@@ -215,6 +216,13 @@ shaka.hls.HlsParser = class {
 
     /** @private {boolean} */
     this.lowLatencyByterangeOptimization_ = false;
+
+    /**
+     * An ewma that tracks how long updates take.
+     * This is to mitigate issues caused by slow parsing on embedded devices.
+     * @private {!shaka.abr.Ewma}
+     */
+    this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
   }
 
 
@@ -932,7 +940,11 @@ shaka.hls.HlsParser = class {
         hasVideo = true;
         break;
       case 'hvc':
-        codecs.push('hvc1.1.6.L93.90');
+        if (videoInfo.codec) {
+          codecs.push(videoInfo.codec);
+        } else {
+          codecs.push('hvc1.1.6.L93.90');
+        }
         hasVideo = true;
         break;
     }
@@ -2493,6 +2505,7 @@ shaka.hls.HlsParser = class {
     return {
       id: this.globalId_++,
       originalId: name,
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex: null,
       mimeType,
@@ -2595,7 +2608,7 @@ shaka.hls.HlsParser = class {
   /**
    * @param {!shaka.hls.Tag} drmTag
    * @param {!shaka.hls.Playlist} playlist
-   * @return {!shaka.extern.HlsAes128Key}
+   * @return {!shaka.extern.aes128Key}
    * @private
    */
   parseAES128DrmTag_(drmTag, playlist) {
@@ -2629,7 +2642,7 @@ shaka.hls.HlsParser = class {
         throw new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_AES_128_INVALID_IV_LENGTH);
+            shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
       }
     }
 
@@ -2652,7 +2665,7 @@ shaka.hls.HlsParser = class {
         throw new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_AES_128_INVALID_KEY_LENGTH);
+            shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
       }
 
       const algorithm = {
@@ -2844,7 +2857,7 @@ shaka.hls.HlsParser = class {
       mapTag.getAttributeValue('BYTERANGE', ''),
     ].join('-');
     if (!this.mapTagToInitSegmentRefMap_.has(mapTagKey)) {
-      /** @type {shaka.extern.HlsAes128Key|undefined} */
+      /** @type {shaka.extern.aes128Key|undefined} */
       let aes128Key = undefined;
       for (const tag of tags) {
         if (tag.name == 'EXT-X-KEY') {
@@ -2866,7 +2879,7 @@ shaka.hls.HlsParser = class {
    * playlist.
    * @param {string} absoluteInitSegmentUri
    * @param {!shaka.hls.Tag} mapTag EXT-X-MAP
-   * @param {shaka.extern.HlsAes128Key=} aes128Key
+   * @param {shaka.extern.aes128Key=} aes128Key
    * @return {!shaka.media.InitSegmentReference}
    * @private
    */
@@ -2915,13 +2928,13 @@ shaka.hls.HlsParser = class {
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} type
    * @param {string} mimeType
-   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
+   * @param {shaka.extern.aes128Key=} aes128Key
    * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, absoluteMediaPlaylistUri, type, mimeType, hlsAes128Key) {
+      variables, absoluteMediaPlaylistUri, type, mimeType, aes128Key) {
     const tags = hlsSegment.tags;
     const extinfTag =
         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
@@ -3066,7 +3079,7 @@ shaka.hls.HlsParser = class {
             /* tileDuration= */ null,
             partialSyncTime,
             partialStatus,
-            hlsAes128Key);
+            aes128Key);
         if (item.name == 'EXT-X-PRELOAD-HINT') {
           partial.markAsPreload();
           isPreloadSegment = true;
@@ -3178,7 +3191,7 @@ shaka.hls.HlsParser = class {
         tileDuration,
         syncTime,
         status,
-        hlsAes128Key,
+        aes128Key,
     );
 
     if (segmentWithByteRangeOptimization) {
@@ -3245,8 +3258,8 @@ shaka.hls.HlsParser = class {
     /** @type {shaka.media.InitSegmentReference} */
     let initSegmentRef;
 
-    /** @type {shaka.extern.HlsAes128Key|undefined} */
-    let hlsAes128Key = undefined;
+    /** @type {shaka.extern.aes128Key|undefined} */
+    let aes128Key = undefined;
 
     let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
         playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', 0);
@@ -3289,9 +3302,9 @@ shaka.hls.HlsParser = class {
       for (const drmTag of item.tags) {
         if (drmTag.name == 'EXT-X-KEY') {
           if (drmTag.getRequiredAttrValue('METHOD') == 'AES-128') {
-            hlsAes128Key = this.parseAES128DrmTag_(drmTag, playlist);
+            aes128Key = this.parseAES128DrmTag_(drmTag, playlist);
           } else {
-            hlsAes128Key = undefined;
+            aes128Key = undefined;
           }
         }
       }
@@ -3322,7 +3335,7 @@ shaka.hls.HlsParser = class {
           playlist.absoluteUri,
           type,
           mimeType,
-          hlsAes128Key);
+          aes128Key);
 
       if (reference) {
         const bitrate = shaka.hls.Utils.getFirstTagWithNameAsNumber(
@@ -3690,12 +3703,20 @@ shaka.hls.HlsParser = class {
     }
 
     try {
+      const startTime = Date.now();
       await this.update();
 
+      // Keep track of how long the longest manifest update took.
+      const endTime = Date.now();
+
       // This may have converted to VOD, in which case we stop updating.
       if (this.isLive_()) {
+        const updateDuration = (endTime - startTime) / 1000.0;
+        this.averageUpdateDuration_.sample(1, updateDuration);
         const delay = this.getUpdatePlaylistDelay_();
-        this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+        const finalDelay = Math.max(0,
+            delay - this.averageUpdateDuration_.getEstimate());
+        this.updatePlaylistTimer_.tickAfter(/* seconds= */ finalDelay);
       }
     } catch (error) {
       // Detect a call to stop() during this.update()
@@ -3718,6 +3739,13 @@ shaka.hls.HlsParser = class {
       // Try again very soon.
       this.updatePlaylistTimer_.tickAfter(/* seconds= */ 0.1);
     }
+
+    // Detect a call to stop()
+    if (!this.playerInterface_) {
+      return;
+    }
+
+    this.playerInterface_.onManifestUpdated();
   }
 
 

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,
+};