rx-player 4.0.0-beta.0 → 4.0.0-beta.2

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

@@ -141,9 +141,9 @@ export default function StreamOrchestrator(
     });
 
   // Create automatically the right `PeriodStream` for every possible types
-  segmentBuffersStore.getBufferTypes().map((bufferType) => {
+  for (const bufferType of segmentBuffersStore.getBufferTypes()) {
     manageEveryStreams(bufferType, initialPeriod);
-  });
+  }
 
   /**
    * Manage creation and removal of Streams for every Periods for a given type.
@@ -168,7 +168,8 @@ export default function StreamOrchestrator(
     let enableOutOfBoundsCheck = false;
 
     /** Cancels currently created `PeriodStream`s. */
-    let currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+    let currentCanceller = new TaskCanceller();
+    currentCanceller.linkToSignal(orchestratorCancelSignal);
 
     // Restart the current Stream when the wanted time is in another period
     // than the ones already considered
@@ -187,7 +188,8 @@ export default function StreamOrchestrator(
         callbacks.periodStreamCleared({ type: bufferType, manifest, period });
       }
       currentCanceller.cancel();
-      currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+      currentCanceller = new TaskCanceller();
+      currentCanceller.linkToSignal(orchestratorCancelSignal);
 
       const nextPeriod = manifest.getPeriodForTime(time) ??
                          manifest.getNextPeriod(time);
