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

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import nextTick from "next-tick";
 import config from "../../../config";
 import {
   formatError,
@@ -25,8 +26,8 @@ import {
   Period,
 } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
-import { getLeftSizeOfRange } from "../../../utils/ranges";
-import createSharedReference, {
+import { getLeftSizeOfBufferedTimeRange } from "../../../utils/ranges";
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, {
@@ -45,7 +46,6 @@ import AdaptationStream, {
   IAdaptationStreamPlaybackObservation,
 } from "../adaptation";
 import { IRepresentationsChoice } from "../representation";
-import createReloadRequest from "../utils/create_reload_request";
 import {
   IPeriodStreamArguments,
   IPeriodStreamCallbacks,
@@ -105,7 +105,7 @@ export default function PeriodStream(
    * `null` when no Adaptation is chosen (e.g. no subtitles)
    * `undefined` at the beginning (it can be ignored.).
    */
-  const adaptationRef = createSharedReference<IAdaptationChoice|null|undefined>(
+  const adaptationRef = new SharedReference<IAdaptationChoice|null|undefined>(
     undefined,
     parentCancelSignal
   );
@@ -136,10 +136,7 @@ export default function PeriodStream(
         if (segmentBufferStatus.type === "initialized") {
           log.info(`Stream: Clearing previous ${bufferType} SegmentBuffer`);
           if (SegmentBuffersStore.isNative(bufferType)) {
-            return createReloadRequest(playbackObserver, ({ position, autoPlay }) => {
-              callbacks
-                .waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-            }, 0, period, streamCanceller.signal);
+            return askForMediaSourceReload(0, true, streamCanceller.signal);
           } else {
             const periodEnd = period.end ?? Infinity;
             if (period.start > periodEnd) {
@@ -191,9 +188,9 @@ export default function PeriodStream(
       if (SegmentBuffersStore.isNative(bufferType) &&
           segmentBuffersStore.getStatus(bufferType).type === "disabled")
       {
-        return createReloadRequest(playbackObserver, ({ position, autoPlay }) => {
-          callbacks.waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-        }, relativePosAfterSwitch, period, streamCanceller.signal);
+        return askForMediaSourceReload(relativePosAfterSwitch,
+                                       true,
+                                       streamCanceller.signal);
       }
 
       // Reload if the Adaptation disappears from the manifest
@@ -203,10 +200,9 @@ export default function PeriodStream(
           if (element.period.id === period.id) {
             for (const adap of element.result.removedAdaptations) {
               if (adap.id === adaptation.id) {
-                return createReloadRequest(playbackObserver, ({ position, autoPlay }) => {
-                  callbacks
-                    .waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-                }, relativePosAfterSwitch, period, streamCanceller.signal);
+                return askForMediaSourceReload(relativePosAfterSwitch,
+                                               true,
+                                               streamCanceller.signal);
               }
             }
           } else if (element.period.start > period.start) {
@@ -239,9 +235,9 @@ export default function PeriodStream(
                                                    playbackInfos,
                                                    options);
       if (strategy.type === "needs-reload") {
-        return createReloadRequest(playbackObserver, ({ position, autoPlay }) => {
-          callbacks.waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-        }, relativePosAfterSwitch, period, streamCanceller.signal);
+        return askForMediaSourceReload(relativePosAfterSwitch,
+                                       true,
+                                       streamCanceller.signal);
       }
 
       await segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal);
@@ -336,6 +332,48 @@ export default function PeriodStream(
       callbacks.error(error);
     }
   }
+
+  /**
+   * Regularly ask to reload the MediaSource on each playback observation
+   * performed by the playback observer.
+   *
+   * @param {number} timeOffset - Relative position, compared to the current
+   * playhead, at which we should restart playback after reloading.
+   * For example `-2` will reload 2 seconds before the current position.
+   * @param {boolean} stayInPeriod - If `true`, we will control that the position
+   * we reload at, after applying `timeOffset`, is still part of the Period
+   * `period`.
+   *
+   * If it isn't we will re-calculate that reloaded position to be:
+   *   - either the Period's start if the calculated position is before the
+   *     Period's start.
+   *   - either the Period'end start if the calculated position is after the
+   *     Period's end.
+   * @param {Object} cancelSignal
+   */
+  function askForMediaSourceReload(
+    timeOffset : number,
+    stayInPeriod: boolean,
+    cancelSignal : CancellationSignal
+  ) : void {
+    // We begin by scheduling a micro-task to reduce the possibility of race
+    // conditions where `askForMediaSourceReload` would be called synchronously before
+    // the next observation (which may reflect very different playback conditions)
+    // is actually received.
+    // It can happen when `askForMediaSourceReload` is called as a side-effect of
+    // the same event that triggers the playback observation to be emitted.
+    nextTick(() => {
+      playbackObserver.listen(() => {
+        if (cancelSignal.isCancelled()) {
+          return;
+        }
+        callbacks.waitingMediaSourceReload({ bufferType,
+                                             period,
+                                             timeOffset,
+                                             stayInPeriod });
+      }, { includeLastObservation: true, clearSignal: cancelSignal });
+    });
+  }
 }
 
 /**
@@ -373,7 +411,7 @@ function getFirstDeclaredMimeType(adaptation : Adaptation) : string {
     const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION",
                                     "No Representation in the chosen " +
                                     adaptation.type + " Adaptation can be played",
-                                    { adaptation });
+                                    { adaptations: [adaptation] });
     throw noRepErr;
   }
   return representations[0].getMimeTypeString();
@@ -393,8 +431,8 @@ function createAdaptationStreamPlaybackObserver(
     observationRef : IReadOnlySharedReference<IPeriodStreamPlaybackObservation>,
     cancellationSignal : CancellationSignal
   ) : IReadOnlySharedReference<IAdaptationStreamPlaybackObservation> {
-    const newRef = createSharedReference(constructAdaptationStreamPlaybackObservation(),
-                                         cancellationSignal);
+    const newRef = new SharedReference(constructAdaptationStreamPlaybackObservation(),
+                                       cancellationSignal);
 
     observationRef.onUpdate(emitAdaptationStreamPlaybackObservation, {
       clearSignal: cancellationSignal,
@@ -406,7 +444,8 @@ function createAdaptationStreamPlaybackObserver(
     ) : IAdaptationStreamPlaybackObservation {
       const baseObservation = observationRef.getValue();
       const buffered = segmentBuffer.getBufferedRanges();
-      const bufferGap = getLeftSizeOfRange(buffered, baseObservation.position.last);
+      const bufferGap = getLeftSizeOfBufferedTimeRange(buffered,
+                                                       baseObservation.position.last);
       return objectAssign({}, baseObservation, { bufferGap });
     }
 
@@ -433,7 +472,7 @@ function createEmptyAdaptationStream(
   wantedBufferAhead : IReadOnlySharedReference<number>,
   bufferType : IBufferType,
   content : { period : Period },
-  callbacks : Pick<IAdaptationStreamCallbacks<unknown>, "streamStatusUpdate">,
+  callbacks : Pick<IAdaptationStreamCallbacks, "streamStatusUpdate">,
   cancelSignal : CancellationSignal
 ) : void {
   const { period } = content;

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

@@ -2,7 +2,9 @@ import Manifest, {
   Adaptation,
   Period,
 } from "../../../manifest";
-import { IReadOnlySharedReference, ISharedReference } from "../../../utils/reference";
+import SharedReference, {
+  IReadOnlySharedReference,
+} from "../../../utils/reference";
 import { CancellationSignal } from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
@@ -23,7 +25,7 @@ import { IPositionPlaybackObservation } from "../representation";
 
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IPeriodStreamCallbacks extends
-  IAdaptationStreamCallbacks<unknown>
+  IAdaptationStreamCallbacks
 {
   /**
    * Called when a new `PeriodStream` is ready to start but needs an Adaptation
@@ -70,7 +72,7 @@ export interface IPeriodStreamReadyPayload {
    * It is set to `undefined` by default, you SHOULD NOT set it to `undefined`
    * yourself.
    */
-  adaptationRef : ISharedReference<IAdaptationChoice|null|undefined>;
+  adaptationRef : SharedReference<IAdaptationChoice|null|undefined>;
 }
 
 /** Playback observation required by the `PeriodStream`. */

package/src/core/stream/period/utils/get_adaptation_switch_strategy.ts

@@ -37,9 +37,19 @@ import {
 import { ITrackSwitchingMode } from "../../adaptation";
 
 export type IAdaptationSwitchStrategy =
+  /** Do nothing special. */
   { type: "continue"; value: undefined } |
+  /**
+   * Clean the given ranges of time from the buffer, preferably avoiding time
+   * around the current position to continue playback smoothly.
+   */
   { type: "clean-buffer"; value: Array<{ start: number; end: number }> } |
+  /**
+   * Clean the given ranges of time from the buffer and try to flush the buffer
+   * so that it is taken in account directly.
+   */
   { type: "flush-buffer"; value: Array<{ start: number; end: number }> } |
+  /** Reload completely the media buffers. */
   { type: "needs-reload"; value: undefined };
 
 export interface IAdaptationSwitchOptions {

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

@@ -27,7 +27,7 @@ import config from "../../../config";
 import log from "../../../log";
 import { ISegment } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
-import { createSharedReference } from "../../../utils/reference";
+import SharedReference from "../../../utils/reference";
 import TaskCanceller, {
   CancellationError,
   CancellationSignal,
@@ -89,7 +89,7 @@ export default function RepresentationStream<TSegmentDataType>(
     segmentBuffer,
     segmentFetcher,
     terminate } : IRepresentationStreamArguments<TSegmentDataType>,
-  callbacks : IRepresentationStreamCallbacks<TSegmentDataType>,
+  callbacks : IRepresentationStreamCallbacks,
   parentCancelSignal : CancellationSignal
 ) : void {
   const { period, adaptation, representation } = content;
@@ -122,7 +122,7 @@ export default function RepresentationStream<TSegmentDataType>(
   });
 
   /** Emit the last scheduled downloading queue for segments. */
-  const lastSegmentQueue = createSharedReference<IDownloadQueueItem>({
+  const lastSegmentQueue = new SharedReference<IDownloadQueueItem>({
     initSegment: null,
     segmentQueue: [],
   }, segmentsLoadingCanceller.signal);
@@ -202,6 +202,9 @@ export default function RepresentationStream<TSegmentDataType>(
     includeLastObservation: false,
     clearSignal: segmentsLoadingCanceller.signal,
   });
+  content.manifest.addEventListener("manifestUpdate",
+                                    checkStatus,
+                                    segmentsLoadingCanceller.signal);
   bufferGoal.onUpdate(checkStatus, {
     emitCurrentValue: false,
     clearSignal: segmentsLoadingCanceller.signal ,

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

@@ -20,7 +20,7 @@ import {
 } from "../../segment_buffers";
 
 /** Callbacks called by the `RepresentationStream` on various events. */
-export interface IRepresentationStreamCallbacks<TSegmentDataType> {
+export interface IRepresentationStreamCallbacks {
   /**
    * Called to announce the current status regarding the buffer for its
    * associated Period and type (e.g. "audio", "video", "text" etc.).
@@ -30,7 +30,7 @@ export interface IRepresentationStreamCallbacks<TSegmentDataType> {
    */
   streamStatusUpdate(payload : IStreamStatusPayload) : void;
   /** Called after a new segment has been succesfully added to the SegmentBuffer */
-  addedSegment(payload : IStreamEventAddedSegmentPayload<TSegmentDataType>) : void;
+  addedSegment(payload : IStreamEventAddedSegmentPayload) : void;
   /** Called when a segment with protection information has been encountered. */
   encryptionDataEncountered(payload : IContentProtection[]) : void;
   /**
@@ -127,7 +127,7 @@ export interface IStreamStatusPayload {
 }
 
 /** Payload for the `addedSegment` callback. */
-export interface IStreamEventAddedSegmentPayload<T> {
+export interface IStreamEventAddedSegmentPayload {
   /** Context about the content that has been added. */
   content: { period : Period;
              adaptation : Adaptation;
@@ -136,8 +136,6 @@ export interface IStreamEventAddedSegmentPayload<T> {
   segment : ISegment;
   /** TimeRanges of the concerned SegmentBuffer after the segment was pushed. */
   buffered : TimeRanges;
-  /* The data pushed */
-  segmentData : T;
 }
 
 /** Structure describing an "inband" event, as found in a media segment. */
@@ -303,6 +301,8 @@ export interface IRepresentationsChoice {
    * How the Streams should react if another, not currently authorized,
    * Representation was previously playing.
    */
+  /* eslint-disable @typescript-eslint/no-duplicate-type-constituents */
   switchingMode : IVideoRepresentationsSwitchingMode |
                   IAudioRepresentationsSwitchingMode;
+  /* eslint-enable @typescript-eslint/no-duplicate-type-constituents */
 }

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

@@ -58,7 +58,7 @@ export default async function appendSegmentToBuffer<T>(
         "An unknown error happened when pushing content";
       throw new MediaError("BUFFER_APPEND_ERROR",
                            reason,
-                           { adaptation: dataInfos.inventoryInfos.adaptation });
+                           { adaptations: [dataInfos.inventoryInfos.adaptation] });
     }
     const { position } = playbackObserver.getReference().getValue();
     const currentPos = position.pending ?? position.last;
@@ -71,7 +71,7 @@ export default async function appendSegmentToBuffer<T>(
 
       throw new MediaError("BUFFER_FULL_ERROR",
                            reason,
-                           { adaptation: dataInfos.inventoryInfos.adaptation });
+                           { adaptations: [dataInfos.inventoryInfos.adaptation] });
     }
   }
 }

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

@@ -30,9 +30,8 @@ import assert from "../../../../utils/assert";
 import EventEmitter from "../../../../utils/event_emitter";
 import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
-  ISharedReference,
 } from "../../../../utils/reference";
 import TaskCanceller from "../../../../utils/task_canceller";
 import { IPrioritizedSegmentFetcher } from "../../../fetchers";
@@ -80,7 +79,7 @@ export default class DownloadingQueue<T>
    * `undefined` when this is not yet known.
    * `null` when no initialization segment or timescale exists.
    */
-  private _initSegmentInfoRef : ISharedReference<number | undefined | null>;
+  private _initSegmentInfoRef : SharedReference<number | undefined | null>;
   /**
    * Some media segment might have been loaded and are only awaiting for the
    * initialization segment to be parsed before being parsed themselves.
@@ -123,7 +122,7 @@ export default class DownloadingQueue<T>
     this._initSegmentRequest = null;
     this._mediaSegmentRequest = null;
     this._segmentFetcher = segmentFetcher;
-    this._initSegmentInfoRef = createSharedReference(undefined);
+    this._initSegmentInfoRef = new SharedReference<number | undefined | null>(undefined);
     this._mediaSegmentAwaitingInitMetadata = null;
     if (!hasInitSegment) {
       this._initSegmentInfoRef.setValue(null);
@@ -509,7 +508,7 @@ export interface IDownloadingQueueEvent<T> {
    * multiple `IParsedSegmentEvent` for a single segment, if that segment is
    * divided into multiple decodable chunks.
    * You will know that all `IParsedSegmentEvent` have been loaded for a given
-   * segment once you received the `IEndOfSegmentEvent` for that segment.
+   * segment once you received the corresponding event.
    */
   parsedMediaSegment : IParsedSegmentPayload<T>;
   /** Notify that a media or initialization segment has been fully-loaded. */

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

@@ -16,7 +16,7 @@
 
 import config from "../../../../config";
 import log from "../../../../log";
-import { getInnerAndOuterTimeRanges } from "../../../../utils/ranges";
+import { getInnerAndOuterRangesFromBufferedTimeRanges } from "../../../../utils/ranges";
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { SegmentBuffer } from "../../../segment_buffers";
 
@@ -78,8 +78,8 @@ function selectGCedRanges(
   buffered : TimeRanges,
   gcGap : number
 ) : Array<{ start : number; end : number }> {
-  const { innerRange, outerRanges } = getInnerAndOuterTimeRanges(buffered,
-                                                                 position);
+  const { innerRange, outerRanges } =
+    getInnerAndOuterRangesFromBufferedTimeRanges(buffered, position);
   const cleanedupRanges : Array<{ start : number;
                                   end: number; }> = [];
 

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

@@ -22,7 +22,7 @@ import Manifest, {
 } from "../../../../manifest";
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import { IReadOnlyPlaybackObserver } from "../../../api";
-import {
+import SegmentBuffersStore, {
   IBufferedChunk,
   IEndOfSegmentOperation,
   SegmentBuffer,
@@ -218,6 +218,7 @@ function getRangeOfNeededSegments(
   // avoid ending the last Period - and by extension the content - with a
   // segment which isn't the last one.
   if (!isNullOrUndefined(lastIndexPosition) &&
+      SegmentBuffersStore.isNative(content.adaptation.type) &&
       initialWantedTime >= lastIndexPosition &&
       representationIndex.isInitialized() &&
       representationIndex.isFinished() &&

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

@@ -45,7 +45,6 @@ export default async function pushInitSegment<T>(
     content,
     initSegmentUniqueId,
     segment,
-    segmentData,
     segmentBuffer,
   } : {
     playbackObserver : IReadOnlyPlaybackObserver<
@@ -61,7 +60,7 @@ export default async function pushInitSegment<T>(
     segmentBuffer : SegmentBuffer;
   },
   cancelSignal : CancellationSignal
-) : Promise< IStreamEventAddedSegmentPayload<T> | null > {
+) : Promise< IStreamEventAddedSegmentPayload | null > {
   if (cancelSignal.cancellationError !== null) {
     throw cancelSignal.cancellationError;
   }
@@ -81,5 +80,5 @@ export default async function pushInitSegment<T>(
                               { data, inventoryInfos },
                               cancelSignal);
   const buffered = segmentBuffer.getBufferedRanges();
-  return { content, segment, buffered, segmentData };
+  return { content, segment, buffered };
 }

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

@@ -57,7 +57,7 @@ export default async function pushMediaSegment<T>(
     segment : ISegment;
     segmentBuffer : SegmentBuffer; },
   cancelSignal : CancellationSignal
-) : Promise< IStreamEventAddedSegmentPayload<T> | null > {
+) : Promise< IStreamEventAddedSegmentPayload | null > {
   if (parsedSegment.chunkData === null) {
     return null;
   }
@@ -109,5 +109,5 @@ export default async function pushMediaSegment<T>(
                               { data, inventoryInfos },
                               cancelSignal);
   const buffered = segmentBuffer.getBufferedRanges();
-  return { content, segment, buffered, segmentData: chunkData };
+  return { content, segment, buffered };
 }

package/src/errors/__tests__/encrypted_media_error.test.ts

@@ -26,7 +26,7 @@ describe("errors - EncryptedMediaError", () => {
     expect(encryptedMediaError.code).toBe("KEY_LOAD_TIMEOUT");
     expect(encryptedMediaError.fatal).toBe(false);
     expect(encryptedMediaError.message)
-      .toBe("EncryptedMediaError (KEY_LOAD_TIMEOUT) test");
+      .toBe("KEY_LOAD_TIMEOUT: test");
   });
 
   it("should be able to set it as fatal", () => {
@@ -40,6 +40,6 @@ describe("errors - EncryptedMediaError", () => {
     expect(encryptedMediaError.code).toBe("INCOMPATIBLE_KEYSYSTEMS");
     expect(encryptedMediaError.fatal).toBe(true);
     expect(encryptedMediaError.message)
-      .toBe("EncryptedMediaError (INCOMPATIBLE_KEYSYSTEMS) test");
+      .toBe("INCOMPATIBLE_KEYSYSTEMS: test");
   });
 });

package/src/errors/__tests__/error_message.test.ts

@@ -18,6 +18,6 @@ import errorMessage from "../error_message";
 
 describe("Errors - generateErrorMessage", () => {
   it("should format a readable error message", () => {
-    expect(errorMessage("foo", "bar", "baz")).toBe("foo (bar) baz");
+    expect(errorMessage("bar", "baz")).toBe("bar: baz");
   });
 });

package/src/errors/__tests__/format_error.test.ts

@@ -43,7 +43,7 @@ describe("errors - formatError", () => {
     const formattedError = formatError(error1, { defaultCode: "toto",
                                                  defaultReason: "a" });
     expect(formattedError).toBeInstanceOf(OtherError);
-    expect(formattedError.message).toBe("OtherError (toto) Error: Abcdef");
+    expect(formattedError.message).toBe("toto: Error: Abcdef");
     expect(formattedError.code).toBe("toto");
   });
 
@@ -56,7 +56,7 @@ describe("errors - formatError", () => {
     const formattedError = formatError(error1, { defaultCode: "toto",
                                                  defaultReason: "a" });
     expect(formattedError).toBeInstanceOf(OtherError);
-    expect(formattedError.message).toBe("OtherError (toto) a");
+    expect(formattedError.message).toBe("toto: a");
     expect(formattedError.code).toBe("toto");
   });
 });

package/src/errors/__tests__/media_error.test.ts

@@ -25,7 +25,7 @@ describe("errors - MediaError", () => {
     expect(mediaError.type).toBe("MEDIA_ERROR");
     expect(mediaError.code).toBe("MEDIA_TIME_BEFORE_MANIFEST");
     expect(mediaError.fatal).toBe(false);
-    expect(mediaError.message).toBe("MediaError (MEDIA_TIME_BEFORE_MANIFEST) test");
+    expect(mediaError.message).toBe("MEDIA_TIME_BEFORE_MANIFEST: test");
   });
 
   it("should be able to set it as fatal", () => {
@@ -37,7 +37,7 @@ describe("errors - MediaError", () => {
     expect(mediaError.type).toBe("MEDIA_ERROR");
     expect(mediaError.code).toBe("MEDIA_TIME_AFTER_MANIFEST");
     expect(mediaError.fatal).toBe(true);
-    expect(mediaError.message).toBe("MediaError (MEDIA_TIME_AFTER_MANIFEST) test");
+    expect(mediaError.message).toBe("MEDIA_TIME_AFTER_MANIFEST: test");
   });
 
   it("should filter in a valid error code", () => {
@@ -50,6 +50,6 @@ describe("errors - MediaError", () => {
     expect(mediaError.type).toBe("MEDIA_ERROR");
     expect(mediaError.code).toBe("MEDIA_ERR_NETWORK");
     expect(mediaError.fatal).toBe(true);
-    expect(mediaError.message).toBe("MediaError (MEDIA_ERR_NETWORK) test");
+    expect(mediaError.message).toBe("MEDIA_ERR_NETWORK: test");
   });
 });

package/src/errors/__tests__/network_error.test.ts

@@ -19,32 +19,33 @@ import RequestError from "../request_error";
 
 describe("errors - NetworkError", () => {
   it("should be able to use a RequestError", () => {
-    const requestError = new RequestError("foo", 12, "TIMEOUT");
+    const requestError = new RequestError("foo", 0, "TIMEOUT");
     const networkError = new NetworkError("PIPELINE_LOAD_ERROR", requestError);
     expect(networkError).toBeInstanceOf(Error);
     expect(networkError.name).toBe("NetworkError");
     expect(networkError.type).toBe("NETWORK_ERROR");
-    expect(networkError.status).toBe(12);
+    expect(networkError.status).toBe(0);
     expect(networkError.errorType).toBe(requestError.type);
     expect(networkError.code).toBe("PIPELINE_LOAD_ERROR");
     expect(networkError.fatal).toBe(false);
     expect(networkError.message)
-      .toBe("NetworkError (PIPELINE_LOAD_ERROR) TIMEOUT");
+      .toBe("PIPELINE_LOAD_ERROR: The request timed out");
   });
 
   it("should filter in a valid error code", () => {
-    const requestError = new RequestError("foo", 13, "ERROR_HTTP_CODE");
+    const requestError = new RequestError("foo", 403, "ERROR_HTTP_CODE");
     const networkError = new NetworkError("PIPELINE_LOAD_ERROR", requestError);
     networkError.fatal = true;
     expect(networkError).toBeInstanceOf(Error);
     expect(networkError.name).toBe("NetworkError");
     expect(networkError.type).toBe("NETWORK_ERROR");
-    expect(networkError.status).toBe(13);
+    expect(networkError.status).toBe(403);
     expect(networkError.errorType).toBe(requestError.type);
     expect(networkError.code).toBe("PIPELINE_LOAD_ERROR");
     expect(networkError.fatal).toBe(true);
     expect(networkError.message)
-      .toBe("NetworkError (PIPELINE_LOAD_ERROR) ERROR_HTTP_CODE");
+      .toBe("PIPELINE_LOAD_ERROR: An HTTP status code " +
+            "indicating failure was received: 403");
   });
 
   it("should return false in isHttpError if not an HTTP error", () => {
@@ -56,7 +57,7 @@ describe("errors - NetworkError", () => {
   /* eslint-disable max-len */
   it("should return false in isHttpError if it is an HTTP error with a different code", () => {
   /* eslint-enable max-len */
-    const requestError = new RequestError("foo", 44, "ERROR_HTTP_CODE");
+    const requestError = new RequestError("foo", 500, "ERROR_HTTP_CODE");
     const networkError = new NetworkError("PIPELINE_LOAD_ERROR", requestError);
     expect(networkError.isHttpError(1)).toBe(false);
   });
@@ -64,8 +65,8 @@ describe("errors - NetworkError", () => {
   /* eslint-disable max-len */
   it("should return true in isHttpError if it is an HTTP error with the same code", () => {
   /* eslint-enable max-len */
-    const requestError = new RequestError("foo", 33, "ERROR_HTTP_CODE");
+    const requestError = new RequestError("foo", 418, "ERROR_HTTP_CODE");
     const networkError = new NetworkError("PIPELINE_LOAD_ERROR", requestError);
-    expect(networkError.isHttpError(33)).toBe(true);
+    expect(networkError.isHttpError(418)).toBe(true);
   });
 });

package/src/errors/__tests__/other_error.test.ts

@@ -24,7 +24,7 @@ describe("errors - OtherError", () => {
     expect(otherError.type).toBe("OTHER_ERROR");
     expect(otherError.code).toBe("NONE");
     expect(otherError.fatal).toBe(false);
-    expect(otherError.message).toBe("OtherError (NONE) tata");
+    expect(otherError.message).toBe("NONE: tata");
   });
 
   it("should be able to set it as fatal", () => {
@@ -36,7 +36,7 @@ describe("errors - OtherError", () => {
     expect(otherError.type).toBe("OTHER_ERROR");
     expect(otherError.code).toBe("NONE");
     expect(otherError.fatal).toBe(true);
-    expect(otherError.message).toBe("OtherError (NONE) test");
+    expect(otherError.message).toBe("NONE: test");
   });
 
   it("should filter in a valid error code", () => {
@@ -48,6 +48,6 @@ describe("errors - OtherError", () => {
     expect(otherError.type).toBe("OTHER_ERROR");
     expect(otherError.code).toBe("PIPELINE_LOAD_ERROR");
     expect(otherError.fatal).toBe(true);
-    expect(otherError.message).toBe("OtherError (PIPELINE_LOAD_ERROR) test");
+    expect(otherError.message).toBe("PIPELINE_LOAD_ERROR: test");
   });
 });

package/src/errors/__tests__/request_error.test.ts

@@ -18,12 +18,12 @@ import RequestError from "../request_error";
 
 describe("errors - RequestError", () => {
   it("should format a RequestError when called", () => {
-    const requestError = new RequestError("foo", 355, "ERROR_EVENT");
+    const requestError = new RequestError("foo", 0, "TIMEOUT");
     expect(requestError).toBeInstanceOf(Error);
     expect(requestError.name).toBe("RequestError");
     expect(requestError.url).toBe("foo");
-    expect(requestError.status).toBe(355);
-    expect(requestError.type).toBe("ERROR_EVENT");
-    expect(requestError.message).toBe("ERROR_EVENT");
+    expect(requestError.status).toBe(0);
+    expect(requestError.type).toBe("TIMEOUT");
+    expect(requestError.message).toBe("The request timed out");
   });
 });

package/src/errors/custom_loader_error.ts

@@ -50,4 +50,3 @@ export default class CustomLoaderError extends Error {
     this.xhr = xhr;
   }
 }
-

package/src/errors/encrypted_media_error.ts

@@ -51,7 +51,9 @@ export default class EncryptedMediaError extends Error {
   constructor(
     code : IEncryptedMediaErrorCode,
     reason : string,
-    supplementaryInfos? : { keyStatuses? : IEncryptedMediaErrorKeyStatusObject[] }
+    supplementaryInfos? : { keyStatuses? : IEncryptedMediaErrorKeyStatusObject[] |
+                                           undefined; } |
+                          undefined
   ) {
     super();
     // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
@@ -61,7 +63,7 @@ export default class EncryptedMediaError extends Error {
     this.type = ErrorTypes.ENCRYPTED_MEDIA_ERROR;
 
     this.code = code;
-    this.message = errorMessage(this.name, this.code, reason);
+    this.message = errorMessage(this.code, reason);
     this.fatal = false;
 
     if (typeof supplementaryInfos?.keyStatuses === "string") {