shaka-player 3.2.0 → 3.2.4

package/lib/ads/client_side_ad_manager.js

@@ -13,10 +13,12 @@ goog.provide('shaka.ads.ClientSideAdManager');
 
 goog.require('goog.asserts');
 goog.require('shaka.ads.ClientSideAd');
+goog.require('shaka.util.IReleasable');
 
 
 /**
  * A class responsible for client-side ad interactions.
+ * @implements {shaka.util.IReleasable}
  */
 shaka.ads.ClientSideAdManager = class {
   /**
@@ -32,6 +34,9 @@ shaka.ads.ClientSideAdManager = class {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
+    /** @private {ResizeObserver} */
+    this.resizeObserver_ = null;
+
     /** @private {number} */
     this.requestAdsStartTime_ = NaN;
 
@@ -106,6 +111,21 @@ shaka.ads.ClientSideAdManager = class {
     }
   }
 
+  /** @override */
+  release() {
+    this.stop();
+    if (this.resizeObserver_) {
+      this.resizeObserver_.disconnect();
+    }
+    if (this.eventManager_) {
+      this.eventManager_.release();
+    }
+    if (this.imaAdsManager_) {
+      this.imaAdsManager_.destroy();
+    }
+    this.adsLoader_.destroy();
+  }
+
   /**
    * @param {!google.ima.AdErrorEvent} e
    * @private
@@ -118,7 +138,7 @@ shaka.ads.ClientSideAdManager = class {
     // Remove ad breaks from the timeline
     this.onEvent_(
         new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-            {'cuepoints': []}));
+            (new Map()).set('cuepoints', [])));
   }
 
 
@@ -131,30 +151,31 @@ shaka.ads.ClientSideAdManager = class {
 
     const now = Date.now() / 1000;
     const loadTime = now - this.requestAdsStartTime_;
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
-            {'loadTime': loadTime}));
+    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
+        (new Map()).set('loadTime', loadTime)));
 
     this.imaAdsManager_ = e.getAdsManager(this.video_);
 
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.IMA_AD_MANAGER_LOADED,
-        {
-          'imaAdManager': this.imaAdsManager_,
-        }));
+        (new Map()).set('imaAdManager', this.imaAdsManager_)));
 
     const cuePointStarts = this.imaAdsManager_.getCuePoints();
     if (cuePointStarts.length) {
-      /** @type {!Array.<!shaka.ads.CuePoint>} */
+      /** @type {!Array.<!shaka.extern.AdCuePoint>} */
       const cuePoints = [];
       for (const start of cuePointStarts) {
-        const shakaCuePoint = new shaka.ads.CuePoint(start);
+        /** @type {shaka.extern.AdCuePoint} */
+        const shakaCuePoint = {
+          start: start,
+          end: null,
+        };
         cuePoints.push(shakaCuePoint);
       }
 
-      this.onEvent_(
-          new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-              {'cuepoints': cuePoints}));
+      this.onEvent_(new shaka.util.FakeEvent(
+          shaka.ads.AdManager.CUEPOINTS_CHANGED,
+          (new Map()).set('cuepoints', cuePoints)));
     }
 
     this.addImaEventListeners_();
@@ -176,6 +197,16 @@ shaka.ads.ClientSideAdManager = class {
             this.video_.offsetHeight, viewMode);
       });
 
+      if ('ResizeObserver' in window) {
+        this.resizeObserver_ = new ResizeObserver(() => {
+          const viewMode = document.fullscreenElement ?
+              google.ima.ViewMode.FULLSCREEN : google.ima.ViewMode.NORMAL;
+          this.imaAdsManager_.resize(this.video_.offsetWidth,
+              this.video_.offsetHeight, viewMode);
+        });
+        this.resizeObserver_.observe(this.video_);
+      }
+
       // Single video and overlay ads will start at this time
       // TODO (ismena): Need a better inderstanding of what this does.
       // The docs say it's called to 'start playing the ads,' but I haven't
