shaka-player 4.4.3 → 4.6.0

package/lib/media/media_source_engine.js

@@ -8,6 +8,7 @@ goog.provide('shaka.media.MediaSourceEngine');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.config.CodecSwitchingStrategy');
 goog.require('shaka.media.Capabilities');
 goog.require('shaka.media.ContentWorkarounds');
 goog.require('shaka.media.ClosedCaptionParser');
@@ -31,7 +32,7 @@ goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PublicPromise');
 goog.require('shaka.util.TsParser');
-goog.require('shaka.lcevc.Dil');
+goog.require('shaka.lcevc.Dec');
 
 
 /**
@@ -53,10 +54,10 @@ shaka.media.MediaSourceEngine = class {
    *    MediaSourceEngine is destroyed, it will destroy the displayer.
    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
    *    onMetadata
-   * @param {?shaka.lcevc.Dil} [lcevcDil] Optional -  LCEVC Dil Object
+   * @param {?shaka.lcevc.Dec} [lcevcDec] Optional -  LCEVC Decoder Object
    *
    */
-  constructor(video, textDisplayer, onMetadata, lcevcDil) {
+  constructor(video, textDisplayer, onMetadata, lcevcDec) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
@@ -91,8 +92,8 @@ shaka.media.MediaSourceEngine = class {
                     number, ?number)} */
     this.onMetadata_ = onMetadata || onMetadataNoOp;
 
-    /** @private {?shaka.lcevc.Dil} */
-    this.lcevcDil_ = lcevcDil || null;
+    /** @private {?shaka.lcevc.Dec} */
+    this.lcevcDec_ = lcevcDec || null;
 
     /**
      * @private {!Object.<string,
@@ -115,7 +116,10 @@ shaka.media.MediaSourceEngine = class {
     /** @private {string} */
     this.url_ = '';
 
-    /** @private {MediaSource} */
+    /** @private {boolean} */
+    this.playbackHasBegun_ = false;
+
+    /** @private {(MediaSource|ManagedMediaSource)} */
     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
 
     /** @private {boolean} */
