rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

package/src/core/segment_buffers/segment_buffers_store.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import { MediaError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
+import {
+  CancellationError,
+  CancellationSignal,
+} from "../../utils/task_canceller";
 import {
   AudioVideoSegmentBuffer,
   IBufferType,
@@ -60,7 +60,7 @@ type INativeMediaBufferType = "audio" | "video";
  * To be able to use a SegmentBuffer linked to a native media buffer, you
  * will first need to create it, but also wait until the other one is either
  * created or explicitely disabled through the `disableSegmentBuffer` method.
- * The Observable returned by `waitForUsableBuffers` will emit when
+ * The Promise returned by `waitForUsableBuffers` will emit when
  * that is the case.
  *
  * @class SegmentBuffersStore
@@ -96,7 +96,7 @@ export default class SegmentBuffersStore {
   /**
    * Callbacks called after a SourceBuffer is either created or disabled.
    * Used for example to trigger the `this.waitForUsableBuffers`
-   * Observable.
+   * Promise.
    */
   private _onNativeBufferAddedOrDisabled : Array<() => void>;
 
@@ -179,7 +179,7 @@ export default class SegmentBuffersStore {
    * content need to all be created (by creating SegmentBuffers linked to them)
    * before any one can be used.
    *
-   * This function will return an Observable emitting when any and all native
+   * This function will return a Promise resolving when any and all native
    * SourceBuffers can be used.
    *
    * From https://w3c.github.io/media-source/#methods
@@ -187,18 +187,27 @@ export default class SegmentBuffersStore {
    *   exception if the media element has reached the HAVE_METADATA
    *   readyState. This can occur if the user agent's media engine
    *   does not support adding more tracks during playback.
-   * @return {Observable}
+   * @param {Object} cancelWaitSignal
+   * @return {Promise}
    */
-  public waitForUsableBuffers() : Observable<void> {
+  public waitForUsableBuffers(cancelWaitSignal : CancellationSignal) : Promise<void> {
     if (this._areNativeBuffersUsable()) {
-      return observableOf(undefined);
+      return Promise.resolve();
     }
-    return new Observable(obs => {
-      this._onNativeBufferAddedOrDisabled.push(() => {
+    return new Promise((res, rej) => {
+      const onAddedOrDisabled = () => {
         if (this._areNativeBuffersUsable()) {
-          obs.next(undefined);
-          obs.complete();
+          res();
+        }
+      };
+      this._onNativeBufferAddedOrDisabled.push(onAddedOrDisabled);
+
+      cancelWaitSignal.register((error : CancellationError) => {
+        const indexOf = this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
+        if (indexOf >= 0) {
+          this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
         }
+        rej(error);
       });
     });
   }

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -44,9 +44,14 @@ import Manifest, {
 import deferSubscriptions from "../../../utils/defer_subscriptions";
 import { fromEvent } from "../../../utils/event_emitter";
 import filterMap from "../../../utils/filter_map";
-import { IReadOnlySharedReference } from "../../../utils/reference";
+import {
+  createMappedReference,
+  IReadOnlySharedReference,
+} from "../../../utils/reference";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
 import nextTickObs from "../../../utils/rx-next-tick";
 import SortedList from "../../../utils/sorted_list";
+import TaskCanceller from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
 import type { IReadOnlyPlaybackObserver } from "../../api";
@@ -140,14 +145,22 @@ export default function StreamOrchestrator(
       const defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
                                 MAXIMUM_MAX_BUFFER_AHEAD[bufferType] as number :
                                 Infinity;
-      return BufferGarbageCollector({
-        segmentBuffer,
-        currentTime$: playbackObserver.getReference().asObservable()
-          .pipe(map(o => o.position.pending ?? o.position.last)),
-        maxBufferBehind$: maxBufferBehind.asObservable().pipe(
-          map(val => Math.min(val, defaultMaxBehind))),
-        maxBufferAhead$: maxBufferAhead.asObservable().pipe(
-          map(val => Math.min(val, defaultMaxAhead))),
+      return new Observable<never>(() => {
+        const canceller = new TaskCanceller();
+        BufferGarbageCollector(
+          { segmentBuffer,
+            playbackObserver,
+            maxBufferBehind: createMappedReference(maxBufferBehind,
+                                                   (val) =>
+                                                     Math.min(val, defaultMaxBehind),
+                                                   canceller.signal),
+            maxBufferAhead: createMappedReference(maxBufferAhead,
+                                                  (val) =>
+                                                    Math.min(val, defaultMaxAhead),
+                                                  canceller.signal) },
+          canceller.signal
+        );
+        return () => { canceller.cancel(); };
       });
     });
 
@@ -322,9 +335,15 @@ export default function StreamOrchestrator(
         destroyStreams$.next();
 
         return observableConcat(
-          ...rangesToClean.map(({ start, end }) =>
-            start >= end ? EMPTY :
-                           segmentBuffer.removeBuffer(start, end).pipe(ignoreElements())),
+          ...rangesToClean.map(({ start, end }) => {
+            if (start >= end) {
+              return EMPTY;
+            }
+            const canceller = new TaskCanceller();
+            return fromCancellablePromise(canceller, () => {
+              return segmentBuffer.removeBuffer(start, end, canceller.signal);
+            }).pipe(ignoreElements());
+          }),
 
           // Schedule micro task before checking the last playback observation
           // to reduce the risk of race conditions where the next observation

package/src/core/stream/period/period_stream.ts

@@ -45,7 +45,10 @@ import { getLeftSizeOfRange } from "../../../utils/ranges";
 import createSharedReference, {
   IReadOnlySharedReference,
 } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller, {
+  CancellationSignal,
+} from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
 import { IReadOnlyPlaybackObserver } from "../../api";
@@ -176,15 +179,20 @@ export default function PeriodStream({
           if (SegmentBuffersStore.isNative(bufferType)) {
             return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
           }
-          if (period.end === undefined) {
-            cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start,
-                                                                  Infinity);
-          } else if (period.end <= period.start) {
-            cleanBuffer$ = observableOf(null);
-          } else {
-            cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start,
-                                                                  period.end);
-          }
+          const canceller = new TaskCanceller();
+          cleanBuffer$ = fromCancellablePromise(canceller, () => {
+            if (period.end === undefined) {
+              return segmentBufferStatus.value.removeBuffer(period.start,
+                                                            Infinity,
+                                                            canceller.signal);
+            } else if (period.end <= period.start) {
+              return Promise.resolve();
+            } else {
+              return segmentBufferStatus.value.removeBuffer(period.start,
+                                                            period.end,
+                                                            canceller.signal);
+            }
+          });
         } else {
           if (segmentBufferStatus.type === "uninitialized") {
             segmentBuffersStore.disableSegmentBuffer(bufferType);
@@ -237,8 +245,11 @@ export default function PeriodStream({
 
         const cleanBuffer$ =
           strategy.type === "clean-buffer" || strategy.type === "flush-buffer" ?
-            observableConcat(...strategy.value.map(({ start, end }) =>
-              segmentBuffer.removeBuffer(start, end))
+            observableConcat(...strategy.value.map(({ start, end }) => {
+              const canceller = new TaskCanceller();
+              return fromCancellablePromise(canceller, () =>
+                segmentBuffer.removeBuffer(start, end, canceller.signal));
+            })
             // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
             // first type parameter as `any` instead of the perfectly fine `unknown`,
             // leading to linter issues, as it forbids the usage of `any`.
@@ -249,12 +260,14 @@ export default function PeriodStream({
         const bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
         const adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
 
-        return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(() => {
-          return observableConcat(cleanBuffer$,
-                                  needsBufferFlush$,
-                                  observableMerge(adaptationStream$,
-                                                  bufferGarbageCollector$));
-        }));
+        const cancelWait = new TaskCanceller();
+        return fromCancellablePromise(cancelWait, () =>
+          segmentBuffersStore.waitForUsableBuffers(cancelWait.signal)
+        ).pipe(mergeMap(() =>
+          observableConcat(cleanBuffer$,
+                           needsBufferFlush$,
+                           observableMerge(adaptationStream$,
+                                           bufferGarbageCollector$))));
       });
 
       return observableConcat(

package/src/core/stream/representation/append_segment_to_buffer.ts

@@ -18,15 +18,8 @@
  * This file allows any Stream to push data to a SegmentBuffer.
  */
 
-import {
-  catchError,
-  concat as observableConcat,
-  mergeMap,
-  ignoreElements,
-  Observable,
-  take,
-} from "rxjs";
 import { MediaError } from "../../../errors";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IPushChunkInfos,
@@ -39,45 +32,37 @@ import { IRepresentationStreamPlaybackObservation } from "./representation_strea
  * Append a segment to the given segmentBuffer.
  * If it leads to a QuotaExceededError, try to run our custom range
  * _garbage collector_ then retry.
- *
  * @param {Observable} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function appendSegmentToBuffer<T>(
+export default async function appendSegmentToBuffer<T>(
   playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>,
   segmentBuffer : SegmentBuffer,
-  dataInfos : IPushChunkInfos<T>
-) : Observable<unknown> {
-  const append$ = segmentBuffer.pushChunk(dataInfos);
-
-  return append$.pipe(
-    catchError((appendError : unknown) => {
-      if (!(appendError instanceof Error) || appendError.name !== "QuotaExceededError") {
-        const reason = appendError instanceof Error ?
-          appendError.toString() :
-          "An unknown error happened when pushing content";
-        throw new MediaError("BUFFER_APPEND_ERROR", reason);
-      }
-
-      return playbackObserver.getReference().asObservable().pipe(
-        take(1),
-        mergeMap((observation) => {
-          const currentPos = observation.position.pending ??
-                             observation.position.last;
-          return observableConcat(
-            forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()),
-            append$
-          ).pipe(
-            catchError((forcedGCError : unknown) => {
-              const reason = forcedGCError instanceof Error ?
-                forcedGCError.toString() :
-                "Could not clean the buffer";
+  dataInfos : IPushChunkInfos<T>,
+  cancellationSignal : CancellationSignal
+) : Promise<void> {
+  try {
+    await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
+  } catch (appendError : unknown) {
+    if (!(appendError instanceof Error) || appendError.name !== "QuotaExceededError") {
+      const reason = appendError instanceof Error ?
+        appendError.toString() :
+        "An unknown error happened when pushing content";
+      throw new MediaError("BUFFER_APPEND_ERROR", reason);
+    }
+    const { position } = playbackObserver.getReference().getValue();
+    const currentPos = position.pending ?? position.last;
+    try {
+      await forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal);
+      await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
+    } catch (err2) {
+      const reason = err2 instanceof Error ? err2.toString() :
+                                             "Could not clean the buffer";
 
-              throw new MediaError("BUFFER_FULL_ERROR", reason);
-            })
-          );
-        }));
-    }));
+      throw new MediaError("BUFFER_FULL_ERROR", reason);
+    }
+  }
 }

package/src/core/stream/representation/force_garbage_collection.ts

@@ -14,16 +14,10 @@
  * limitations under the License.
  */
 
-import {
-  concatAll,
-  defer as observableDefer,
-  from as observableFrom,
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import config from "../../../config";
 import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { SegmentBuffer } from "../../segment_buffers";
 
 
@@ -33,37 +27,39 @@ import { SegmentBuffer } from "../../segment_buffers";
  * Try to clean up buffered ranges from a low gcGap at first.
  * If it does not succeed to clean up space, use a higher gcCap.
  *
- * @param {Observable} timings$
+ * @param {number} currentPosition
  * @param {Object} bufferingQueue
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function forceGarbageCollection(
+export default async function forceGarbageCollection(
   currentPosition : number,
-  bufferingQueue : SegmentBuffer
-) : Observable<unknown> {
-  return observableDefer(() => {
-    const GC_GAP_CALM = config.getCurrent().BUFFER_GC_GAPS.CALM;
-    const GC_GAP_BEEFY = config.getCurrent().BUFFER_GC_GAPS.BEEFY;
-    log.warn("Stream: Running garbage collector");
-    const buffered = bufferingQueue.getBufferedRanges();
-    let cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);
+  bufferingQueue : SegmentBuffer,
+  cancellationSignal : CancellationSignal
+) : Promise<void> {
+  const GC_GAP_CALM = config.getCurrent().BUFFER_GC_GAPS.CALM;
+  const GC_GAP_BEEFY = config.getCurrent().BUFFER_GC_GAPS.BEEFY;
+  log.warn("Stream: Running garbage collector");
+  const buffered = bufferingQueue.getBufferedRanges();
+  let cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);
 
-    // more aggressive GC if we could not find any range to clean
-    if (cleanedupRanges.length === 0) {
-      cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_BEEFY);
-    }
+  // more aggressive GC if we could not find any range to clean
+  if (cleanedupRanges.length === 0) {
+    cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_BEEFY);
+  }
 
-    if (log.hasLevel("DEBUG")) {
-      log.debug("Stream: GC cleaning",
-                cleanedupRanges.map(({ start, end }) => `start: ${start} - end ${end}`)
-                  .join(", "));
+  if (log.hasLevel("DEBUG")) {
+    log.debug("Stream: GC cleaning",
+              cleanedupRanges.map(({ start, end }) => `start: ${start} - end ${end}`)
+                .join(", "));
+  }
+  for (const range of cleanedupRanges) {
+    const { start, end } = range;
+    if (start < end) {
+      await bufferingQueue.removeBuffer(start, end, cancellationSignal);
     }
-    return observableFrom(
-      cleanedupRanges.map(({ start, end }) =>
-        start >= end ? observableOf(null) :
-                       bufferingQueue.removeBuffer(start, end))
-    ).pipe(concatAll());
-  });
+  }
+  return;
 }
 
 /**

package/src/core/stream/representation/get_buffer_status.ts

@@ -100,8 +100,12 @@ export default function getBufferStatus(
   segmentBuffer.synchronizeInventory();
 
   const { representation } = content;
+  const askedStart = playbackObserver.getIsPaused() ||
+                     playbackObserver.getPlaybackRate() <= 0 ?
+    initialWantedTime - 0.1 :
+    initialWantedTime;
   const neededRange = getRangeOfNeededSegments(content,
-                                               initialWantedTime,
+                                               askedStart,
                                                bufferGoal);
   const shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start,
                                                                    neededRange.end);
@@ -139,7 +143,7 @@ export default function getBufferStatus(
 
   const prioritizedNeededSegments: IQueuedSegment[] = segmentsToLoad.map((segment) => (
     {
-      priority: getSegmentPriority(segment.time, initialWantedTime),
+      priority: getSegmentPriority(segment.time, askedStart),
       segment,
     }
   ));
@@ -221,7 +225,7 @@ function getRangeOfNeededSegments(
   {
     wantedStartPosition = lastIndexPosition - 1;
   } else {
-    wantedStartPosition = initialWantedTime;
+    wantedStartPosition = initialWantedTime - 0.1;
   }
 
   const wantedEndPosition = wantedStartPosition + bufferGoal;

package/src/core/stream/representation/push_init_segment.ts

@@ -26,6 +26,8 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import {
   IPushedChunkData,
@@ -71,11 +73,15 @@ export default function pushInitSegment<T>(
                                          timestampOffset: 0,
                                          appendWindow: [ undefined, undefined ],
                                          codec };
-    return appendSegmentToBuffer(playbackObserver,
-                                 segmentBuffer,
-                                 { data, inventoryInfos: null }).pipe(map(() => {
-      const buffered = segmentBuffer.getBufferedRanges();
-      return EVENTS.addedSegment(content, segment, buffered, segmentData);
-    }));
+    const canceller = new TaskCanceller();
+    return fromCancellablePromise(canceller, () =>
+      appendSegmentToBuffer(playbackObserver,
+                            segmentBuffer,
+                            { data, inventoryInfos: null },
+                            canceller.signal))
+      .pipe(map(() => {
+        const buffered = segmentBuffer.getBufferedRanges();
+        return EVENTS.addedSegment(content, segment, buffered, segmentData);
+      }));
   });
 }

package/src/core/stream/representation/push_media_segment.ts

@@ -29,6 +29,8 @@ import Manifest, {
 } from "../../../manifest";
 import { ISegmentParserParsedMediaChunk } from "../../../transports";
 import objectAssign from "../../../utils/object_assign";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
 import EVENTS from "../events_generators";
@@ -108,12 +110,16 @@ export default function pushMediaSegment<T>(
                                           start: estimatedStart,
                                           end: estimatedEnd },
                                         content);
+    const canceller = new TaskCanceller();
 
-    return appendSegmentToBuffer(playbackObserver,
-                                 segmentBuffer,
-                                 { data, inventoryInfos }).pipe(map(() => {
-      const buffered = segmentBuffer.getBufferedRanges();
-      return EVENTS.addedSegment(content, segment, buffered, chunkData);
-    }));
+    return fromCancellablePromise(canceller, () =>
+      appendSegmentToBuffer(playbackObserver,
+                            segmentBuffer,
+                            { data, inventoryInfos },
+                            canceller.signal))
+      .pipe(map(() => {
+        const buffered = segmentBuffer.getBufferedRanges();
+        return EVENTS.addedSegment(content, segment, buffered, chunkData);
+      }));
   });
 }

package/src/core/stream/representation/representation_stream.ts

@@ -52,6 +52,8 @@ import Manifest, {
 import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
 import { createSharedReference } from "../../../utils/reference";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { SegmentBuffer } from "../../segment_buffers";
@@ -267,10 +269,11 @@ export default function RepresentationStream<TSegmentDataType>({
           0,
           initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
         if (gcedPosition > 0) {
-          bufferRemoval = segmentBuffer
-            .removeBuffer(0, gcedPosition)
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            .pipe(ignoreElements());
+          const removalCanceller = new TaskCanceller();
+          bufferRemoval = fromCancellablePromise(removalCanceller, () =>
+            segmentBuffer.removeBuffer(0, gcedPosition, removalCanceller.signal)
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          ).pipe(ignoreElements());
         }
       }
       return status.shouldRefreshManifest ?
@@ -318,7 +321,10 @@ export default function RepresentationStream<TSegmentDataType>({
 
       case "end-of-segment": {
         const { segment } = evt.value;
-        return segmentBuffer.endOfSegment(objectAssign({ segment }, content))
+        const endOfSegmentCanceller = new TaskCanceller();
+        return fromCancellablePromise(endOfSegmentCanceller, () =>
+          segmentBuffer.endOfSegment(objectAssign({ segment }, content),
+                                     endOfSegmentCanceller.signal))
           // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
           // first type parameter as `any` instead of the perfectly fine `unknown`,
           // leading to linter issues, as it forbids the usage of `any`.

package/src/default_config.ts

@@ -342,7 +342,7 @@ const DEFAULT_CONFIG = {
      * small enough so this (arguably rare) situation won't lead to too much
      * waiting time.
      */
-  FORCE_DISCONTINUITY_SEEK_DELAY: 2000,
+  FORCE_DISCONTINUITY_SEEK_DELAY: 3000,
 
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
@@ -754,22 +754,22 @@ const DEFAULT_CONFIG = {
     END: 0.1,
   },
 
-    /**
-     * Maximum interval at which text tracks are refreshed in an "html"
-     * textTrackMode.
-     *
-     * The text tracks are also refreshed on various video events, this interval
-     * will only trigger a refresh if none of those events was received during
-     * that timespan.
-     *
-     * Note that if the TextTrack cue did not change between two intervals or
-     * events, the DOM won't be refreshed.
-     * The TextTrack cues structure is also optimized for fast retrieval.
-     * We should thus not have much of a performance impact here if we set a low
-     * interval.
-     *
-     * @type {Number}
-     */
+  /**
+   * Maximum interval at which text tracks are refreshed in an "html"
+   * textTrackMode.
+   *
+   * The text tracks are also refreshed on various video events, this interval
+   * will only trigger a refresh if none of those events was received during
+   * that timespan.
+   *
+   * Note that if the TextTrack cue did not change between two intervals or
+   * events, the DOM won't be refreshed.
+   * The TextTrack cues structure is also optimized for fast retrieval.
+   * We should thus not have much of a performance impact here if we set a low
+   * interval.
+   *
+   * @type {Number}
+   */
   MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL: 50,
 
     /**

package/src/errors/custom_loader_error.ts

@@ -31,9 +31,10 @@ export default class CustomLoaderError extends Error {
   public readonly xhr : XMLHttpRequest | undefined;
 
   /**
+   * @param {string} message
+   * @param {boolean} canRetry
+   * @param {boolean} isOfflineError
    * @param {XMLHttpRequest} xhr
-   * @param {string} url
-   * @param {string} type
    */
   constructor(
     message : string,

package/src/experimental/tools/VideoThumbnailLoader/get_initialized_source_buffer.ts

@@ -29,6 +29,8 @@ import {
 import { ISegmentFetcher } from "../../../core/fetchers/segment/segment_fetcher";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 import { ISegment } from "../../../manifest";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import prepareSourceBuffer from "./prepare_source_buffer";
 import { IContentInfos } from "./types";
 
@@ -88,14 +90,17 @@ function loadAndPushInitData(contentInfos: IContentInfos,
       const initSegmentData = initializationData instanceof ArrayBuffer ?
         new Uint8Array(initializationData) :
         initializationData;
-      return sourceBuffer
+
+      const pushCanceller = new TaskCanceller();
+      return fromCancellablePromise(pushCanceller, () => sourceBuffer
         .pushChunk({ data: { initSegment: initSegmentData,
                              chunk: null,
                              appendWindow: [undefined, undefined],
                              timestampOffset: 0,
                              codec: contentInfos
                                .representation.getMimeTypeString() },
-                     inventoryInfos: null });
+                     inventoryInfos: null },
+                   pushCanceller.signal));
     })
   );
 }

package/src/experimental/tools/VideoThumbnailLoader/push_data.ts

@@ -9,6 +9,8 @@ import Manifest, {
   Representation,
 } from "../../../manifest";
 import { ISegmentParserParsedMediaChunk } from "../../../transports";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 
 /**
  * Push data to the video source buffer.
@@ -33,12 +35,14 @@ export default function pushData(
   const { chunkData, appendWindow } = parsed;
   const segmentData = chunkData instanceof ArrayBuffer ?
     new Uint8Array(chunkData) : chunkData;
-  return videoSourceBuffer
+  const pushCanceller = new TaskCanceller();
+  return fromCancellablePromise(pushCanceller, () => videoSourceBuffer
     .pushChunk({ data: { chunk: segmentData,
                          timestampOffset: 0,
                          appendWindow,
                          initSegment: null,
                          codec: inventoryInfos
                            .representation.getMimeTypeString() },
-                 inventoryInfos });
+                 inventoryInfos },
+               pushCanceller.signal));
 }