@@ -194,6 +225,15 @@ shaka.ads.ClientSideAdManager = class {
    * @private
    */
   addImaEventListeners_() {
+    /**
+     * @param {!Event} e
+     * @param {string} type
+     */
+    const convertEventAndSend = (e, type) => {
+      const data = (new Map()).set('originalEvent', e);
+      this.onEvent_(new shaka.util.FakeEvent(type, data));
+    };
+
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdErrorEvent.Type.AD_ERROR, (error) => {
           this.onAdError_(/** @type {!google.ima.AdErrorEvent} */ (error));
@@ -211,30 +251,22 @@ shaka.ads.ClientSideAdManager = class {
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.FIRST_QUARTILE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_FIRST_QUARTILE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_FIRST_QUARTILE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.MIDPOINT, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MIDPOINT,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_MIDPOINT);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.THIRD_QUARTILE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_THIRD_QUARTILE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_THIRD_QUARTILE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.COMPLETE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_COMPLETE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_COMPLETE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
@@ -249,140 +281,102 @@ shaka.ads.ClientSideAdManager = class {
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.SKIPPED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_SKIPPED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_SKIPPED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.VOLUME_CHANGED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_VOLUME_CHANGED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_VOLUME_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.VOLUME_MUTED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MUTED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_MUTED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.PAUSED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
           this.ad_.setPaused(true);
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_PAUSED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_PAUSED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.RESUMED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
           this.ad_.setPaused(false);
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_RESUMED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_RESUMED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.SKIPPABLE_STATE_CHANGED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_SKIP_STATE_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_SKIP_STATE_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.CLICK, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_CLICKED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_CLICKED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_PROGRESS, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_PROGRESS,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_PROGRESS);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_BUFFERING, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_BUFFERING,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_BUFFERING);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.IMPRESSION, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_IMPRESSION,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_IMPRESSION);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.DURATION_CHANGE, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_DURATION_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_DURATION_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.USER_CLOSE, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_CLOSED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_CLOSED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LOADED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_LOADED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_LOADED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.ALL_ADS_COMPLETED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.ALL_ADS_COMPLETED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.ALL_ADS_COMPLETED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LINEAR_CHANGED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_LINEAR_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_LINEAR_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_METADATA, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_METADATA,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_METADATA);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LOG, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_RECOVERABLE_ERROR,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_RECOVERABLE_ERROR);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_BREAK_READY, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_BREAK_READY,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_BREAK_READY);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.INTERACTION, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_INTERACTION,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_INTERACTION);
         });
   }
 
@@ -396,12 +390,12 @@ shaka.ads.ClientSideAdManager = class {
 
     const imaAd = e.getAd();
     this.ad_ = new shaka.ads.ClientSideAd(imaAd, this.imaAdsManager_);
-    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
-        {
-          'ad': this.ad_,
-          'sdkAdObject': imaAd,
-          'originalEvent': e,
-        }));
+    const data = new Map()
+        .set('ad', this.ad_)
+        .set('sdkAdObject', imaAd)
+        .set('originalEvent', e);
+    this.onEvent_(new shaka.util.FakeEvent(
+        shaka.ads.AdManager.AD_STARTED, data));
     this.adContainer_.setAttribute('ad-active', 'true');
     this.video_.pause();
   }
@@ -412,7 +406,7 @@ shaka.ads.ClientSideAdManager = class {
    */
   onAdComplete_(e) {
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED,
-        {'originalEvent': e}));
+        (new Map()).set('originalEvent', e)));
     this.adContainer_.removeAttribute('ad-active');
     this.video_.play();
   }

package/lib/ads/server_side_ad_manager.js

@@ -14,10 +14,12 @@ goog.provide('shaka.ads.ServerSideAdManager');
 goog.require('goog.asserts');
 goog.require('shaka.ads.ServerSideAd');
 goog.require('shaka.log');
