rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/mse/main_media_source_interface.ts

@@ -85,7 +85,7 @@ export default class MainMediaSourceInterface
     super();
     this.id = id;
     this.sourceBuffers = [];
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("MainMediaSourceInterface");
 
     if (isNullOrUndefined(MediaSource_)) {
       throw new MediaError(
@@ -160,14 +160,16 @@ export default class MainMediaSourceInterface
   }
 
   /** @see IMediaSourceInterface */
-  public interruptDurationSetting() {
-    this._durationUpdater.stopUpdating();
+  public interruptDurationSetting(reason: string | undefined) {
+    this._durationUpdater.stopUpdating(reason);
   }
 
   /** @see IMediaSourceInterface */
   public maintainEndOfStream() {
     if (this._endOfStreamCanceller === null) {
-      this._endOfStreamCanceller = new TaskCanceller();
+      this._endOfStreamCanceller = new TaskCanceller(
+        "MainMediaSourceInterface EndOfStream",
+      );
       this._endOfStreamCanceller.linkToSignal(this._canceller.signal);
       log.debug("mse", "end-of-stream order received.");
       maintainEndOfStream(this._mediaSource, this._endOfStreamCanceller.signal);
@@ -178,15 +180,15 @@ export default class MainMediaSourceInterface
   public stopEndOfStream() {
     if (this._endOfStreamCanceller !== null) {
       log.debug("mse", "resume-stream order received.");
-      this._endOfStreamCanceller.cancel();
+      this._endOfStreamCanceller.cancel("MediaSourceInterface stopEndOfStream");
       this._endOfStreamCanceller = null;
     }
   }
 
   /** @see IMediaSourceInterface */
-  public dispose() {
-    this.sourceBuffers.forEach((s) => s.dispose());
-    this._canceller.cancel();
+  public dispose(reason: string | undefined) {
+    this.sourceBuffers.forEach((s) => s.dispose(reason));
+    this._canceller.cancel(reason ?? "MainMediaSourceInterface dispose");
     resetMediaSource(this._mediaSource);
   }
 }
@@ -231,7 +233,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
   constructor(sbType: SourceBufferType, codec: string, sourceBuffer: ISourceBuffer) {
     this.type = sbType;
     this.codec = codec;
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("MainSourceBufferInterface " + sbType);
     this._sourceBuffer = sourceBuffer;
     this._operationQueue = [];
     this._currentOperations = [];
@@ -290,7 +292,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
   }
 
   /** @see ISourceBufferInterface */
-  public abort(): void {
+  public abort(reason: string | undefined): void {
     try {
       this._sourceBuffer.abort();
     } catch (err) {
@@ -300,17 +302,17 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
         err instanceof Error ? err : "Unknown Error",
       );
     }
-    this._emptyCurrentQueue();
+    this._emptyCurrentQueue(reason);
   }
 
   /** @see ISourceBufferInterface */
-  public dispose(): void {
+  public dispose(reason: string | undefined): void {
     try {
       this._sourceBuffer.abort();
     } catch (_) {
       // we don't care
     }
-    this._emptyCurrentQueue();
+    this._emptyCurrentQueue(reason);
   }
 
   private _onError(evt: Event) {
@@ -360,8 +362,16 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
     this._performNextOperation();
   }
 
-  private _emptyCurrentQueue(): void {
-    const error = new CancellationError();
+  /**
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * action. Used for debugging matters, especially for debug log
+   * inspection.
+   */
+  private _emptyCurrentQueue(reason: string | undefined): void {
+    const error = new CancellationError(
+      "MainSourceBufferInterface queue " + this.type,
+      reason,
+    );
     if (this._currentOperations.length > 0) {
       this._currentOperations.forEach((op) => {
         op.reject(error);
@@ -552,12 +562,17 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
     const sourceBuffer = this._sourceBuffer;
     const { codec, timestampOffset, appendWindow = [] } = params;
     if (codec !== undefined && codec !== this.codec) {
-      log.debug("mse", "updating codec", { prevCodec: this.codec, newCodec: codec });
+      log.debug("mse", "updating codec", {
+        type: this.type,
+        prevCodec: this.codec,
+        newCodec: codec,
+      });
       const hasUpdatedSourceBufferType = tryToChangeSourceBufferType(sourceBuffer, codec);
       if (hasUpdatedSourceBufferType) {
         this.codec = codec;
       } else {
         log.debug("mse", "could not update codec", {
+          type: this.type,
           prevCodec: this.codec,
           newCodec: codec,
         });
@@ -570,6 +585,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
     ) {
       const newTimestampOffset = timestampOffset;
       log.debug("mse", "updating timestampOffset", {
+        type: this.type,
         codec,
         prevTimestampOffset: sourceBuffer.timestampOffset,
         newTimestampOffset,
@@ -580,6 +596,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
     if (appendWindow[0] === undefined) {
       if (sourceBuffer.appendWindowStart > 0) {
         log.debug("mse", "re-setting `appendWindowStart`", {
+          type: this.type,
           prevWindowStart: sourceBuffer.appendWindowStart,
         });
         sourceBuffer.appendWindowStart = 0;
@@ -588,12 +605,14 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
       if (appendWindow[0] >= sourceBuffer.appendWindowEnd) {
         const newWindowEnd = appendWindow[0] + 1;
         log.debug("mse", "pre-updating `appendWindowEnd`", {
+          type: this.type,
           prevWindowEnd: sourceBuffer.appendWindowEnd,
           newWindowEnd,
         });
         sourceBuffer.appendWindowEnd = newWindowEnd;
       }
       log.debug("mse", "setting `appendWindowStart`", {
+        type: this.type,
         appendWindowStart: appendWindow[0],
       });
       sourceBuffer.appendWindowStart = appendWindow[0];
@@ -602,12 +621,14 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
     if (appendWindow[1] === undefined) {
       if (sourceBuffer.appendWindowEnd !== Infinity) {
         log.debug("mse", "re-setting `appendWindowEnd`", {
+          type: this.type,
           prevWindowStart: sourceBuffer.appendWindowStart,
         });
         sourceBuffer.appendWindowEnd = Infinity;
       }
     } else if (appendWindow[1] !== sourceBuffer.appendWindowEnd) {
       log.debug("mse", "setting `appendWindowEnd`", {
+        type: this.type,
         prevWindowEnd: sourceBuffer.appendWindowEnd,
         newWindowEnd: appendWindow[1],
       });

package/src/mse/types.ts

@@ -89,16 +89,24 @@ export interface ISourceBufferInterface {
    * @returns {Promise.<Array.<Object>>}
    */
   remove(start: number, end: number): Promise<IRange[]>;
-  /** Abort all operations pending on the `SourceBuffer`. */
-  abort(): void;
+  /**
+   * Abort all operations pending on the `SourceBuffer`.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * abort. Used for debugging matters, especially for debug log
+   * inspection.
+   */
+  abort(reason: string | undefined): void;
   /**
    * Abort all operations pending on the `SourceBuffer` AND free up all
    * resources taken by the `ISourceBufferInterface`.
    *
    * The `ISourceBufferInterface` implementation might not be usable after
    * this call, it should mostly be called for clean-up.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  dispose(): void;
+  dispose(reason: string | undefined): void;
   /**
    * Returns the current range of buffered data, or `undefined` if this is not
    * obtainable synchronously.
@@ -247,8 +255,11 @@ export interface IMediaSourceInterface extends EventEmitter<IMediaSourceInterfac
   /**
    * Interrupt a duration update background task previously started through
    * a `setDuration` call.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * interrupt. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  interruptDurationSetting(): void;
+  interruptDurationSetting(reason: string | undefined): void;
 
   /**
    * Signal to the `IMediaSourceInterface` that all media segments until the
@@ -272,8 +283,11 @@ export interface IMediaSourceInterface extends EventEmitter<IMediaSourceInterfac
   /**
    * Free all resources taken by the `IMediaSourceInterface`, including all its
    * inner `ISourceBufferInterface` objects.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  dispose(): void;
+  dispose(reason: string | undefined): void;
 
   /**
    * Only set for `IMediaSourceInterface` objects which cannot rely on

package/src/mse/utils/end_of_stream.ts

@@ -82,13 +82,13 @@ export default function triggerEndOfStream(
 
   log.debug("mse", "Waiting SourceBuffers to be updated before calling endOfStream.");
 
-  const innerCanceller = new TaskCanceller();
+  const innerCanceller = new TaskCanceller("EndOfStream current iteration");
   innerCanceller.linkToSignal(cancelSignal);
   for (const sourceBuffer of updatingSourceBuffers) {
     onSourceBufferUpdate(
       sourceBuffer,
       () => {
-        innerCanceller.cancel();
+        innerCanceller.cancel("SourceBuffer update");
         triggerEndOfStream(mediaSource, cancelSignal);
       },
       innerCanceller.signal,
@@ -98,7 +98,7 @@ export default function triggerEndOfStream(
   onRemoveSourceBuffers(
     sourceBuffers,
     () => {
-      innerCanceller.cancel();
+      innerCanceller.cancel("SourceBuffer remove");
       triggerEndOfStream(mediaSource, cancelSignal);
     },
     innerCanceller.signal,
@@ -115,14 +115,14 @@ export function maintainEndOfStream(
   mediaSource: IMediaSource,
   cancelSignal: CancellationSignal,
 ): void {
-  let endOfStreamCanceller = new TaskCanceller();
+  let endOfStreamCanceller = new TaskCanceller("EndOfStream");
   endOfStreamCanceller.linkToSignal(cancelSignal);
   onSourceOpen(
     mediaSource,
     () => {
       log.debug("mse", "MediaSource re-opened while end-of-stream is active");
-      endOfStreamCanceller.cancel();
-      endOfStreamCanceller = new TaskCanceller();
+      endOfStreamCanceller.cancel("MediaSource re-opened");
+      endOfStreamCanceller = new TaskCanceller("EndOfStream");
       endOfStreamCanceller.linkToSignal(cancelSignal);
       triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
     },

package/src/mse/utils/media_source_duration_updater.ts

@@ -74,9 +74,11 @@ export default class MediaSourceDurationUpdater {
    */
   public updateDuration(newDuration: number, isRealEndKnown: boolean): void {
     if (this._currentMediaSourceDurationUpdateCanceller !== null) {
-      this._currentMediaSourceDurationUpdateCanceller.cancel();
+      this._currentMediaSourceDurationUpdateCanceller.cancel("manual duration update");
     }
-    this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
+    this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller(
+      "MediaSource Duration Update",
+    );
 
     const mediaSource = this._mediaSource;
     const currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
@@ -86,7 +88,9 @@ export default class MediaSourceDurationUpdater {
     );
 
     /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
-    let msOpenStatusCanceller = new TaskCanceller();
+    let msOpenStatusCanceller = new TaskCanceller(
+      undefined /* we do not care for logs here */,
+    );
     msOpenStatusCanceller.linkToSignal(currentSignal);
     isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, {
       emitCurrentValue: true,
@@ -94,24 +98,26 @@ export default class MediaSourceDurationUpdater {
     });
 
     function onMediaSourceOpenedStatusChanged() {
-      msOpenStatusCanceller.cancel();
+      msOpenStatusCanceller.cancel("MediaSource open status changed");
       if (!isMediaSourceOpened.getValue()) {
         return;
       }
-      msOpenStatusCanceller = new TaskCanceller();
+      msOpenStatusCanceller = new TaskCanceller(
+        undefined /* we do not care for logs here */,
+      );
       msOpenStatusCanceller.linkToSignal(currentSignal);
       const areSourceBuffersUpdating = createSourceBuffersUpdatingReference(
         mediaSource.sourceBuffers,
         msOpenStatusCanceller.signal,
       );
       /** TaskCanceller triggered each time SourceBuffers' updating status changes */
-      let sourceBuffersUpdatingCanceller = new TaskCanceller();
+      let sourceBuffersUpdatingCanceller = new TaskCanceller(undefined);
       sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
 
       return areSourceBuffersUpdating.onUpdate(
         (areUpdating) => {
-          sourceBuffersUpdatingCanceller.cancel();
-          sourceBuffersUpdatingCanceller = new TaskCanceller();
+          sourceBuffersUpdatingCanceller.cancel("SourceBuffer status update");
+          sourceBuffersUpdatingCanceller = new TaskCanceller(undefined);
           sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
           if (areUpdating) {
             return;
@@ -131,10 +137,13 @@ export default class MediaSourceDurationUpdater {
 
   /**
    * Abort the last duration-setting operation and free its resources.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * stop. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public stopUpdating() {
+  public stopUpdating(reason: string | undefined) {
     if (this._currentMediaSourceDurationUpdateCanceller !== null) {
-      this._currentMediaSourceDurationUpdateCanceller.cancel();
+      this._currentMediaSourceDurationUpdateCanceller.cancel(reason ?? "stop MSDU");
       this._currentMediaSourceDurationUpdateCanceller = null;
     }
   }

package/src/mse/worker_media_source_interface.ts

@@ -1,19 +1,19 @@
+import type {
+  IAbortBufferCoreMessage,
+  IAddSourceBufferCoreMessage,
+  IAppendBufferCoreMessage,
+  ICreateMediaSourceCoreMessage,
+  IDisposeMediaSourceCoreMessage,
+  IEndOfStreamCoreMessage,
+  IInterruptMediaSourceDurationCoreMessage,
+  IRemoveBufferCoreMessage,
+  IStopEndOfStreamCoreMessage,
+  IUpdateMediaSourceDurationCoreMessage,
+} from "../core/types";
+import { CoreMessageType } from "../core/types";
 import { SourceBufferError } from "../errors";
 import type { ISerializedSourceBufferError } from "../errors/source_buffer_error";
 import log from "../log";
-import type {
-  IAbortBufferWorkerMessage,
-  IAddSourceBufferWorkerMessage,
-  IAppendBufferWorkerMessage,
-  ICreateMediaSourceWorkerMessage,
-  IDisposeMediaSourceWorkerMessage,
-  IEndOfStreamWorkerMessage,
-  IInterruptMediaSourceDurationWorkerMessage,
-  IRemoveBufferWorkerMessage,
-  IStopEndOfStreamWorkerMessage,
-  IUpdateMediaSourceDurationWorkerMessage,
-} from "../multithread_types";
-import { WorkerMessageType } from "../multithread_types";
 import EventEmitter from "../utils/event_emitter";
 import idGenerator from "../utils/id_generator";
 import type { IRange } from "../utils/ranges";
@@ -67,13 +67,13 @@ export default class WorkerMediaSourceInterface
     super();
     this.id = id;
     this.sourceBuffers = [];
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("WorkerMediaSourceInterface");
     this.readyState = "closed";
     this._messageSender = messageSender;
 
     const mediaSourceId = generateMediaSourceId();
     this._messageSender({
-      type: WorkerMessageType.CreateMediaSource,
+      type: CoreMessageType.CreateMediaSource,
       contentId,
       mediaSourceId,
     });
@@ -101,7 +101,7 @@ export default class WorkerMediaSourceInterface
     codec: string,
   ): ISourceBufferInterface {
     this._messageSender({
-      type: WorkerMessageType.AddSourceBuffer,
+      type: CoreMessageType.AddSourceBuffer,
       mediaSourceId: this.id,
       value: {
         sourceBufferType: sbType,
@@ -120,7 +120,7 @@ export default class WorkerMediaSourceInterface
 
   public setDuration(newDuration: number, isRealEndKnown: boolean) {
     this._messageSender({
-      type: WorkerMessageType.UpdateMediaSourceDuration,
+      type: CoreMessageType.UpdateMediaSourceDuration,
       mediaSourceId: this.id,
       value: {
         duration: newDuration,
@@ -131,7 +131,7 @@ export default class WorkerMediaSourceInterface
 
   public interruptDurationSetting() {
     this._messageSender({
-      type: WorkerMessageType.InterruptMediaSourceDurationUpdate,
+      type: CoreMessageType.InterruptMediaSourceDurationUpdate,
       mediaSourceId: this.id,
       value: null,
     });
@@ -139,7 +139,7 @@ export default class WorkerMediaSourceInterface
 
   public maintainEndOfStream() {
     this._messageSender({
-      type: WorkerMessageType.EndOfStream,
+      type: CoreMessageType.EndOfStream,
       mediaSourceId: this.id,
       value: null,
     });
@@ -147,17 +147,22 @@ export default class WorkerMediaSourceInterface
 
   public stopEndOfStream() {
     this._messageSender({
-      type: WorkerMessageType.InterruptEndOfStream,
+      type: CoreMessageType.InterruptEndOfStream,
       mediaSourceId: this.id,
       value: null,
     });
   }
 
-  public dispose() {
-    this.sourceBuffers.forEach((s) => s.dispose());
-    this._canceller.cancel();
+  /**
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
+   */
+  public dispose(reason: string | undefined) {
+    this.sourceBuffers.forEach((s) => s.dispose(reason));
+    this._canceller.cancel("WorkerMediaSourceInterface dispose");
     this._messageSender({
-      type: WorkerMessageType.DisposeMediaSource,
+      type: CoreMessageType.DisposeMediaSource,
       mediaSourceId: this.id,
       value: null,
     });
@@ -166,16 +171,16 @@ export default class WorkerMediaSourceInterface
 
 export type IWorkerMediaSourceInterfaceMessageSender = (
   msg:
-    | IAppendBufferWorkerMessage
-    | IRemoveBufferWorkerMessage
-    | IAbortBufferWorkerMessage
-    | ICreateMediaSourceWorkerMessage
-    | IAddSourceBufferWorkerMessage
-    | IUpdateMediaSourceDurationWorkerMessage
-    | IInterruptMediaSourceDurationWorkerMessage
-    | IEndOfStreamWorkerMessage
-    | IStopEndOfStreamWorkerMessage
-    | IDisposeMediaSourceWorkerMessage,
+    | IAppendBufferCoreMessage
+    | IRemoveBufferCoreMessage
+    | IAbortBufferCoreMessage
+    | ICreateMediaSourceCoreMessage
+    | IAddSourceBufferCoreMessage
+    | IUpdateMediaSourceDurationCoreMessage
+    | IInterruptMediaSourceDurationCoreMessage
+    | IEndOfStreamCoreMessage
+    | IStopEndOfStreamCoreMessage
+    | IDisposeMediaSourceCoreMessage,
   transferables?: Transferable[],
 ) => void;
 
@@ -226,7 +231,7 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
   ) {
     this.type = sbType;
     this.codec = codec;
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("WorkerSourceBufferInterface " + sbType);
     this._mediaSourceId = mediaSourceId;
     this._queuedOperations = [];
     this._pendingOperations = new Map();
@@ -236,7 +241,9 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
   public onOperationSuccess(operationId: string, ranges: IRange[]): void {
     const mapElt = this._pendingOperations.get(operationId);
     if (mapElt === undefined) {
-      log.warn("mse", "unknown SourceBuffer operation succeeded");
+      log.warn("mse", "unknown SourceBuffer operation succeeded", {
+        type: this.type,
+      });
     } else {
       this._pendingOperations.delete(operationId);
       mapElt.resolve(ranges);
@@ -250,17 +257,25 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
   ): void {
     const formattedErr =
       error.errorName === "CancellationError"
-        ? new CancellationError()
+        ? new CancellationError("Pending SBI Operation " + this.type, "SBI Failure")
         : new SourceBufferError(error.errorName, error.message, error.isBufferFull);
     const mapElt = this._pendingOperations.get(operationId);
     if (mapElt === undefined) {
-      log.info("mse", "unknown SourceBuffer operation failed", formattedErr);
+      log.info(
+        "mse",
+        "unknown SourceBuffer operation failed",
+        { type: this.type },
+        formattedErr,
+      );
     } else {
       this._pendingOperations.delete(operationId);
       mapElt.reject(formattedErr);
     }
 
-    const cancellationError = new CancellationError();
+    const cancellationError = new CancellationError(
+      "Queued SBI Operation " + this.type,
+      "SBI failure",
+    );
     for (const operation of this._queuedOperations) {
       operation.reject(cancellationError);
     }
@@ -299,7 +314,7 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
         const operationId = generateSourceBufferOperationId();
         this._messageSender(
           {
-            type: WorkerMessageType.SourceBufferAppend,
+            type: CoreMessageType.SourceBufferAppend,
             mediaSourceId: this._mediaSourceId,
             sourceBufferType: this.type,
             operationId,
@@ -334,7 +349,7 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
       try {
         const operationId = generateSourceBufferOperationId();
         this._messageSender({
-          type: WorkerMessageType.SourceBufferRemove,
+          type: CoreMessageType.SourceBufferRemove,
           mediaSourceId: this._mediaSourceId,
           sourceBufferType: this.type,
           operationId,
@@ -352,16 +367,21 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
 
   public abort(): void {
     this._messageSender({
-      type: WorkerMessageType.AbortSourceBuffer,
+      type: CoreMessageType.AbortSourceBuffer,
       mediaSourceId: this._mediaSourceId,
       sourceBufferType: this.type,
       value: null,
     });
   }
 
-  public dispose(): void {
+  /**
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
+   */
+  public dispose(reason: string | undefined): void {
     this.abort();
-    this._canceller.cancel();
+    this._canceller.cancel(reason ?? "WorkerSourceBufferInterface dispose");
   }
 
   public getBuffered(): undefined {
@@ -411,7 +431,7 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
           const nOpId = generateSourceBufferOperationId();
           this._messageSender(
             {
-              type: WorkerMessageType.SourceBufferAppend,
+              type: CoreMessageType.SourceBufferAppend,
               mediaSourceId: this._mediaSourceId,
               sourceBufferType: this.type,
               operationId: nOpId,
@@ -427,7 +447,7 @@ export class WorkerSourceBufferInterface implements ISourceBufferInterface {
           const [start, end] = nextOp.params;
           const nOpId = generateSourceBufferOperationId();
           this._messageSender({
-            type: WorkerMessageType.SourceBufferRemove,
+            type: CoreMessageType.SourceBufferRemove,
             mediaSourceId: this._mediaSourceId,
             sourceBufferType: this.type,
             operationId: nOpId,