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

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,

package/src/default_config.ts

@@ -374,6 +374,33 @@ const DEFAULT_CONFIG = {
      */
   SAMPLING_INTERVAL_NO_MEDIASOURCE: 500,
 
+  /**
+   * Amount of buffer to have ahead of the current position before we may
+   * consider buffer-based adaptive estimates, in seconds.
+   *
+   * For example setting it to `10` means that we need to have ten seconds of
+   * buffer ahead of the current position before relying on buffer-based
+   * adaptive estimates.
+   *
+   * To avoid getting in-and-out of the buffer-based logic all the time, it
+   * should be set higher than `ABR_EXIT_BUFFER_BASED_ALGO`.
+   */
+  ABR_ENTER_BUFFER_BASED_ALGO: 10,
+
+  /**
+   * Below this amount of buffer ahead of the current position, in seconds, we
+   * will stop using buffer-based estimate in our adaptive logic to select a
+   * quality.
+   *
+   * For example setting it to `5` means that if we have less than 5 seconds of
+   * buffer ahead of the current position, we should stop relying on
+   * buffer-based estimates to choose a quality.
+   *
+   * To avoid getting in-and-out of the buffer-based logic all the time, it
+   * should be set lower than `ABR_ENTER_BUFFER_BASED_ALGO`.
+   */
+  ABR_EXIT_BUFFER_BASED_ALGO: 5,
+
     /**
      * Minimum number of bytes sampled before we trust the estimate.
      * If we have not sampled much data, our estimate may not be accurate
@@ -412,8 +439,8 @@ const DEFAULT_CONFIG = {
      * @type {Object}
      */
   ABR_REGULAR_FACTOR: {
-    DEFAULT: 0.8,
-    LOW_LATENCY: 0.8,
+    DEFAULT: 0.72,
+    LOW_LATENCY: 0.72,
   },
 
     /**

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

@@ -19,25 +19,25 @@ import MediaError from "../media_error";
 describe("errors - MediaError", () => {
   it("should format a MediaError", () => {
     const reason = "test";
-    const mediaError = new MediaError("BUFFER_FULL_ERROR", reason);
+    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", reason);
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
     expect(mediaError.type).toBe("MEDIA_ERROR");
-    expect(mediaError.code).toBe("BUFFER_FULL_ERROR");
+    expect(mediaError.code).toBe("MEDIA_TIME_BEFORE_MANIFEST");
     expect(mediaError.fatal).toBe(false);
-    expect(mediaError.message).toBe("MediaError (BUFFER_FULL_ERROR) test");
+    expect(mediaError.message).toBe("MediaError (MEDIA_TIME_BEFORE_MANIFEST) test");
   });
 
   it("should be able to set it as fatal", () => {
     const reason = "test";
-    const mediaError = new MediaError("BUFFER_APPEND_ERROR", reason);
+    const mediaError = new MediaError("MEDIA_TIME_AFTER_MANIFEST", reason);
     mediaError.fatal = true;
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
     expect(mediaError.type).toBe("MEDIA_ERROR");
-    expect(mediaError.code).toBe("BUFFER_APPEND_ERROR");
+    expect(mediaError.code).toBe("MEDIA_TIME_AFTER_MANIFEST");
     expect(mediaError.fatal).toBe(true);
-    expect(mediaError.message).toBe("MediaError (BUFFER_APPEND_ERROR) test");
+    expect(mediaError.message).toBe("MediaError (MEDIA_TIME_AFTER_MANIFEST) test");
   });
 
   it("should filter in a valid error code", () => {

package/src/errors/index.ts

@@ -26,7 +26,9 @@ import {
 } from "./error_codes";
 import formatError from "./format_error";
 import isKnownError from "./is_known_error";
-import MediaError from "./media_error";
+import MediaError, {
+  IMediaErrorTrackContext,
+} from "./media_error";
 import NetworkError from "./network_error";
 import OtherError from "./other_error";
 import RequestError from "./request_error";
@@ -39,6 +41,7 @@ export {
   ErrorTypes,
   IErrorCode,
   IErrorType,
+  IMediaErrorTrackContext,
   formatError,
   MediaError as MediaError,
   NetworkError,

package/src/errors/media_error.ts

@@ -14,12 +14,42 @@
  * limitations under the License.
  */
 
+import { Adaptation } from "../manifest";
+import {
+  IAudioTrack,
+  ITextTrack,
+  IVideoTrack,
+} from "../public_types";
 import {
   ErrorTypes,
   IMediaErrorCode,
 } from "./error_codes";
 import errorMessage from "./error_message";
 
+interface IAudioTrackMediaErrorContext {
+  type : "audio";
+  track : IAudioTrack;
+}
+
+interface IVideoTrackMediaErrorContext {
+  type : "video";
+  track : IVideoTrack;
+}
+
+interface ITextTrackMediaErrorContext {
+  type : "text";
+  track : ITextTrack;
+}
+
+export type IMediaErrorTrackContext = IAudioTrackMediaErrorContext |
+                                      IVideoTrackMediaErrorContext |
+                                      ITextTrackMediaErrorContext;
+
+type ICodeWithAdaptationType = "BUFFER_APPEND_ERROR" |
+                               "BUFFER_FULL_ERROR" |
+                               "NO_PLAYABLE_REPRESENTATION" |
+                               "MANIFEST_INCOMPATIBLE_CODECS_ERROR";
+
 /**
  * Error linked to the media Playback.
  *
@@ -31,13 +61,32 @@ export default class MediaError extends Error {
   public readonly type : "MEDIA_ERROR";
   public readonly message : string;
   public readonly code : IMediaErrorCode;
+  public readonly trackInfo : IMediaErrorTrackContext | undefined;
   public fatal : boolean;
 
   /**
    * @param {string} code
    * @param {string} reason
+   * @param {Object|undefined} [context]
    */
-  constructor(code : IMediaErrorCode, reason : string) {
+  constructor(
+    code : ICodeWithAdaptationType,
+    reason : string,
+    context: {
+      adaptation : Adaptation | undefined;
+    }
+  );
+  constructor(
+    code : Exclude<IMediaErrorCode, ICodeWithAdaptationType>,
+    reason : string,
+  );
+  constructor(
+    code : IMediaErrorCode,
+    reason : string,
+    context? : {
+      adaptation? : Adaptation | undefined;
+    } | undefined
+  ) {
     super();
     // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
     Object.setPrototypeOf(this, MediaError.prototype);
@@ -48,5 +97,22 @@ export default class MediaError extends Error {
     this.code = code;
     this.message = errorMessage(this.name, this.code, reason);
     this.fatal = false;
+    const adaptation = context?.adaptation;
+    if (adaptation !== undefined) {
+      switch (adaptation.type) {
+        case "audio":
+          this.trackInfo = { type: "audio",
+                             track: adaptation.toAudioTrack(false) };
+          break;
+        case "video":
+          this.trackInfo = { type: "video",
+                             track: adaptation.toVideoTrack(false) };
+          break;
+        case "text":
+          this.trackInfo = { type: "text",
+                             track: adaptation.toTextTrack() };
+          break;
+      }
+    }
   }
 }

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

@@ -33,30 +33,33 @@ export default function loadAndPushSegment(
   segmentInfo : ISegmentLoaderContent,
   segmentBuffer: AudioVideoSegmentBuffer,
   segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>,
+  initSegmentUniqueId : string | null,
   cancelSignal: CancellationSignal
 ): Promise<unknown> {
   const pushOperations : Array<Promise<unknown>> = [];
   return segmentFetcher(segmentInfo, {
     onChunk(parseChunk) {
       const parsed = parseChunk(undefined);
-      let isIsInitSegment : boolean;
+      let isInitSegment : boolean;
       let data : BufferSource | null;
       let timestampOffset : number;
       const codec = segmentInfo.representation.getMimeTypeString();
       if (parsed.segmentType === "init") {
-        isIsInitSegment = true;
+        isInitSegment = true;
         data = parsed.initializationData;
         timestampOffset = 0;
+        if (initSegmentUniqueId !== null) {
+          segmentBuffer.declareInitSegment(initSegmentUniqueId, data);
+        }
       } else {
-        isIsInitSegment = false;
+        isInitSegment = false;
         data = parsed.chunkData;
         timestampOffset = parsed.chunkOffset;
       }
       const pushOperation = segmentBuffer.pushChunk({
-        data: { initSegment: isIsInitSegment ? data :
-                                               null,
-                chunk: isIsInitSegment ? null :
-                                         data,
+        data: { initSegmentUniqueId,
+                chunk: isInitSegment ? null :
+                                       data,
                 appendWindow: [segmentInfo.period.start, segmentInfo.period.end],
                 timestampOffset,
                 codec },

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

@@ -167,7 +167,7 @@ export default class VideoThumbnailLoader {
 
     let lastRepInfo : IVideoThumbnailLoaderRepresentationInfo;
     if (this._lastRepresentationInfo === null) {
-      const cleaner = new TaskCanceller();
+      const lastRepInfoCleaner = new TaskCanceller();
       const segmentFetcher = createSegmentFetcher(
         "video",
         loader.video,
@@ -179,13 +179,17 @@ export default class VideoThumbnailLoader {
           maxRetry: 0,
           requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT }
       ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
+      const initSegment = content.representation.index.getInitSegment();
+      const initSegmentUniqueId = initSegment !== null ?
+        content.representation.uniqueId :
+        null;
       const segmentBufferProm = prepareSourceBuffer(
         this._videoElement,
         content.representation.getMimeTypeString(),
-        cleaner.signal
+        lastRepInfoCleaner.signal
       ).then(async (segmentBuffer) => {
-        const initSegment = content.representation.index.getInitSegment();
-        if (initSegment === null) {
+        if (initSegment === null || initSegmentUniqueId === null) {
+          lastRepInfo.initSegmentUniqueId = null;
           return segmentBuffer;
         }
         const segmentInfo = objectAssign({ segment: initSegment },
@@ -193,13 +197,18 @@ export default class VideoThumbnailLoader {
         await loadAndPushSegment(segmentInfo,
                                  segmentBuffer,
                                  lastRepInfo.segmentFetcher,
-                                 cleaner.signal);
+                                 initSegmentUniqueId,
+                                 lastRepInfoCleaner.signal);
+        lastRepInfoCleaner.signal.register(() => {
+          segmentBuffer.freeInitSegment(initSegmentUniqueId);
+        });
         return segmentBuffer;
       });
       lastRepInfo = {
-        cleaner,
+        cleaner: lastRepInfoCleaner,
         segmentBuffer: segmentBufferProm,
         content,
+        initSegmentUniqueId,
         segmentFetcher,
         pendingRequests: [],
       };
@@ -251,6 +260,7 @@ export default class VideoThumbnailLoader {
             const prom = loadAndPushSegment(segmentInfo,
                                             segmentBuffer,
                                             lastRepInfo.segmentFetcher,
+                                            lastRepInfo.initSegmentUniqueId,
                                             requestCanceller.signal)
               .then(unlinkSignal, (err) => {
                 unlinkSignal();
@@ -390,6 +400,7 @@ interface IVideoThumbnailLoaderRepresentationInfo {
    * `pendingRequests`.
    */
   pendingRequests : IPendingRequestInfo[];
+  initSegmentUniqueId : string |  null;
 }
 
 interface IPendingRequestInfo {

package/src/experimental/tools/mediaCapabilitiesProber/index.ts

@@ -15,8 +15,4 @@
  */
 
 import MediaCapabilitiesProber from "./api";
-import log from "./log";
-
-log.setLevel("WARNING");
-
 export default MediaCapabilitiesProber;

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

@@ -72,7 +72,7 @@ describe("Manifest - Manifest", () => {
     expect(manifest.suggestedPresentationDelay).toEqual(undefined);
     expect(manifest.uris).toEqual([]);
 
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();
@@ -114,7 +114,7 @@ describe("Manifest - Manifest", () => {
                                          contentWarnings: [] } ]);
     expect(manifest.adaptations).toEqual({});
 
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();
@@ -152,7 +152,7 @@ describe("Manifest - Manifest", () => {
     expect(fakePeriod).toHaveBeenCalledTimes(2);
     expect(fakePeriod).toHaveBeenCalledWith(period1, representationFilter);
     expect(fakePeriod).toHaveBeenCalledWith(period2, representationFilter);
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();
@@ -194,7 +194,7 @@ describe("Manifest - Manifest", () => {
     ]);
     expect(manifest.adaptations).toBe(adapP1);
 
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();
@@ -234,7 +234,7 @@ describe("Manifest - Manifest", () => {
     expect(manifest.contentWarnings).toContainEqual(new Error("0"));
     expect(manifest.contentWarnings).toContainEqual(new Error("1"));
 
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();
@@ -285,7 +285,7 @@ describe("Manifest - Manifest", () => {
     ]);
     expect(manifest.suggestedPresentationDelay).toEqual(99);
     expect(manifest.uris).toEqual(["url1", "url2"]);
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();
@@ -419,7 +419,7 @@ describe("Manifest - Manifest", () => {
       .toHaveBeenCalledWith(manifest.periods, newManifest.periods);
     expect(mockTrigger).toHaveBeenCalledTimes(1);
     expect(mockTrigger).toHaveBeenCalledWith("manifestUpdate", fakeReplacePeriodsRes);
-    expect(fakeIdGenerator).toHaveBeenCalledTimes(1);
+    expect(fakeIdGenerator).toHaveBeenCalled();
     expect(fakeGenerateNewId).toHaveBeenCalledTimes(1);
     expect(fakeLogger.info).not.toHaveBeenCalled();
     expect(fakeLogger.warn).not.toHaveBeenCalled();