@@ -199,7 +201,13 @@ export default function StreamOrchestrator(
     }, { clearSignal: orchestratorCancelSignal, includeLastObservation: true });
 
     manifest.addEventListener("decipherabilityUpdate", (evt) => {
+      if (orchestratorCancelSignal.isCancelled()) {
+        return;
+      }
       onDecipherabilityUpdates(evt).catch(err => {
+        if (orchestratorCancelSignal.isCancelled()) {
+          return;
+        }
         currentCanceller.cancel();
         callbacks.error(err);
       });
@@ -276,8 +284,16 @@ export default function StreamOrchestrator(
       const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
       const ofCurrentType = updates
         .filter(update => update.adaptation.type === bufferType);
-      if (ofCurrentType.length === 0 || segmentBufferStatus.type !== "initialized") {
-        return ; // no need to stop the current Streams.
+      if (
+        // No update concerns the current type of data
+        ofCurrentType.length === 0 ||
+        segmentBufferStatus.type !== "initialized" ||
+        // The update only notifies of now-decipherable streams
+        ofCurrentType.every(x => x.representation.decipherable === true)
+      ) {
+        // Data won't have to be removed from the buffers, no need to stop the
+        // current Streams.
+        return ;
       }
 
       const segmentBuffer = segmentBufferStatus.value;
@@ -317,7 +333,8 @@ export default function StreamOrchestrator(
       }
 
       currentCanceller.cancel();
-      currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+      currentCanceller = new TaskCanceller();
+      currentCanceller.linkToSignal(orchestratorCancelSignal);
 
       /** Remove from the `SegmentBuffer` all the concerned time ranges. */
       for (const { start, end } of [...undecipherableRanges, ...rangesToRemove]) {
@@ -330,7 +347,7 @@ export default function StreamOrchestrator(
       // to reduce the risk of race conditions where the next observation
       // was going to be emitted synchronously.
       nextTick(() => {
-        if (orchestratorCancelSignal.isCancelled) {
+        if (orchestratorCancelSignal.isCancelled()) {
           return ;
         }
         const observation = playbackObserver.getReference().getValue();
@@ -340,12 +357,12 @@ export default function StreamOrchestrator(
           callbacks.needsDecipherabilityFlush({ position: observation.position.last,
                                                 autoPlay: shouldAutoPlay,
                                                 duration: observation.duration });
-          if (orchestratorCancelSignal.isCancelled) {
+          if (orchestratorCancelSignal.isCancelled()) {
             return ;
           }
         } else if (needsFlushingAfterClean(observation, rangesToRemove)) {
           callbacks.needsBufferFlush();
-          if (orchestratorCancelSignal.isCancelled) {
+          if (orchestratorCancelSignal.isCancelled()) {
             return ;
           }
         }
@@ -418,7 +435,8 @@ export default function StreamOrchestrator(
     } | null = null;
 
     /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */
-    const currentStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    const currentStreamCanceller = new TaskCanceller();
+    currentStreamCanceller.linkToSignal(cancelSignal);
 
     // Stop current PeriodStream when the current position goes over the end of
     // that Period.
@@ -453,12 +471,10 @@ export default function StreamOrchestrator(
       ...consecutivePeriodStreamCb,
       streamStatusUpdate(value : IStreamStatusPayload) : void {
         if (value.hasFinishedLoading) {
-          if (nextStreamInfo === null) {
-            const nextPeriod = manifest.getPeriodAfter(basePeriod);
-            if (nextPeriod !== null) {
-              // current Stream is full, create the next one if not
-              createNextPeriodStream(nextPeriod);
-            }
+          const nextPeriod = manifest.getPeriodAfter(basePeriod);
+          if (nextPeriod !== null) {
+            // current Stream is full, create the next one if not
+            checkOrCreateNextPeriodStream(nextPeriod);
           }
         } else if (nextStreamInfo !== null) {
           // current Stream is active, destroy next Stream if created
@@ -490,15 +506,21 @@ export default function StreamOrchestrator(
      * Create `PeriodStream` for the next Period, specified under `nextPeriod`.
      * @param {Object} nextPeriod
      */
-    function createNextPeriodStream(nextPeriod : Period) : void {
+    function checkOrCreateNextPeriodStream(nextPeriod : Period) : void {
       if (nextStreamInfo !== null) {
-        log.warn("Stream: Creating next `PeriodStream` while it was already created.");
+        if (nextStreamInfo.period.id === nextPeriod.id) {
+          return;
+        }
+        log.warn("Stream: Creating next `PeriodStream` while one was already created.",
+                 bufferType, nextPeriod.id, nextStreamInfo.period.id);
         consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
                                                         manifest,
                                                         period: nextStreamInfo.period });
         nextStreamInfo.canceller.cancel();
       }
-      nextStreamInfo = { canceller: new TaskCanceller({ cancelOn: cancelSignal }),
+      const nextStreamCanceller = new TaskCanceller();
+      nextStreamCanceller.linkToSignal(cancelSignal);
+      nextStreamInfo = { canceller: nextStreamCanceller,
                          period: nextPeriod };
       manageConsecutivePeriodStreams(bufferType,
                                      nextPeriod,

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

@@ -111,7 +111,7 @@ export default function PeriodStream(
   );
 
   callbacks.periodStreamReady({ type: bufferType, manifest, period, adaptationRef });
-  if (parentCancelSignal.isCancelled) {
+  if (parentCancelSignal.isCancelled()) {
     return;
   }
 
@@ -124,7 +124,8 @@ export default function PeriodStream(
       if (choice === undefined) {
         return;
       }
-      const streamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+      const streamCanceller = new TaskCanceller();
+      streamCanceller.linkToSignal(parentCancelSignal);
       currentStreamCanceller?.cancel(); // Cancel oreviously created stream if one
       currentStreamCanceller = streamCanceller;
 
@@ -147,20 +148,20 @@ export default function PeriodStream(
               await segmentBufferStatus.value.removeBuffer(period.start,
                                                            periodEnd,
                                                            streamCanceller.signal);
-              if (streamCanceller.isUsed) {
+              if (streamCanceller.isUsed()) {
                 return; // The stream has been cancelled
               }
             }
           }
         } else if (segmentBufferStatus.type === "uninitialized") {
           segmentBuffersStore.disableSegmentBuffer(bufferType);
-          if (streamCanceller.isUsed) {
+          if (streamCanceller.isUsed()) {
             return; // The stream has been cancelled
           }
         }
 
         callbacks.adaptationChange({ type: bufferType, adaptation: null, period });
-        if (streamCanceller.isUsed) {
+        if (streamCanceller.isUsed()) {
           return; // Previous call has provoken Stream cancellation by side-effect
         }
 
@@ -220,7 +221,7 @@ export default function PeriodStream(
                `P: ${period.start}`);
 
       callbacks.adaptationChange({ type: bufferType, adaptation, period });
-      if (streamCanceller.isUsed) {
+      if (streamCanceller.isUsed()) {
         return; // Previous call has provoken cancellation by side-effect
       }
 
@@ -244,19 +245,19 @@ export default function PeriodStream(
       }
 
       await segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal);
-      if (streamCanceller.isUsed) {
+      if (streamCanceller.isUsed()) {
         return; // The Stream has since been cancelled
       }
       if (strategy.type === "flush-buffer" || strategy.type === "clean-buffer") {
         for (const { start, end } of strategy.value) {
           await segmentBuffer.removeBuffer(start, end, streamCanceller.signal);
-          if (streamCanceller.isUsed) {
+          if (streamCanceller.isUsed()) {
             return; // The Stream has since been cancelled
           }
         }
         if (strategy.type === "flush-buffer") {
           callbacks.needsBufferFlush();
-          if (streamCanceller.isUsed) {
+          if (streamCanceller.isUsed()) {
             return ; // Previous callback cancelled the Stream by side-effect
           }
         }
@@ -319,7 +320,7 @@ export default function PeriodStream(
           defaultReason: "Unknown `AdaptationStream` error",
         });
         callbacks.warning(formattedError);
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return ; // Previous callback cancelled the Stream by side-effect
         }
 
@@ -371,7 +372,8 @@ function getFirstDeclaredMimeType(adaptation : Adaptation) : string {
   if (representations.length === 0) {
     const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION",
                                     "No Representation in the chosen " +
-                                    adaptation.type + " Adaptation can be played");
+                                    adaptation.type + " Adaptation can be played",
+                                    { adaptation });
     throw noRepErr;
   }
   return representations[0].getMimeTypeString();

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

@@ -97,23 +97,29 @@ export default function RepresentationStream<TSegmentDataType>(
   const bufferType = adaptation.type;
 
   /** `TaskCanceller` stopping ALL operations performed by the `RepresentationStream` */
-  const globalCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+  const globalCanceller = new TaskCanceller();
+  globalCanceller.linkToSignal(parentCancelSignal);
 
   /**
    * `TaskCanceller` allowing to only stop segment loading and checking operations.
    * This allows to stop only tasks linked to network resource usage, which is
    * often a limited resource, while still letting buffer operations to finish.
    */
-  const segmentsLoadingCanceller = new TaskCanceller({
-    cancelOn: globalCanceller.signal,
-  });
+  const segmentsLoadingCanceller = new TaskCanceller();
+  segmentsLoadingCanceller.linkToSignal(globalCanceller.signal);
 
   /** Saved initialization segment state for this representation. */
-  const initSegmentState : IInitSegmentState<TSegmentDataType> = {
+  const initSegmentState : IInitSegmentState = {
     segment: representation.index.getInitSegment(),
-    segmentData: null,
+    uniqueId: null,
     isLoaded: false,
   };
+  globalCanceller.signal.register(() => {
+    // Free initialization segment if one has been declared
+    if (initSegmentState.uniqueId !== null) {
+      segmentBuffer.freeInitSegment(initSegmentState.uniqueId);
+    }
+  });
 
   /** Emit the last scheduled downloading queue for segments. */
   const lastSegmentQueue = createSharedReference<IDownloadQueueItem>({
@@ -125,7 +131,6 @@ export default function RepresentationStream<TSegmentDataType>(
   const hasInitSegment = initSegmentState.segment !== null;
 
   if (!hasInitSegment) {
-    initSegmentState.segmentData = null;
     initSegmentState.isLoaded = true;
   }
 
@@ -149,7 +154,7 @@ export default function RepresentationStream<TSegmentDataType>(
       callbacks.encryptionDataEncountered(
         encryptionData.map(d => objectAssign({ content }, d))
       );
-      if (globalCanceller.isUsed) {
+      if (globalCanceller.isUsed()) {
         return ; // previous callback has stopped everything by side-effect
       }
     }
@@ -161,7 +166,7 @@ export default function RepresentationStream<TSegmentDataType>(
                                                 segmentFetcher,
                                                 hasInitSegment);
   downloadingQueue.addEventListener("error", (err) => {
-    if (segmentsLoadingCanceller.signal.isCancelled) {
+    if (segmentsLoadingCanceller.signal.isCancelled()) {
       return; // ignore post requests-cancellation loading-related errors,
     }
     globalCanceller.cancel(); // Stop every operations
@@ -172,7 +177,7 @@ export default function RepresentationStream<TSegmentDataType>(
   downloadingQueue.addEventListener("emptyQueue", checkStatus);
   downloadingQueue.addEventListener("requestRetry", (payload) => {
     callbacks.warning(payload.error);
-    if (segmentsLoadingCanceller.signal.isCancelled) {
+    if (segmentsLoadingCanceller.signal.isCancelled()) {
       return; // If the previous callback led to loading operations being stopped, skip
     }
     const retriedSegment = payload.segment;
@@ -218,7 +223,7 @@ export default function RepresentationStream<TSegmentDataType>(
    * issues at the current time, calling the right callbacks if necessary.
    */
   function checkStatus() : void {
-    if (segmentsLoadingCanceller.isUsed) {
+    if (segmentsLoadingCanceller.isUsed()) {
       return ; // Stop all buffer status checking if load operations are stopped
     }
     const observation = playbackObserver.getReference().getValue();
@@ -305,7 +310,7 @@ export default function RepresentationStream<TSegmentDataType>(
                                    isEmptyStream: false,
                                    hasFinishedLoading: status.hasFinishedLoading,
                                    neededSegments: status.neededSegments });
-    if (segmentsLoadingCanceller.signal.isCancelled) {
+    if (segmentsLoadingCanceller.signal.isCancelled()) {
       return ; // previous callback has stopped loading operations by side-effect
     }
     const { UPTO_CURRENT_POSITION_CLEANUP } = config.getCurrent();
@@ -314,7 +319,7 @@ export default function RepresentationStream<TSegmentDataType>(
         0,
         initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
       if (gcedPosition > 0) {
-        segmentBuffer.removeBuffer(0, gcedPosition, segmentsLoadingCanceller.signal)
+        segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
           .catch(onFatalBufferError);
       }
     }
@@ -332,7 +337,7 @@ export default function RepresentationStream<TSegmentDataType>(
     evt : IParsedInitSegmentPayload<TSegmentDataType> |
           IParsedSegmentPayload<TSegmentDataType>
   ) : void {
-    if (globalCanceller.isUsed) {
+    if (globalCanceller.isUsed()) {
       // We should not do anything with segments if the `RepresentationStream`
       // is not running anymore.
       return ;
@@ -359,7 +364,7 @@ export default function RepresentationStream<TSegmentDataType>(
         hasSentEncryptionData = true;
 
         // previous callback could have lead to cancellation
-        if (globalCanceller.isUsed) {
+        if (globalCanceller.isUsed()) {
           return ;
         }
       }
@@ -371,21 +376,27 @@ export default function RepresentationStream<TSegmentDataType>(
       {
         representation.index.initialize(evt.segmentList);
       }
-      initSegmentState.segmentData = evt.initializationData;
       initSegmentState.isLoaded = true;
 
-      pushInitSegment({ playbackObserver,
-                        content,
-                        segment: evt.segment,
-                        segmentData: evt.initializationData,
-                        segmentBuffer },
-                      globalCanceller.signal)
-        .then((result) => {
-          if (result !== null) {
-            callbacks.addedSegment(result);
-          }
-        })
-        .catch(onFatalBufferError);
+      if (evt.initializationData !== null) {
+        const initSegmentUniqueId = representation.uniqueId;
+        initSegmentState.uniqueId = initSegmentUniqueId;
+        segmentBuffer.declareInitSegment(initSegmentUniqueId,
+                                         evt.initializationData);
+        pushInitSegment({ playbackObserver,
+                          content,
+                          initSegmentUniqueId,
+                          segment: evt.segment,
+                          segmentData: evt.initializationData,
+                          segmentBuffer },
+                        globalCanceller.signal)
+          .then((result) => {
+            if (result !== null) {
+              callbacks.addedSegment(result);
+            }
+          })
+          .catch(onFatalBufferError);
+      }
 
       // Sometimes the segment list is only known once the initialization segment
       // is parsed. Thus we immediately re-check if there's new segments to load.
@@ -401,21 +412,21 @@ export default function RepresentationStream<TSegmentDataType>(
 
       if (needsManifestRefresh === true) {
         callbacks.needsManifestRefresh();
-        if (globalCanceller.isUsed) {
+        if (globalCanceller.isUsed()) {
           return ; // previous callback has stopped everything by side-effect
         }
       }
       if (inbandEvents !== undefined && inbandEvents.length > 0) {
         callbacks.inbandEvent(inbandEvents);
-        if (globalCanceller.isUsed) {
+        if (globalCanceller.isUsed()) {
           return ; // previous callback has stopped everything by side-effect
         }
       }
 
-      const initSegmentData = initSegmentState.segmentData;
+      const initSegmentUniqueId = initSegmentState.uniqueId;
       pushMediaSegment({ playbackObserver,
                          content,
-                         initSegmentData,
+                         initSegmentUniqueId,
                          parsedSegment: evt,
                          segment: evt.segment,
                          segmentBuffer },
@@ -436,7 +447,7 @@ export default function RepresentationStream<TSegmentDataType>(
    * @param {*} err
    */
   function onFatalBufferError(err : unknown) : void {
-    if (globalCanceller.isUsed && err instanceof CancellationError) {
+    if (globalCanceller.isUsed() && err instanceof CancellationError) {
       // The error is linked to cancellation AND we explicitely cancelled buffer
       // operations.
       // We can thus ignore it, it is very unlikely to lead to true buffer issues.
@@ -451,17 +462,18 @@ export default function RepresentationStream<TSegmentDataType>(
  * Information about the initialization segment linked to the Representation
  * which the RepresentationStream try to download segments for.
  */
-interface IInitSegmentState<T> {
+interface IInitSegmentState {
   /**
    * Segment Object describing that initialization segment.
    * `null` if there's no initialization segment for that Representation.
    */
   segment : ISegment | null;
   /**
-   * Initialization segment data.
-   * `null` either when it doesn't exist or when it has not been loaded yet.
+   * Unique identifier used to identify the initialization segment data, used by
+   * the `SegmentBuffer`.
+   * `null` either when it doesn't exist or when it has not been declared yet.
    */
-  segmentData : T | null;
+  uniqueId : string | null;
   /** `true` if the initialization segment has been loaded and parsed. */
   isLoaded : boolean;
 }

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

@@ -22,6 +22,7 @@ import { MediaError } from "../../../../errors";
 import { CancellationError, CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import {
+  IInsertedChunkInfos,
   IPushChunkInfos,
   SegmentBuffer,
 } from "../../../segment_buffers";
@@ -41,13 +42,13 @@ import forceGarbageCollection from "./force_garbage_collection";
 export default async function appendSegmentToBuffer<T>(
   playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>,
   segmentBuffer : SegmentBuffer,
-  dataInfos : IPushChunkInfos<T>,
+  dataInfos : IPushChunkInfos<T> & { inventoryInfos: IInsertedChunkInfos },
   cancellationSignal : CancellationSignal
 ) : Promise<void> {
   try {
     await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
   } catch (appendError : unknown) {
-    if (cancellationSignal.isCancelled && appendError instanceof CancellationError) {
+    if (cancellationSignal.isCancelled() && appendError instanceof CancellationError) {
       throw appendError;
     } else if (!(appendError instanceof Error) ||
                appendError.name !== "QuotaExceededError")
@@ -55,7 +56,9 @@ export default async function appendSegmentToBuffer<T>(
       const reason = appendError instanceof Error ?
         appendError.toString() :
         "An unknown error happened when pushing content";
-      throw new MediaError("BUFFER_APPEND_ERROR", reason);
+      throw new MediaError("BUFFER_APPEND_ERROR",
+                           reason,
+                           { adaptation: dataInfos.inventoryInfos.adaptation });
     }
     const { position } = playbackObserver.getReference().getValue();
     const currentPos = position.pending ?? position.last;
@@ -66,7 +69,9 @@ export default async function appendSegmentToBuffer<T>(
       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,
+                           { adaptation: dataInfos.inventoryInfos.adaptation });
     }
   }
 }

package/src/core/stream/representation/utils/downloading_queue.ts

@@ -28,6 +28,7 @@ import {
 } from "../../../../transports";
 import assert from "../../../../utils/assert";
 import EventEmitter from "../../../../utils/event_emitter";
+import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
 import createSharedReference, {
   IReadOnlySharedReference,
@@ -231,6 +232,7 @@ export default class DownloadingQueue<T>
 
   public stop() {
     this._currentCanceller?.cancel();
+    this._currentCanceller = null;
   }
 
   /**
@@ -245,7 +247,7 @@ export default class DownloadingQueue<T>
     const recursivelyRequestSegments = (
       startingSegment : IQueuedSegment | undefined
     ) : void  => {
-      if (this._currentCanceller !== null && this._currentCanceller.isUsed) {
+      if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
         this._mediaSegmentRequest = null;
         return;
       }
@@ -254,7 +256,10 @@ export default class DownloadingQueue<T>
         this.trigger("emptyQueue", null);
         return;
       }
-      const canceller = new TaskCanceller({ cancelOn: this._currentCanceller?.signal });
+      const canceller = new TaskCanceller();
+      const unlinkCanceller = this._currentCanceller === null ?
+        noop :
+        canceller.linkToSignal(this._currentCanceller.signal);
 
       const { segment, priority } = startingSegment;
       const context = objectAssign({ segment }, this._content);
@@ -368,6 +373,7 @@ export default class DownloadingQueue<T>
          * requests are scheduled. It is used to schedule the next segment.
          */
         beforeEnded: () : void => {
+          unlinkCanceller();
           this._mediaSegmentRequest = null;
 
           if (isWaitingOnInitSegment) {
@@ -381,6 +387,7 @@ export default class DownloadingQueue<T>
       }, canceller.signal);
 
       request.catch((error : unknown) => {
+        unlinkCanceller();
         if (!isComplete) {
           isComplete = true;
           this.stop();
@@ -400,7 +407,7 @@ export default class DownloadingQueue<T>
   private _restartInitSegmentDownloadingQueue(
     queuedInitSegment : IQueuedSegment | null
   ) : void {
-    if (this._currentCanceller !== null && this._currentCanceller.isUsed) {
+    if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
       return;
     }
     if (this._initSegmentRequest !== null) {
@@ -410,7 +417,10 @@ export default class DownloadingQueue<T>
       return ;
     }
 
-    const canceller = new TaskCanceller({ cancelOn: this._currentCanceller?.signal });
+    const canceller = new TaskCanceller();
+    const unlinkCanceller = this._currentCanceller === null ?
+      noop :
+      canceller.linkToSignal(this._currentCanceller.signal);
     const { segment, priority } = queuedInitSegment;
     const context = objectAssign({ segment }, this._content);
 
@@ -428,6 +438,7 @@ export default class DownloadingQueue<T>
         log.info("Stream: init segment request interrupted temporarly.", segment.id);
       },
       beforeEnded: () => {
+        unlinkCanceller();
         this._initSegmentRequest = null;
         isComplete = true;
       },
@@ -446,6 +457,7 @@ export default class DownloadingQueue<T>
     }, canceller.signal);
 
     request.catch((error : unknown) => {
+      unlinkCanceller();
       if (!isComplete) {
         isComplete = true;
         this.stop();

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

@@ -20,6 +20,7 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../../manifest";
+import objectAssign from "../../../../utils/object_assign";
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import {
@@ -42,6 +43,7 @@ export default async function pushInitSegment<T>(
   {
     playbackObserver,
     content,
+    initSegmentUniqueId,
     segment,
     segmentData,
     segmentBuffer,
@@ -53,27 +55,30 @@ export default async function pushInitSegment<T>(
                manifest : Manifest;
                period : Period;
                representation : Representation; };
-    segmentData : T | null;
+    initSegmentUniqueId : string;
+    segmentData : T;
     segment : ISegment;
     segmentBuffer : SegmentBuffer;
   },
   cancelSignal : CancellationSignal
 ) : Promise< IStreamEventAddedSegmentPayload<T> | null > {
-  if (segmentData === null) {
-    return null;
-  }
   if (cancelSignal.cancellationError !== null) {
     throw cancelSignal.cancellationError;
   }
   const codec = content.representation.getMimeTypeString();
-  const data : IPushedChunkData<T> = { initSegment: segmentData,
+  const data : IPushedChunkData<T> = { initSegmentUniqueId,
                                        chunk: null,
                                        timestampOffset: 0,
                                        appendWindow: [ undefined, undefined ],
                                        codec };
+  const inventoryInfos = objectAssign({ segment,
+                                        chunkSize: undefined,
+                                        start: 0,
+                                        end: 0 },
+                                      content);
   await appendSegmentToBuffer(playbackObserver,
                               segmentBuffer,
-                              { data, inventoryInfos: null },
+                              { data, inventoryInfos },
                               cancelSignal);
   const buffered = segmentBuffer.getBufferedRanges();
   return { content, segment, buffered, segmentData };

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

@@ -41,7 +41,7 @@ import appendSegmentToBuffer from "./append_segment_to_buffer";
 export default async function pushMediaSegment<T>(
   { playbackObserver,
     content,
-    initSegmentData,
+    initSegmentUniqueId,
     parsedSegment,
     segment,
     segmentBuffer } :
@@ -52,7 +52,7 @@ export default async function pushMediaSegment<T>(
                manifest : Manifest;
                period : Period;
                representation : Representation; };
-    initSegmentData : T | null;
+    initSegmentUniqueId : string | null;
     parsedSegment : ISegmentParserParsedMediaChunk<T>;
     segment : ISegment;
     segmentBuffer : SegmentBuffer; },
@@ -83,7 +83,7 @@ export default async function pushMediaSegment<T>(
       undefined,
   ];
 
-  const data = { initSegment: initSegmentData,
+  const data = { initSegmentUniqueId,
                  chunk: chunkData,
                  timestampOffset: chunkOffset,
                  appendWindow: safeAppendWindow,