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

package/src/manifest/__tests__/period.test.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import Adaptation from "../adaptation";
+
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-var-requires */
@@ -27,7 +29,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if no adaptation is given", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -38,12 +40,14 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: {}, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
 
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
@@ -59,7 +63,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if no audio nor video adaptation is given", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -79,12 +83,14 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: { foo }, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
 
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
@@ -104,7 +110,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if only empty audio and/or video adaptations is given", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -115,12 +121,14 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: { video: [], audio: [] }, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
 
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
@@ -138,7 +146,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if we are left with no audio representation", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -177,12 +185,14 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: { video, audio }, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
 
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
@@ -199,7 +209,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if no audio Adaptation is supported", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -238,8 +248,9 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: { video, audio }, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
@@ -247,6 +258,9 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
+    expect(unsupportedAdaptations).toHaveLength(2);
+    expect(unsupportedAdaptations[0].id).toEqual("57");
+    expect(unsupportedAdaptations[1].id).toEqual("58");
 
     // Impossible check to shut-up TypeScript
     if (!(errorReceived instanceof Error)) {
@@ -260,7 +274,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if we are left with no video representation", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -299,12 +313,14 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: { video, audio }, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
 
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
@@ -321,7 +337,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if no video adaptation is supported", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -360,8 +376,9 @@ describe("Manifest - Period", () => {
     const args = { id: "12", adaptations: { video, audio }, start: 0 };
     let period = null;
     let errorReceived = null;
+    const unsupportedAdaptations: Adaptation[] = [];
     try {
-      period = new Period(args);
+      period = new Period(args, unsupportedAdaptations);
     } catch (e) {
       errorReceived = e;
     }
@@ -369,6 +386,7 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
+    expect(unsupportedAdaptations).toHaveLength(3);
 
     // Impossible check to shut-up TypeScript
     if (!(errorReceived instanceof Error)) {
@@ -406,8 +424,9 @@ describe("Manifest - Period", () => {
                         toVideoTrack() { return videoAda2; } };
     const video2 = [videoAda2];
     const args = { id: "12", adaptations: { video, video2 }, start: 0 };
-    const period = new Period(args);
-    expect(period.contentWarnings).toHaveLength(1);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(1);
 
     expect(mockAdaptation).toHaveBeenCalledTimes(2);
     expect(mockAdaptation).toHaveReturnedTimes(2);
@@ -415,14 +434,13 @@ describe("Manifest - Period", () => {
     expect(mockAdaptation).toHaveBeenCalledWith(videoAda2, {});
     expect(mockAdaptation).toHaveReturnedWith(period.adaptations.video[0]);
 
-    const [error] = period.contentWarnings;
-    expect(error).toBeInstanceOf(Error);
-    expect(error.code).toBe("MANIFEST_INCOMPATIBLE_CODECS_ERROR");
-    expect(error.type).toBe("MEDIA_ERROR");
+    const [adap] = unsupportedAdaptations;
+    expect((adap as { id: string }).id).toBe("55");
+    expect((adap as { isSupported: boolean }).isSupported).toBe(false);
   });
 
   it("should not set a parsing error if an empty unsupported adaptation is given", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -439,18 +457,19 @@ describe("Manifest - Period", () => {
     const video = [videoAda1];
     const bar = undefined;
     const args = { id: "12", adaptations: { bar, video }, start: 0 };
-    const period = new Period(args);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
     expect(period.adaptations).toEqual({
-      video: video.map(v => ({ ...v, contentWarnings: [] })),
+      video: video.map(v => ({ ...v })),
     });
-    expect(period.contentWarnings).toHaveLength(0);
+    expect(unsupportedAdaptations).toHaveLength(0);
 
     expect(mockAdaptation).toHaveBeenCalledTimes(1);
     expect(mockAdaptation).toHaveBeenCalledWith(videoAda1, {});
   });
 
   it("should give a representationFilter to the adaptation", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     const representationFilter = jest.fn();
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
@@ -471,9 +490,10 @@ describe("Manifest - Period", () => {
                         toVideoTrack() { return videoAda2; } };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 0 };
-    const period = new Period(args, representationFilter);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations, representationFilter);
 
-    expect(period.contentWarnings).toHaveLength(0);
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period.adaptations.video).toHaveLength(2);
 
     expect(mockAdaptation).toHaveBeenCalledTimes(2);
@@ -484,7 +504,7 @@ describe("Manifest - Period", () => {
     expect(representationFilter).not.toHaveBeenCalled();
   });
 
-  it("should add contentWarnings if Adaptations are not supported", () => {
+  it("should report if Adaptations are not supported", () => {
     const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
@@ -510,19 +530,16 @@ describe("Manifest - Period", () => {
     const video = [videoAda1, videoAda2];
     const foo = [fooAda1];
     const args = { id: "12", adaptations: { video, foo }, start: 0 };
-    const period = new Period(args);
-
-    expect(period.contentWarnings).toHaveLength(2);
-    const error = period.contentWarnings[0];
-    expect(error.code).toEqual("MANIFEST_INCOMPATIBLE_CODECS_ERROR");
-    expect(error.type).toEqual("MEDIA_ERROR");
+    const unsupportedAdaptations: Adaptation[] = [];
+    new Period(args, unsupportedAdaptations);
 
-    const error2 = period.contentWarnings[1];
-    expect(error2.code).toEqual("MANIFEST_INCOMPATIBLE_CODECS_ERROR");
-    expect(error2.type).toEqual("MEDIA_ERROR");
+    expect(unsupportedAdaptations).toHaveLength(2);
+    const [adap1, adap2] = unsupportedAdaptations;
+    expect((adap1 as { id: string }).id).toBe("54");
+    expect((adap2 as { id: string }).id).toBe("12");
   });
 
-  it("should not add contentWarnings if an Adaptation has no Representation", () => {
+  it("should not report if an Adaptation has no Representation", () => {
     const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
@@ -548,13 +565,13 @@ describe("Manifest - Period", () => {
     const video = [videoAda1, videoAda2];
     const foo = [fooAda1];
     const args = { id: "12", adaptations: { video, foo }, start: 0 };
-    const period = new Period(args);
-
-    expect(period.contentWarnings).toHaveLength(0);
+    const unsupportedAdaptations: Adaptation[] = [];
+    new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(0);
   });
 
   it("should set the given start", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -574,14 +591,16 @@ describe("Manifest - Period", () => {
                         toVideoTrack() { return videoAda2; } };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 72 };
-    const period = new Period(args);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period.start).toEqual(72);
     expect(period.duration).toEqual(undefined);
     expect(period.end).toEqual(undefined);
   });
 
   it("should set a given duration", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -601,14 +620,16 @@ describe("Manifest - Period", () => {
                         toVideoTrack() { return videoAda2; } };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 0, duration: 12 };
-    const period = new Period(args);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period.start).toEqual(0);
     expect(period.duration).toEqual(12);
     expect(period.end).toEqual(12);
   });
 
   it("should infer the end from the start and the duration", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -628,14 +649,16 @@ describe("Manifest - Period", () => {
                         toVideoTrack() { return videoAda2; } };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 50, duration: 12 };
-    const period = new Period(args);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period.start).toEqual(50);
     expect(period.duration).toEqual(12);
     expect(period.end).toEqual(62);
   });
 
   it("should return every Adaptations combined with `getAdaptations`", () => {
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -663,8 +686,9 @@ describe("Manifest - Period", () => {
     const audio = [audioAda1];
 
     const args = { id: "12", adaptations: { video, audio }, start: 50, duration: 12 };
-    const period = new Period(args);
-
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period.getAdaptations()).toHaveLength(3);
     expect(period.getAdaptations()).toContain(period.adaptations.video[0]);
     expect(period.getAdaptations()).toContain(period.adaptations.video[1]);
@@ -674,7 +698,7 @@ describe("Manifest - Period", () => {
   /* eslint-disable max-len */
   it("should return every Adaptations from a given type with `getAdaptationsForType`", () => {
   /* eslint-enable max-len */
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -702,7 +726,9 @@ describe("Manifest - Period", () => {
     const audio = [audioAda1];
 
     const args = { id: "12", adaptations: { video, audio }, start: 50, duration: 12 };
-    const period = new Period(args);
+    const unsupportedAdaptations: Adaptation[] = [];
+    const period = new Period(args, unsupportedAdaptations);
+    expect(unsupportedAdaptations).toHaveLength(0);
 
     expect(period.getAdaptationsForType("video")).toHaveLength(2);
     expect(period.getAdaptationsForType("video"))
@@ -719,7 +745,7 @@ describe("Manifest - Period", () => {
   /* eslint-disable max-len */
   it("should return the first Adaptations with a given Id when calling `getAdaptation`", () => {
   /* eslint-enable max-len */
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,
@@ -752,8 +778,9 @@ describe("Manifest - Period", () => {
     const audio = [audioAda1];
 
     const args = { id: "12", adaptations: { video, audio }, start: 50, duration: 12 };
+    const unsupportedAdaptations: Adaptation[] = [];
     const period = new Period(args);
-
+    expect(unsupportedAdaptations).toHaveLength(0);
     expect(period.getAdaptation("54")).toEqual(period.adaptations.video[0]);
     expect(period.getAdaptation("55")).toEqual(period.adaptations.video[1]);
     expect(period.getAdaptation("56")).toEqual(period.adaptations.audio[0]);
@@ -762,7 +789,7 @@ describe("Manifest - Period", () => {
   /* eslint-disable max-len */
   it("should return undefind if no adaptation has the given Id when calling `getAdaptation`", () => {
   /* eslint-enable max-len */
-    const mockAdaptation = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
+    const mockAdaptation = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: mockAdaptation,

package/src/manifest/__tests__/update_periods.test.ts

@@ -410,7 +410,7 @@ describe("Manifest - updatePeriods", () => {
     expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
     expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
-      "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: not enough data"
+      "MANIFEST_UPDATE_ERROR: Cannot perform partial update: not enough data"
     );
     expect(oldPeriods.length).toBe(1);
     expect(oldPeriods[0].id).toBe("p1");
@@ -511,7 +511,7 @@ describe("Manifest - updatePeriods", () => {
     expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
     expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
-      "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: incoherent data"
+      "MANIFEST_UPDATE_ERROR: Cannot perform partial update: incoherent data"
     );
     expect(oldPeriods.length).toBe(1);
     expect(oldPeriods[0].id).toBe("p2");
@@ -602,7 +602,7 @@ describe("Manifest - updatePeriods", () => {
     expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
     expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
-      "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: not enough data"
+      "MANIFEST_UPDATE_ERROR: Cannot perform partial update: not enough data"
     );
     expect(oldPeriods.length).toBe(2);
     expect(oldPeriods[0].id).toBe("p0");
@@ -674,7 +674,7 @@ describe("Manifest - updatePeriods", () => {
     expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
     expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
-      "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: incoherent data"
+      "MANIFEST_UPDATE_ERROR: Cannot perform partial update: incoherent data"
     );
     expect(oldPeriods.length).toBe(1);
     expect(oldPeriods[0].id).toBe("p1");

package/src/manifest/manifest.ts

@@ -14,16 +14,18 @@
  * limitations under the License.
  */
 
+import { MediaError } from "../errors";
 import log from "../log";
 import { IParsedManifest } from "../parsers/manifest";
 import {
   ITrackType,
-  IPlayerError,
   IRepresentationFilter,
+  IPlayerError,
 } from "../public_types";
 import arrayFind from "../utils/array_find";
 import EventEmitter from "../utils/event_emitter";
 import idGenerator from "../utils/id_generator";
+import getMonotonicTimeStamp from "../utils/monotonic_timestamp";
 import warnOnce from "../utils/warn_once";
 import Adaptation from "./adaptation";
 import Period, {
@@ -184,15 +186,9 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    */
   public publishTime: number | undefined;
 
-  /**
-   * Array containing every minor errors that happened when the Manifest has
-   * been created, in the order they have happened.
-   */
-  public contentWarnings : IPlayerError[];
-
   /*
-   * Difference between the server's clock in milliseconds and the return of the
-   * JS function `performance.now`.
+   * Difference between the server's clock in milliseconds and the
+   * monotonically-raising timestamp used by the RxPlayer.
    * This property allows to calculate the server time at any moment.
    * `undefined` if we did not obtain the server's time
    */
@@ -280,8 +276,8 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
        */
       maximumSafePosition : number;
       /**
-       * `Performance.now()` output at the time both `maximumSafePosition` and
-       * `livePosition` were calculated.
+       * `Monotically-increasing timestamp used by the RxPlayer at the time both
+       * `maximumSafePosition` and `livePosition` were calculated.
        * This can be used to retrieve a new maximum position from them when they
        * linearly evolves over time (see `isLinear` property).
        */
@@ -297,23 +293,38 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    * will contain all such errors, in the order they have been encountered.
    * @param {Object} parsedManifest
    * @param {Object} options
-   */
-  constructor(parsedManifest : IParsedManifest, options : IManifestParsingOptions) {
+   * @param {Array.<Object>} warnings - After construction, will be optionally
+   * filled by errors expressing minor issues seen while parsing the Manifest.
+   */
+  constructor(
+    parsedManifest : IParsedManifest,
+    options : IManifestParsingOptions,
+    warnings : IPlayerError[]
+  ) {
     super();
     const { representationFilter,
             manifestUpdateUrl } = options;
-    this.contentWarnings = [];
     this.id = generateNewManifestId();
     this.expired = parsedManifest.expired ?? null;
     this.transport = parsedManifest.transportType;
     this.clockOffset = parsedManifest.clockOffset;
 
+    const unsupportedAdaptations: Adaptation[] = [];
     this.periods = parsedManifest.periods.map((parsedPeriod) => {
-      const period = new Period(parsedPeriod, representationFilter);
-      this.contentWarnings.push(...period.contentWarnings);
+      const period = new Period(parsedPeriod,
+                                unsupportedAdaptations,
+                                representationFilter);
       return period;
     }).sort((a, b) => a.start - b.start);
 
+    if (unsupportedAdaptations.length > 0) {
+      const error =
+        new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
+                       "An Adaptation contains only incompatible codecs.",
+                       { adaptations: unsupportedAdaptations });
+      warnings.push(error);
+    }
+
     /**
      * @deprecated It is here to ensure compatibility with the way the
      * v3.x.x manages adaptations at the Manifest level
@@ -443,7 +454,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
     if (!windowData.maximumTimeData.isLinear) {
       maximumTime = maximumTimeData.maximumSafePosition;
     } else {
-      const timeDiff = performance.now() - maximumTimeData.time;
+      const timeDiff = getMonotonicTimeStamp() - maximumTimeData.time;
       maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
     }
     const theoricalMinimum = maximumTime - windowData.timeshiftDepth;
@@ -463,7 +474,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
     if (!maximumTimeData.isLinear) {
       return maximumTimeData.livePosition;
     }
-    const timeDiff = performance.now() - maximumTimeData.time;
+    const timeDiff = getMonotonicTimeStamp() - maximumTimeData.time;
     return maximumTimeData.livePosition + timeDiff / 1000;
   }
 
@@ -477,7 +488,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
     if (!maximumTimeData.isLinear) {
       return maximumTimeData.maximumSafePosition;
     }
-    const timeDiff = performance.now() - maximumTimeData.time;
+    const timeDiff = getMonotonicTimeStamp() - maximumTimeData.time;
     return maximumTimeData.maximumSafePosition + timeDiff / 1000;
   }
 
@@ -562,7 +573,6 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
     this.isLive = newManifest.isLive;
     this.isLastPeriodKnown = newManifest.isLastPeriodKnown;
     this.lifetime = newManifest.lifetime;
-    this.contentWarnings = newManifest.contentWarnings;
     this.suggestedPresentationDelay = newManifest.suggestedPresentationDelay;
     this.transport = newManifest.transport;
     this.publishTime = newManifest.publishTime;

package/src/manifest/period.ts

@@ -20,7 +20,6 @@ import {
 } from "../parsers/manifest";
 import {
   ITrackType,
-  IPlayerError,
   IRepresentationFilter,
 } from "../public_types";
 import arrayFind from "../utils/array_find";
@@ -57,12 +56,6 @@ export default class Period {
    */
   public end : number | undefined;
 
-  /**
-   * Array containing every errors that happened when the Period has been
-   * created, in the order they have happened.
-   */
-  public readonly contentWarnings : IPlayerError[];
-
   /** Array containing every stream event happening on the period */
   public streamEvents : IManifestStreamEvent[];
 
@@ -73,9 +66,9 @@ export default class Period {
    */
   constructor(
     args : IParsedPeriod,
+    unsupportedAdaptations: Adaptation[],
     representationFilter? : IRepresentationFilter | undefined
   ) {
-    this.contentWarnings = [];
     this.id = args.id;
     this.adaptations = (Object.keys(args.adaptations) as ITrackType[])
       .reduce<IManifestAdaptations>((acc, type) => {
@@ -87,11 +80,7 @@ export default class Period {
           .map((adaptation) : Adaptation => {
             const newAdaptation = new Adaptation(adaptation, { representationFilter });
             if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
-              const error =
-                new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
-                               "An Adaptation contains only incompatible codecs.",
-                               { adaptation: newAdaptation });
-              this.contentWarnings.push(error);
+              unsupportedAdaptations.push(newAdaptation);
             }
             return newAdaptation;
           })
@@ -104,7 +93,7 @@ export default class Period {
         ) {
           throw new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
                                "No supported " + type + " adaptations",
-                               { adaptation: undefined });
+                               { adaptations: undefined });
         }
 
         if (filteredAdaptations.length > 0) {