+goog.require('shaka.util.IReleasable');
 
 
 /**
  * A class responsible for server-side ad interactions.
+ * @implements {shaka.util.IReleasable}
  */
 shaka.ads.ServerSideAdManager = class {
   /**
@@ -62,6 +64,9 @@ shaka.ads.ServerSideAdManager = class {
     /** @private {string} */
     this.backupUrl_ = '';
 
+    /** @private {!Array.<!shaka.extern.AdCuePoint>} */
+    this.currentCuePoints_ = [];
+
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
@@ -75,9 +80,7 @@ shaka.ads.ServerSideAdManager = class {
 
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.IMA_STREAM_MANAGER_LOADED,
-        {
-          'imaStreamManager': this.streamManager_,
-        }));
+        (new Map()).set('imaStreamManager', this.streamManager_)));
 
     // Events
     this.eventManager_.listen(this.streamManager_,
@@ -201,9 +204,26 @@ shaka.ads.ServerSideAdManager = class {
    * Resets the stream manager and removes any continuous polling.
    */
   stop() {
-    this.streamManager_.reset();
+    // TODO:
+    // For SS DAI streams, if a different asset gets unloaded as
+    // part of the process
+    // of loading a DAI asset, stream manager state gets reset and we
+    // don't get any ad events.
+    // We need to figure out if it makes sense to stop the SS
+    // manager on unload, and, if it does, find
+    // a way to do it safely.
+    // this.streamManager_.reset();
     this.backupUrl_ = '';
     this.snapForwardTime_ = null;
+    this.currentCuePoints_ = [];
+  }
+
+  /** @override */
+  release() {
+    this.stop();
+    if (this.eventManager_) {
+      this.eventManager_.release();
+    }
   }
 
   /**
@@ -233,6 +253,13 @@ shaka.ads.ServerSideAdManager = class {
     }
   }
 
+  /**
+   * @return {!Array.<!shaka.extern.AdCuePoint>}
+   */
+  getCuePoints() {
+    return this.currentCuePoints_;
+  }
+
   /**
    * If a seek jumped over the ad break, return to the start of the
    * ad break, then complete the seek after the ad played through.
@@ -280,7 +307,7 @@ shaka.ads.ServerSideAdManager = class {
     }
 
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
-        {'ad': this.ad_}));
+        (new Map()).set('ad', this.ad_)));
     this.adContainer_.setAttribute('ad-active', 'true');
   }
 
@@ -306,9 +333,8 @@ shaka.ads.ServerSideAdManager = class {
   onLoaded_(e) {
     const now = Date.now() / 1000;
     const loadTime = now - this.streamRequestStartTime_;
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
-            {'loadTime': loadTime}));
+    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
+        (new Map()).set('loadTime', loadTime)));
 
     const streamData = e.getStreamData();
     const url = streamData.url;
@@ -361,15 +387,21 @@ shaka.ads.ServerSideAdManager = class {
   onCuePointsChanged_(e) {
     const streamData = e.getStreamData();
 
-    /** @type {!Array.<!shaka.ads.CuePoint>} */
+    /** @type {!Array.<!shaka.extern.AdCuePoint>} */
     const cuePoints = [];
     for (const point of streamData.cuepoints) {
-      const shakaCuePoint = new shaka.ads.CuePoint(point.start, point.end);
+      /** @type {shaka.extern.AdCuePoint} */
+      const shakaCuePoint = {
+        start: point.start,
+        end: point.end,
+      };
       cuePoints.push(shakaCuePoint);
     }
 
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-            {'cuepoints': cuePoints}));
+    this.currentCuePoints_ = cuePoints;
+
+    this.onEvent_(new shaka.util.FakeEvent(
+        shaka.ads.AdManager.CUEPOINTS_CHANGED,
+        (new Map()).set('cuepoints', cuePoints)));
   }
 };

package/lib/cast/cast_proxy.js

@@ -120,6 +120,9 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
     this.videoProxy_ = null;
     this.playerProxy_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return Promise.all(waitFor);
   }
 
@@ -525,7 +528,8 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Wrong error type!');
       const eventType = shaka.Player.EventName.Error;
-      const event = new shaka.util.FakeEvent(eventType, {'detail': error});
+      const data = (new Map()).set('detail', error);
+      const event = new shaka.util.FakeEvent(eventType, data);
       this.localPlayer_.dispatchEvent(event);
     });
   }
@@ -598,7 +602,7 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
 
     // Convert this real Event into a FakeEvent for dispatch from our
     // FakeEventListener.
-    const fakeEvent = new shaka.util.FakeEvent(event.type, event);
+    const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
     this.videoEventTarget_.dispatchEvent(fakeEvent);
   }
 

package/lib/cast/cast_receiver.js

@@ -238,6 +238,9 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
     this.shakaBus_ = null;
     this.genericBus_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     await Promise.all(waitFor);
 
     const manager = cast.receiver.CastReceiverManager.getInstance();
