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

package/src/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.ts

@@ -21,11 +21,8 @@ import {
 import config from "../../../../config";
 import log from "../../../../log";
 import { getLoggableSegmentId } from "../../../../manifest";
-import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
-import { toUint8Array } from "../../../../utils/byte_parsing";
 import createCancellablePromise from "../../../../utils/create_cancellable_promise";
-import hashBuffer from "../../../../utils/hash_buffer";
 import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
 import TaskCanceller, {
@@ -139,20 +136,26 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
   private _pendingTask : IAVSBPendingTask | null;
 
   /**
-   * Keep track of the of the latest init segment pushed in the linked
-   * SourceBuffer.
+   * Keep track of the unique identifier of the  of the latest init segment
+   * pushed to the linked SourceBuffer.
    *
-   * This allows to be sure the right initialization segment is pushed before
-   * any chunk is.
+   * Such identifiers are first declared through the `declareInitSegment`
+   * method and the corresponding initialization segment is then pushed through
+   * the `pushChunk` method.
+   *
+   * Keeping track of this allows to be sure the right initialization segment is
+   * pushed before any chunk is.
    *
    * `null` if no initialization segment have been pushed to the
    * `AudioVideoSegmentBuffer` yet.
    */
-  private _lastInitSegment : { /** The init segment itself. */
-                               data : Uint8Array;
-                               /** Hash of the initSegment for fast comparison */
-                               hash : number; } |
-                             null;
+  private _lastInitSegmentUniqueId : string | null;
+
+  /**
+   * Link unique identifiers for initialization segments (as communicated by
+   * `declareInitSegment`) to the corresponding initialization data.
+   */
+  private _initSegmentsMap : Map<string, BufferSource>;
 
   /**
    * @constructor
@@ -174,8 +177,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     this._sourceBuffer = sourceBuffer;
     this._queue = [];
     this._pendingTask = null;
-    this._lastInitSegment = null;
+    this._lastInitSegmentUniqueId = null;
     this.codec = codec;
+    this._initSegmentsMap = new Map();
 
     const onError = this._onPendingTaskError.bind(this);
     const reCheck = this._flush.bind(this);
@@ -198,6 +202,20 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     });
   }
 
+  public declareInitSegment(
+    uniqueId : string,
+    initSegmentData : unknown
+  ) : void {
+    assertDataIsBufferSource(initSegmentData);
+    this._initSegmentsMap.set(uniqueId, initSegmentData);
+  }
+
+  public freeInitSegment(
+    uniqueId : string
+  ) : void {
+    this._initSegmentsMap.delete(uniqueId);
+  }
+
   /**
    * Push a chunk of the media segment given to the attached SourceBuffer, in a
    * FIFO queue.
@@ -229,12 +247,12 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     infos : IPushChunkInfos<unknown>,
     cancellationSignal : CancellationSignal
   ) : Promise<void> {
-    assertPushedDataIsBufferSource(infos);
+    assertDataIsBufferSource(infos.data.chunk);
     log.debug("AVSB: receiving order to push data to the SourceBuffer",
               this.bufferType,
               getLoggableSegmentId(infos.inventoryInfos));
     return this._addToQueue({ type: SegmentBufferOperation.Push,
-                              value: infos },
+                              value: infos as IPushChunkInfos<BufferSource> },
                             cancellationSignal);
   }
 
@@ -350,7 +368,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
    * @param {Event} err
    */
   private _onPendingTaskError(err : unknown) : void {
-    this._lastInitSegment = null; // initialize init segment as a security
+    this._lastInitSegmentUniqueId = null; // initialize init segment as a security
     if (this._pendingTask !== null) {
       const error = err instanceof Error ?
                       err :
@@ -447,7 +465,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
           const error = e instanceof Error ?
             e :
             new Error("An unknown error occured when preparing a push operation");
-          this._lastInitSegment = null; // initialize init segment as a security
+          this._lastInitSegmentUniqueId = null; // initialize init segment as a security
           nextItem.reject(error);
           return;
         }
@@ -557,15 +575,17 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
       this._sourceBuffer.appendWindowEnd = appendWindow[1];
     }
 
-    if (data.initSegment !== null &&
-        (hasUpdatedSourceBufferType || !this._isLastInitSegment(data.initSegment)))
+    if (data.initSegmentUniqueId !== null &&
+        (hasUpdatedSourceBufferType ||
+         !this._isLastInitSegment(data.initSegmentUniqueId)))
     {
       // Push initialization segment before the media segment
-      const segmentData = data.initSegment;
+      const segmentData = this._initSegmentsMap.get(data.initSegmentUniqueId);
+      if (segmentData === undefined) {
+        throw new Error("Invalid initialization segment uniqueId");
+      }
       dataToPush.push(segmentData);
-      const initU8 = toUint8Array(segmentData);
-      this._lastInitSegment = { data: initU8,
-                                hash: hashBuffer(initU8) };
+      this._lastInitSegmentUniqueId = data.initSegmentUniqueId;
     }
 
     if (data.chunk !== null) {
@@ -576,28 +596,16 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
   }
 
  /**
-  * Return `true` if the given `segmentData` is the same segment than the last
+  * Return `true` if the given `uniqueId` is the identifier of the last
   * initialization segment pushed to the `AudioVideoSegmentBuffer`.
-  * @param {BufferSource} segmentData
+  * @param {string} uniqueId
   * @returns {boolean}
   */
-  private _isLastInitSegment(segmentData : BufferSource) : boolean {
-    if (this._lastInitSegment === null) {
+  private _isLastInitSegment(uniqueId : string) : boolean {
+    if (this._lastInitSegmentUniqueId === null) {
       return false;
     }
-    if (this._lastInitSegment.data === segmentData) {
-      return true;
-    }
-    const oldInit = this._lastInitSegment.data;
-    if (oldInit.byteLength === segmentData.byteLength) {
-      const newInitU8 = toUint8Array(segmentData);
-      if (hashBuffer(newInitU8) === this._lastInitSegment.hash &&
-          areArraysOfNumbersEqual(oldInit, newInitU8))
-      {
-        return true;
-      }
-    }
-    return false;
+    return this._lastInitSegmentUniqueId === uniqueId;
   }
 }
 
@@ -605,27 +613,20 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is
  * difficult to enforce.
- * @param {Object} pushedData
+ * @param {Object} data
  */
-function assertPushedDataIsBufferSource(
-  pushedData : IPushChunkInfos<unknown>
-) : asserts pushedData is IPushChunkInfos<BufferSource> {
+function assertDataIsBufferSource(
+  data : unknown
+) : asserts data is BufferSource {
   if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
-  const { chunk, initSegment } = pushedData.data;
   if (
-    typeof chunk !== "object" ||
-    typeof initSegment !== "object" ||
-    (
-      chunk !== null &&
-      !(chunk instanceof ArrayBuffer) &&
-      !((chunk as ArrayBufferView).buffer instanceof ArrayBuffer)
-    ) ||
+    typeof data !== "object" ||
     (
-      initSegment !== null &&
-      !(initSegment instanceof ArrayBuffer) &&
-      !((initSegment as ArrayBufferView).buffer instanceof ArrayBuffer)
+      data !== null &&
+      !(data instanceof ArrayBuffer) &&
+      !((data as ArrayBufferView).buffer instanceof ArrayBuffer)
     )
   ) {
     throw new Error("Invalid data given to the AudioVideoSegmentBuffer");

package/src/core/segment_buffers/implementations/text/html/html_text_segment_buffer.ts

@@ -137,6 +137,22 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     this.autoRefreshSubtitles(this._canceller.signal);
   }
 
+  /**
+   * @param {string} uniqueId
+   */
+  public declareInitSegment(uniqueId : string): void {
+    log.warn("ISB: Declaring initialization segment for image SegmentBuffer",
+             uniqueId);
+  }
+
+  /**
+   * @param {string} uniqueId
+   */
+  public freeInitSegment(uniqueId : string): void {
+    log.warn("ISB: Freeing initialization segment for image SegmentBuffer",
+             uniqueId);
+  }
+
   /**
    * Push text segment to the HTMLTextSegmentBuffer.
    * @param {Object} infos

package/src/core/segment_buffers/implementations/text/native/native_text_segment_buffer.ts

@@ -61,6 +61,22 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
     this._trackElement = trackElement;
   }
 
+  /**
+   * @param {string} uniqueId
+   */
+  public declareInitSegment(uniqueId : string): void {
+    log.warn("ISB: Declaring initialization segment for image SegmentBuffer",
+             uniqueId);
+  }
+
+  /**
+   * @param {string} uniqueId
+   */
+  public freeInitSegment(uniqueId : string): void {
+    log.warn("ISB: Freeing initialization segment for image SegmentBuffer",
+             uniqueId);
+  }
+
   /**
    * @param {Object} infos
    * @returns {Promise}

package/src/core/segment_buffers/implementations/types.ts

@@ -87,6 +87,13 @@ export abstract class SegmentBuffer {
     this._segmentInventory = new SegmentInventory();
   }
 
+  public abstract declareInitSegment(
+    uniqueId : string,
+    initSegmentData : unknown
+  ) : void;
+
+  public abstract freeInitSegment(uniqueId : string) : void;
+
   /**
    * Push a chunk of the media segment given to the attached buffer, in a
    * FIFO queue.
@@ -96,7 +103,8 @@ export abstract class SegmentBuffer {
    * pushed.
    *
    * Depending on the type of data appended, the pushed chunk might rely on an
-   * initialization segment, given through the `data.initSegment` property.
+   * initialization segment, which had to be previously declared through the
+   * `declareInitSegment` method.
    *
    * Such initialization segment will be first pushed to the buffer if the
    * last pushed segment was associated to another initialization segment.
@@ -106,7 +114,7 @@ export abstract class SegmentBuffer {
    * reference).
    *
    * If you don't need any initialization segment to push the wanted chunk, you
-   * can just set `data.initSegment` to `null`.
+   * can just set the corresponding property to `null`.
    *
    * You can also only push an initialization segment by setting the
    * `data.chunk` argument to null.
@@ -229,12 +237,16 @@ export type IBufferType = "audio" |
  */
 export interface IPushedChunkData<T> {
   /**
-   * The whole initialization segment's data related to the chunk you want to
+   * The `uniqueId` of the initialization segment linked to the data you want to
    * push.
+   *
+   * That identifier should previously have been declared through the
+   * `declareInitSegment` method and not freed.
+   *
    * To set to `null` either if no initialization data is needed, or if you are
    * confident that the last pushed one is compatible.
    */
-  initSegment: T | null;
+  initSegmentUniqueId : string | null;
   /**
    * Chunk you want to push.
    * This can be the whole decodable segment's data or just a decodable sub-part

package/src/core/segment_buffers/index.ts

@@ -30,6 +30,7 @@ import {
 import {
   IBufferedChunk,
   IChunkContext,
+  IInsertedChunkInfos,
   getFirstSegmentAfterPeriod,
   getLastSegmentBeforePeriod,
 } from "./inventory";
@@ -51,6 +52,7 @@ export {
 
   IBufferedChunk,
   IChunkContext,
+  IInsertedChunkInfos,
 
   IPushChunkInfos,
   IPushedChunkData,

package/src/core/stream/adaptation/utils/create_representation_estimator.ts

@@ -0,0 +1,114 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { MediaError } from "../../../../errors";
+import Manifest, {
+  Adaptation,
+  Period,
+  Representation,
+} from "../../../../manifest";
+import { IPlayerError } from "../../../../public_types";
+import createSharedReference, {
+  IReadOnlySharedReference,
+} from "../../../../utils/reference";
+import { CancellationSignal } from "../../../../utils/task_canceller";
+import {
+  IABREstimate,
+  IRepresentationEstimatorPlaybackObservation,
+  IRepresentationEstimator,
+  IRepresentationEstimatorCallbacks,
+} from "../../../adaptive";
+import { IReadOnlyPlaybackObserver } from "../../../api";
+
+/**
+ * Produce estimates to know which Representation should be played.
+ * @param {Object} content - The Manifest, Period and Adaptation wanted.
+ * @param {Object} representationEstimator - `IRepresentationEstimator` which
+ * will produce Representation estimates.
+ * @param {Object} currentRepresentation - Reference emitting the
+ * currently-loaded Representation.
+ * @param {Object} playbackObserver - Allows to observe the current playback
+ * conditions.
+ * @param {Function} onFatalError - Callback called when a fatal error was
+ * thrown. Once this callback is called, no estimate will be produced.
+ * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
+ * the production of estimates (and clean-up all linked resources).
+ * @returns {Object} - Returns an object with the following properties:
+ *   - `estimateRef`: Reference emitting the last estimate
+ *   - `abrCallbacks`: Callbacks allowing to report back network and playback
+ *     activities to improve the estimates given.
+ */
+export default function getRepresentationEstimate(
+  content : { manifest : Manifest;
+              period : Period;
+              adaptation : Adaptation; },
+  representationEstimator : IRepresentationEstimator,
+  currentRepresentation : IReadOnlySharedReference<Representation | null>,
+  playbackObserver : IReadOnlyPlaybackObserver<
+    IRepresentationEstimatorPlaybackObservation
+  >,
+  onFatalError: (err : IPlayerError) => void,
+  cancellationSignal : CancellationSignal
+) : { estimateRef : IReadOnlySharedReference<IABREstimate>;
+      abrCallbacks : IRepresentationEstimatorCallbacks; }
+{
+  const { manifest, adaptation } = content;
+  const representations = createSharedReference<Representation[]>(
+    [],
+    cancellationSignal);
+  updateRepresentationsReference();
+  manifest.addEventListener("decipherabilityUpdate", updateRepresentationsReference);
+  const unregisterCleanUp = cancellationSignal.register(cleanUp);
+  const { estimates: estimateRef,
+          callbacks: abrCallbacks } = representationEstimator(content,
+                                                              currentRepresentation,
+                                                              representations,
+                                                              playbackObserver,
+                                                              cancellationSignal);
+  return { abrCallbacks, estimateRef };
+
+  function updateRepresentationsReference() : void {
+    /** Representations for which a `RepresentationStream` can be created. */
+    const newRepr = adaptation.getPlayableRepresentations();
+    if (newRepr.length === 0) {
+      const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION",
+                                      "No Representation in the chosen " +
+                                      adaptation.type + " Adaptation can be played",
+                                      { adaptation });
+      cleanUp();
+      onFatalError(noRepErr);
+      return;
+    }
+
+    const prevRepr = representations.getValue();
+    if (prevRepr.length === newRepr.length) {
+      if (prevRepr.every((r, idx) => r.id === newRepr[idx].id)) {
+        return ;
+      }
+    }
+    representations.setValue(newRepr);
+  }
+
+  /** Clean-up all resources taken here. */
+  function cleanUp() : void {
+    manifest.removeEventListener("decipherabilityUpdate", updateRepresentationsReference);
+
+    // check to protect against the case where it is not yet defined.
+    if (typeof unregisterCleanUp !== "undefined") {
+      unregisterCleanUp();
+    }
+  }
+}

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

@@ -201,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);
       });
@@ -465,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
@@ -502,9 +506,13 @@ 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 });

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

@@ -372,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

@@ -109,11 +109,17 @@ export default function RepresentationStream<TSegmentDataType>(
   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;
   }
 
@@ -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.
@@ -412,10 +423,10 @@ export default function RepresentationStream<TSegmentDataType>(
         }
       }
 
-      const initSegmentData = initSegmentState.segmentData;
+      const initSegmentUniqueId = initSegmentState.uniqueId;
       pushMediaSegment({ playbackObserver,
                          content,
-                         initSegmentData,
+                         initSegmentUniqueId,
                          parsedSegment: evt,
                          segment: evt.segment,
                          segmentBuffer },
@@ -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,7 +42,7 @@ 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 {
@@ -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 });
     }
   }
 }