@@ -138,6 +142,12 @@ shaka.media.MediaSourceEngine = class {
 
     /** @private {!shaka.util.PublicPromise.<number>} */
     this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
+
+    /** @private {boolean} */
+    this.needSplitMuxedContent_ = false;
+
+    /** @private {boolean} */
+    this.streamingAllowed_ = true;
   }
 
   /**
@@ -147,25 +157,60 @@ shaka.media.MediaSourceEngine = class {
    * Replaced by unit tests.
    *
    * @param {!shaka.util.PublicPromise} p
-   * @return {!MediaSource}
+   * @return {!(MediaSource|ManagedMediaSource)}
    */
   createMediaSource(p) {
-    const mediaSource = new MediaSource();
+    if (window.ManagedMediaSource) {
+      this.video_.disableRemotePlayback = true;
+
+      const mediaSource = new ManagedMediaSource();
+
+      this.eventManager_.listenOnce(
+          mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
 
-    // Set up MediaSource on the video element.
-    this.eventManager_.listenOnce(
-        mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
+      this.eventManager_.listen(
+          mediaSource, 'startstreaming', () => {
+            this.streamingAllowed_ = true;
+          });
+
+      this.eventManager_.listen(
+          mediaSource, 'endstreaming', () => {
+            this.streamingAllowed_ = false;
+          });
+
+      // Correctly set when playback has begun.
+      this.eventManager_.listenOnce(this.video_, 'playing', () => {
+        this.playbackHasBegun_ = true;
+      });
+
+      this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
 
-    // Store the object URL for releasing it later.
-    this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
+      this.video_.src = this.url_;
+
+      return mediaSource;
+    } else {
+      const mediaSource = new MediaSource();
 
-    this.video_.src = this.url_;
+      // Set up MediaSource on the video element.
+      this.eventManager_.listenOnce(
+          mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
 
-    return mediaSource;
+      // Correctly set when playback has begun.
+      this.eventManager_.listenOnce(this.video_, 'playing', () => {
+        this.playbackHasBegun_ = true;
+      });
+
+      // Store the object URL for releasing it later.
+      this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
+
+      this.video_.src = this.url_;
+
+      return mediaSource;
+    }
   }
 
   /**
-   * @param {!shaka.util.PublicPromise} p
+   * @param {shaka.util.PublicPromise} p
    * @private
    */
   onSourceOpen_(p) {
@@ -217,9 +262,11 @@ shaka.media.MediaSourceEngine = class {
       'video/mp4; codecs="vp9"',
       'video/mp4; codecs="vp09.00.10.08"',
       'video/mp4; codecs="av01.0.01M.08"',
+      'video/mp4; codecs="dvh1.20.01"',
       'audio/mp4; codecs="mp4a.40.2"',
       'audio/mp4; codecs="ac-3"',
       'audio/mp4; codecs="ec-3"',
+      'audio/mp4; codecs="ac-4"',
       'audio/mp4; codecs="opus"',
       'audio/mp4; codecs="flac"',
       'audio/mp4; codecs="dtsc"', // DTS Digital Surround
@@ -341,7 +388,7 @@ shaka.media.MediaSourceEngine = class {
     this.queues_ = {};
 
     // This object is owned by Player
-    this.lcevcDil_ = null;
+    this.lcevcDec_ = null;
   }
 
   /**
@@ -379,6 +426,8 @@ shaka.media.MediaSourceEngine = class {
   async init(streamsByType, sequenceMode=false,
       manifestType=shaka.media.ManifestParser.UNKNOWN,
       ignoreManifestTimestampsInSegmentsMode=false) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
     await this.mediaSourceOpen_;
 
     this.sequenceMode_ = sequenceMode;
@@ -392,8 +441,13 @@ shaka.media.MediaSourceEngine = class {
 
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
-      this.initSourceBuffer_(contentType, stream);
-      this.queues_[contentType] = [];
+      this.initSourceBuffer_(contentType, stream, stream.codecs);
+      if (this.needSplitMuxedContent_) {
+        this.queues_[ContentType.AUDIO] = [];
+        this.queues_[ContentType.VIDEO] = [];
+      } else {
+        this.queues_[contentType] = [];
+      }
     }
   }
 
@@ -402,9 +456,10 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} codecs
    * @private
    */
-  initSourceBuffer_(contentType, stream) {
+  initSourceBuffer_(contentType, stream, codecs) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(
@@ -412,7 +467,7 @@ shaka.media.MediaSourceEngine = class {
         'Type negotiation should happen before MediaSourceEngine.init!');
 
     let mimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
+        stream.mimeType, codecs);
     if (contentType == ContentType.TEXT) {
       this.reinitText(mimeType, this.sequenceMode_, stream.external);
     } else {
@@ -424,9 +479,19 @@ shaka.media.MediaSourceEngine = class {
       }
       const mimeTypeWithAllCodecs =
           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-              stream.mimeType, stream.codecs);
+              stream.mimeType, codecs);
       const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
       if (needTransmux) {
+        const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+            ContentType.AUDIO, (codecs || '').split(','));
+        const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+            ContentType.VIDEO, (codecs || '').split(','));
+        if (audioCodec && videoCodec) {
+          this.needSplitMuxedContent_ = true;
+          this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
+          this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
+          return;
+        }
         const transmuxerPlugin =
             TransmuxerEngine.findTransmuxer(mimeTypeWithAllCodecs);
         if (transmuxerPlugin) {
@@ -450,8 +515,8 @@ shaka.media.MediaSourceEngine = class {
             shaka.util.Error.Category.MEDIA,
             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
             exception,
-            'The mediaSource_ status was' + this.mediaSource_.readyState +
-            'expected \'open\'');
+            'The mediaSource_ status was ' + this.mediaSource_.readyState +
+            ' expected \'open\'');
       }
 
       if (this.sequenceMode_) {
@@ -481,6 +546,16 @@ shaka.media.MediaSourceEngine = class {
     this.config_ = config;
   }
 
+  /**
+   * Indicate if the streaming is allowed by MediaSourceEngine.
+   * If we using MediaSource we allways returns true.
+   *
+   * @return {boolean}
+   */
+  isStreamingAllowed() {
+    return this.streamingAllowed_;
+  }
+
   /**
    * Reinitialize the TextEngine for a new text type.
    * @param {string} mimeType
@@ -513,7 +588,8 @@ shaka.media.MediaSourceEngine = class {
    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
    */
   bufferStart(contentType) {
-    if (this.reloadingMediaSource_) {
+    if (this.reloadingMediaSource_ ||
+          !Object.keys(this.sourceBuffers_).length) {
       return null;
     }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
@@ -708,7 +784,7 @@ shaka.media.MediaSourceEngine = class {
     } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
         shaka.util.TsParser.probe(uint8ArrayData)) {
       const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
-      const startTime = tsParser.getStartTime()[contentType];
+      const startTime = tsParser.getStartTime(contentType);
       if (startTime != null) {
         timestamp = startTime;
       }
@@ -743,7 +819,7 @@ shaka.media.MediaSourceEngine = class {
    */
   async appendBuffer(
       contentType, data, reference, stream, hasClosedCaptions, seeked = false,
-      adaptation = false, isChunkedData = false) {
+      adaptation = false, isChunkedData = false, fromSplit = false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
@@ -755,7 +831,23 @@ shaka.media.MediaSourceEngine = class {
       await this.textEngine_.appendBuffer(
           data,
           reference ? reference.startTime : null,
-          reference ? reference.endTime : null);
+          reference ? reference.endTime : null,
+          reference ? reference.getUris()[0] : null);
+      return;
+    }
+
+    if (!fromSplit && this.needSplitMuxedContent_) {
+      await this.appendBuffer(ContentType.AUDIO, data, reference, stream,
+          hasClosedCaptions, seeked, adaptation, isChunkedData,
+          /* fromSplit= */ true);
+      await this.appendBuffer(ContentType.VIDEO, data, reference, stream,
+          hasClosedCaptions, seeked, adaptation, isChunkedData,
+          /* fromSplit= */ true);
+      return;
+    }
+
+    if (!this.sourceBuffers_[contentType]) {
+      shaka.log.warning('Attempted to restore a non-existent source buffer');
       return;
     }
 
@@ -763,7 +855,7 @@ shaka.media.MediaSourceEngine = class {
 
     let mimeType = this.sourceBufferTypes_[contentType];
     if (this.transmuxers_[contentType]) {
-      mimeType = this.transmuxers_[contentType].getOrginalMimeType();
+      mimeType = this.transmuxers_[contentType].getOriginalMimeType();
     }
     if (reference) {
       const timestamp = this.getTimestampAndDispatchMetadata_(
@@ -772,7 +864,9 @@ shaka.media.MediaSourceEngine = class {
         const calculatedTimestampOffset = reference.startTime - timestamp;
         const timestampOffsetDifference =
             Math.abs(timestampOffset - calculatedTimestampOffset);
-        if (timestampOffsetDifference >= 0.1 || seeked || adaptation) {
+        if ((timestampOffsetDifference >= 0.1 || seeked || adaptation) &&
+            (!isChunkedData || calculatedTimestampOffset > 0 ||
+            !timestampOffset)) {
           timestampOffset = calculatedTimestampOffset;
           if (this.attemptTimestampOffsetCalculation_) {
             this.enqueueOperation_(
@@ -850,7 +944,7 @@ shaka.media.MediaSourceEngine = class {
       if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
         bufferedBefore = this.getBuffered_(contentType);
       }
-      this.append_(contentType, data);
+      this.append_(contentType, data, timestampOffset);
     });
 
     if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
@@ -910,6 +1004,11 @@ shaka.media.MediaSourceEngine = class {
       await this.enqueueOperation_(
           contentType,
           () => this.remove_(contentType, startTime, endTime));
+      if (this.needSplitMuxedContent_) {
+        await this.enqueueOperation_(
+            ContentType.AUDIO,
+            () => this.remove_(ContentType.AUDIO, startTime, endTime));
+      }
     }
   }
 
@@ -931,6 +1030,12 @@ shaka.media.MediaSourceEngine = class {
       await this.enqueueOperation_(
           contentType,
           () => this.remove_(contentType, 0, this.mediaSource_.duration));
+      if (this.needSplitMuxedContent_) {
+        await this.enqueueOperation_(
+            ContentType.AUDIO,
+            () => this.remove_(
+                ContentType.AUDIO, 0, this.mediaSource_.duration));
+      }
     }
   }
 
@@ -961,6 +1066,11 @@ shaka.media.MediaSourceEngine = class {
     await this.enqueueOperation_(
         contentType,
         () => this.flush_(contentType));
+    if (this.needSplitMuxedContent_) {
+      await this.enqueueOperation_(
+          ContentType.AUDIO,
+          () => this.flush_(ContentType.AUDIO));
+    }
   }
 
   /**
@@ -1014,16 +1124,33 @@ shaka.media.MediaSourceEngine = class {
       operations.push(this.enqueueOperation_(
           contentType,
           () => this.abort_(contentType)));
+      if (this.needSplitMuxedContent_) {
+        operations.push(this.enqueueOperation_(
+            ContentType.AUDIO,
+            () => this.abort_(ContentType.AUDIO)));
+      }
     }
     if (!ignoreTimestampOffset) {
       operations.push(this.enqueueOperation_(
           contentType,
           () => this.setTimestampOffset_(contentType, timestampOffset)));
+      if (this.needSplitMuxedContent_) {
+        operations.push(this.enqueueOperation_(
+            ContentType.AUDIO,
+            () => this.setTimestampOffset_(
+                ContentType.AUDIO, timestampOffset)));
+      }
     }
     operations.push(this.enqueueOperation_(
         contentType,
         () => this.setAppendWindow_(
             contentType, appendWindowStart, appendWindowEnd)));
+    if (this.needSplitMuxedContent_) {
+      operations.push(this.enqueueOperation_(
+          ContentType.AUDIO,
+          () => this.setAppendWindow_(
+              ContentType.AUDIO, appendWindowStart, appendWindowEnd)));
+    }
 
     await Promise.all(operations);
   }
@@ -1054,9 +1181,19 @@ shaka.media.MediaSourceEngine = class {
     this.enqueueOperation_(
         contentType,
         () => this.abort_(contentType));
+    if (this.needSplitMuxedContent_) {
+      this.enqueueOperation_(
+          ContentType.AUDIO,
+          () => this.abort_(ContentType.AUDIO));
+    }
     await this.enqueueOperation_(
         contentType,
         () => this.setTimestampOffset_(contentType, timestampOffset));
+    if (this.needSplitMuxedContent_) {
+      await this.enqueueOperation_(
+          ContentType.AUDIO,
+          () => this.setTimestampOffset_(ContentType.AUDIO, timestampOffset));
+    }
   }
 
   /**
@@ -1120,16 +1257,17 @@ shaka.media.MediaSourceEngine = class {
    * Append data to the SourceBuffer.
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {BufferSource} data
+   * @param {number} timestampOffset
    * @private
    */
-  append_(contentType, data) {
+  append_(contentType, data, timestampOffset) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    // Append only video data to the LCEVC Dil.
-    if (contentType == ContentType.VIDEO && this.lcevcDil_) {
-      // Append video buffers to the LCEVC Dil for parsing and storing
+    // Append only video data to the LCEVC Dec.
+    if (contentType == ContentType.VIDEO && this.lcevcDec_) {
+      // Append video buffers to the LCEVC Dec for parsing and storing
       // of LCEVC data.
-      this.lcevcDil_.appendBuffer(data);
+      this.lcevcDec_.appendBuffer(data, timestampOffset);
     }
 
     // This will trigger an 'updateend' event.
@@ -1292,7 +1430,6 @@ shaka.media.MediaSourceEngine = class {
    */
   enqueueOperation_(contentType, start) {
     this.destroyer_.ensureNotDestroyed();
-
     const operation = {
       start: start,
       p: new shaka.util.PublicPromise(),
@@ -1563,8 +1700,24 @@ shaka.media.MediaSourceEngine = class {
    */
   async reset_(streamsByType) {
     const Functional = shaka.util.Functional;
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
     this.reloadingMediaSource_ = true;
+    this.needSplitMuxedContent_ = false;
     const currentTime = this.video_.currentTime;
+
+    // When codec switching if the user is currently paused we don't want
+    // to trigger a play when switching codec.
+    // Playing can also end up in a paused state after a codec switch
+    // so we need to remember the current states.
+    const previousAutoPlayState = this.video_.autoplay;
+    const previousPausedState = this.video_.paused;
+    if (this.playbackHasBegun_) {
+      // Only set autoplay to false if the video playback has already begun.
+      // When a codec switch happens before playback has begun this can cause
+      // autoplay not to work as expected.
+      this.video_.autoplay = false;
+    }
+
     try {
       this.eventManager_.removeAll();
 
@@ -1598,7 +1751,6 @@ shaka.media.MediaSourceEngine = class {
       }
       await Promise.all(cleanup);
       this.transmuxers_ = {};
-      this.queues_ = {};
       this.sourceBuffers_ = {};
 
       const previousDuration = this.mediaSource_.duration;
@@ -1622,7 +1774,13 @@ shaka.media.MediaSourceEngine = class {
 
       for (const contentType of streamsByType.keys()) {
         const stream = streamsByType.get(contentType);
-        this.initSourceBuffer_(contentType, stream);
+        this.initSourceBuffer_(contentType, stream, stream.codecs);
+        if (this.needSplitMuxedContent_) {
+          this.queues_[ContentType.AUDIO] = [];
+          this.queues_[ContentType.VIDEO] = [];
+        } else {
+          this.queues_[contentType] = [];
+        }
       }
 
       // Fake a seek to catchup the playhead.
@@ -1631,6 +1789,17 @@ shaka.media.MediaSourceEngine = class {
       await sourceBufferAdded;
     } finally {
       this.reloadingMediaSource_ = false;
+
+      this.destroyer_.ensureNotDestroyed();
+
+      this.eventManager_.listenOnce(this.video_, 'canplay', () => {
+        this.destroyer_.ensureNotDestroyed();
+
+        this.video_.autoplay = previousAutoPlayState;
+        if (!previousPausedState) {
+          this.video_.play();
+        }
+      });
     }
   }
 
@@ -1657,6 +1826,9 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   async codecSwitchIfNecessary_(contentType, stream, streamsByType) {
+    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      return false;
+    }
     const MimeUtils = shaka.util.MimeUtils;
     const currentCodec = MimeUtils.getCodecBase(
         MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
@@ -1696,7 +1868,10 @@ shaka.media.MediaSourceEngine = class {
       return false;
     }
 
-    if (shaka.media.Capabilities.isChangeTypeSupported()) {
+    if (this.config_.codecSwitchingStrategy ===
+        shaka.config.CodecSwitchingStrategy.SMOOTH &&
+          shaka.media.Capabilities.isChangeTypeSupported() &&
+            !this.needSplitMuxedContent_) {
       await this.changeType(contentType, newMimeType, transmuxer);
     } else {
       if (transmuxer) {
@@ -1708,11 +1883,78 @@ shaka.media.MediaSourceEngine = class {
   }
 
   /**
-   * Update LCEVC DIL object when ready for LCEVC Decodes
-   * @param {?shaka.lcevc.Dil} lcevcDil
+   * Returns true if it's necessary codec switch to load the new stream.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {shaka.extern.Stream} stream
+   * @return {boolean}
+   * @private
+   */
+  isCodecSwitchNecessary_(contentType, stream) {
+    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      return false;
+    }
+    const MimeUtils = shaka.util.MimeUtils;
+    const currentCodec = MimeUtils.getCodecBase(
+        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
+    const currentBasicType = MimeUtils.getBasicType(
+        this.sourceBufferTypes_[contentType]);
+
+    let newMimeType = shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs);
+    let needTransmux = this.config_.forceTransmux;
+    if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
+        (!this.sequenceMode_ &&
+        shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
+      needTransmux = true;
+    }
+    const newMimeTypeWithAllCodecs =
+        shaka.util.MimeUtils.getFullTypeWithAllCodecs(
+            stream.mimeType, stream.codecs);
+    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
+    if (needTransmux) {
+      const transmuxerPlugin =
+          TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
+      if (transmuxerPlugin) {
+        const transmuxer = transmuxerPlugin();
+        newMimeType =
+            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+        transmuxer.destroy();
+      }
+    }
+
+    const newCodec = MimeUtils.getCodecBase(
+        MimeUtils.getCodecs(newMimeType));
+    const newBasicType = MimeUtils.getBasicType(newMimeType);
+
+    return currentCodec !== newCodec || currentBasicType !== newBasicType;
+  }
+
+  /**
+   * Returns true if it's necessary reset the media source to load the
+   * new stream.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {shaka.extern.Stream} stream
+   * @return {boolean}
+   */
+  isResetMediaSourceNecessary(contentType, stream) {
+    if (!this.isCodecSwitchNecessary_(contentType, stream)) {
+      return false;
+    }
+
+    return this.config_.codecSwitchingStrategy !==
+        shaka.config.CodecSwitchingStrategy.SMOOTH ||
+        !shaka.media.Capabilities.isChangeTypeSupported() ||
+        this.needSplitMuxedContent_;
+  }
+
+  /**
+   * Update LCEVC Decoder object when ready for LCEVC Decode.
+   * @param {?shaka.lcevc.Dec} lcevcDec
    */
-  updateLcevcDil(lcevcDil) {
-    this.lcevcDil_ = lcevcDil;
+  updateLcevcDec(lcevcDec) {
+    this.lcevcDec_ = lcevcDec;
   }
 };