@@ -407,7 +410,8 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
         goog.asserts.assert(error instanceof shaka.util.Error,
             'Wrong error type!');
         const eventType = shaka.Player.EventName.Error;
-        const event = new shaka.util.FakeEvent(eventType, {'detail': error});
+        const data = (new Map()).set('detail', error);
+        const event = new shaka.util.FakeEvent(eventType, data);
         // Only dispatch the event if the player still exists.
         if (this.player_) {
           this.player_.dispatchEvent(event);

package/lib/cast/cast_sender.js

@@ -647,7 +647,7 @@ shaka.cast.CastSender = class {
       case 'event': {
         const targetName = message['targetName'];
         const event = message['event'];
-        const fakeEvent = new shaka.util.FakeEvent(event['type'], event);
+        const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
         this.onRemoteEvent_(targetName, fakeEvent);
         break;
       }
@@ -725,7 +725,7 @@ shaka.cast.CastSender = class {
 
       // Dispatch it through the Player proxy
       const fakeEvent = new shaka.util.FakeEvent(
-          'error', {'detail': shakaError});
+          'error', (new Map()).set('detail', shakaError));
       this.onRemoteEvent_('player', fakeEvent);
 
       // Force this session to disconnect and transfer playback to the local

package/lib/cea/sei_processor.js

@@ -17,31 +17,31 @@ shaka.cea.SeiProcessor = class {
    * @return {!Iterable.<!Uint8Array>}
    */
   * process(naluData) {
-    const emuCount = this.removeEmu_(naluData);
+    const naluClone = this.removeEmu(naluData);
 
     // The following is an implementation of section 7.3.2.3.1
     // in Rec. ITU-T H.264 (06/2019), the H.264 spec.
     let offset = 0;
 
-    while (offset + emuCount < naluData.length) {
+    while (offset < naluClone.length) {
       let payloadType = 0; // SEI payload type as defined by H.264 spec
-      while (naluData[offset] == 0xFF) {
+      while (naluClone[offset] == 0xFF) {
         payloadType += 255;
         offset++;
       }
-      payloadType += naluData[offset++];
+      payloadType += naluClone[offset++];
 
       let payloadSize = 0; // SEI payload size as defined by H.264 spec
-      while (naluData[offset] == 0xFF) {
+      while (naluClone[offset] == 0xFF) {
         payloadSize += 255;
         offset++;
       }
-      payloadSize += naluData[offset++];
+      payloadSize += naluClone[offset++];
 
       // Payload type 4 is user_data_registered_itu_t_t35, as per the H.264
       // spec. This payload type contains caption data.
       if (payloadType == 0x04) {
-        yield naluData.subarray(offset, offset + payloadSize);
+        yield naluClone.subarray(offset, offset + payloadSize);
       }
       offset += payloadSize;
     }
@@ -50,28 +50,35 @@ shaka.cea.SeiProcessor = class {
 
   /**
    * Removes H.264 emulation prevention bytes from the byte array.
+   *
+   * Note: Remove bytes by shifting will cause Chromium (VDA) to complain
+   * about conformance. Recreating a new array solves it.
+   *
    * @param {!Uint8Array} naluData NALU from which EMUs should be removed.
-   * @return {number} The number of removed emulation prevention bytes.
-   * @private
+   * @return {!Uint8Array} The NALU with the emulation prevention byte removed.
    */
-  removeEmu_(naluData) {
+  removeEmu(naluData) {
+    let naluClone = naluData;
     let zeroCount = 0;
     let src = 0;
-    let dst = 0;
-    while (src < naluData.length) {
-      if (zeroCount == 2 && naluData[src] == 0x03) {
+    while (src < naluClone.length) {
+      if (zeroCount == 2 && naluClone[src] == 0x03) {
+        // 0x00, 0x00, 0x03 pattern detected
         zeroCount = 0;
+
+        // Splice the array and recreate a new one, instead of shifting bytes
+        const newArr = [...naluClone];
+        newArr.splice(src, 1);
+        naluClone = new Uint8Array(newArr);
       } else {
-        if (naluData[src] == 0x00) {
+        if (naluClone[src] == 0x00) {
           zeroCount++;
         } else {
           zeroCount = 0;
         }
-        naluData[dst] = naluData[src];
-        dst++;
       }
       src++;
     }
-    return (src - dst);
+    return naluClone;
   }
 };