rx-player 3.27.0 → 3.27.1-dev.2022041500

package/src/parsers/manifest/types.ts

@@ -263,10 +263,15 @@ export interface IParsedManifest {
    */
   timeBounds : {
     /**
-     * The minimum time, in seconds, available in this Manifest.
-     * `undefined` if that value is unknown.
+     * This is the theoretical minimum playable position on the content
+     * regardless of the current Adaptation chosen, as estimated at parsing
+     * time.
+     * `undefined` if unknown.
+     *
+     * More technically, the `minimumSafePosition` is the maximum between all
+     * the minimum positions reachable in any of the audio and video Adaptation.
      */
-    absoluteMinimumTime? : number | undefined;
+    minimumSafePosition? : number | undefined;
     /**
      * Some dynamic contents have the concept of a "window depth" (or "buffer
      * depth") which allows to set a minimum position for all reachable
@@ -283,27 +288,50 @@ export interface IParsedManifest {
     timeshiftDepth : number | null;
     /** Data allowing to calculate the maximum position at any given time. */
     maximumTimeData : {
-      /** Maximum seekable time in milliseconds calculated at `time`. */
-      value : number;
       /**
-       * `Performance.now()` output at the time `value` was calculated.
-       * This can be used to retrieve the maximum position from `value` when it
-       * linearly evolves over time (see `isLinear` property).
+       * Current position representing live content.
+       * Only makes sense for un-ended live contents.
+       *
+       * `undefined` if unknown or if it doesn't make sense in the current context.
        */
-      time : number;
+      livePosition : number | undefined;
       /**
-       * Whether the maximum seekable position evolves linearly over time.
+       * Whether the maximum positions should evolve linearly over time.
        *
-       * If set to `false`, `value` indicates the constant maximum position.
-       *
-       * If set to `true`, the maximum seekable time continuously increase at
+       * If set to `true`, the maximum seekable position continuously increase at
        * the same rate than the time since `time` does.
-       * For example, a `value` of 50000 (50 seconds) will indicate a maximum time
-       * of 51 seconds after 1 second have passed, of 56 seconds after 6 seconds
-       * have passed (we know how many seconds have passed since the initial
-       * calculation of value by checking the `time` property) etc.
+       *
+       * For example, a `maximumSafePosition` of 50000 (50 seconds) will
+       * indicate a maximum time of 51 seconds after 1 second have passed, of 56
+       * seconds after 6 seconds have passed (we know how many seconds have
+       * passed since the initial calculation of the maximum position by
+       * checking the `time` property) etc.
        */
       isLinear: boolean;
+      /**
+       * This is the theoretical maximum playable position on the content,
+       * regardless of the current Adaptation chosen, as estimated at parsing
+       * time.
+       *
+       * More technically, the `maximumSafePosition` is the minimum between all
+       * attributes indicating the duration of the content in the Manifest.
+       *
+       * That is the minimum between:
+       *   - The Manifest original attributes relative to its duration
+       *   - The minimum between all known maximum audio positions
+       *   - The minimum between all known maximum video positions
+       *
+       * This can for example be understood as the safe maximum playable
+       * position through all possible tacks.
+       */
+      maximumSafePosition : number;
+      /**
+       * `Performance.now()` output at the time both `maximumSafePosition` and
+       * `maximumPositionWithMediaData` were calculated.
+       * This can be used to retrieve a new maximum position from them when they
+       * linearly evolves over time (see `isLinear` property).
+       */
+      time : number;
     };
   };
   /**

package/src/parsers/manifest/utils/{get_maximum_position.ts → get_maximum_positions.ts}

@@ -24,7 +24,9 @@ import getLastPositionFromAdaptation from "./get_last_time_from_adaptation";
  */
 export default function getMaximumPosition(
   periods : IParsedPeriod[]
-) : number | undefined {
+) : { safe : number | undefined;
+      unsafe : number | undefined; }
+{
   for (let i = periods.length - 1; i >= 0; i--) {
     const periodAdaptations = periods[i].adaptations;
     const firstAudioAdaptationFromPeriod = periodAdaptations.audio === undefined ?
@@ -44,7 +46,7 @@ export default function getMaximumPosition(
         const lastPosition =
           getLastPositionFromAdaptation(firstAudioAdaptationFromPeriod);
         if (lastPosition === undefined) {
-          return undefined;
+          return { safe: undefined, unsafe: undefined };
         }
         maximumAudioPosition = lastPosition;
       }
@@ -52,7 +54,7 @@ export default function getMaximumPosition(
         const lastPosition =
           getLastPositionFromAdaptation(firstVideoAdaptationFromPeriod);
         if (lastPosition === undefined) {
-          return undefined;
+          return { safe: undefined, unsafe: undefined };
         }
         maximumVideoPosition = lastPosition;
       }
@@ -64,18 +66,22 @@ export default function getMaximumPosition(
       ) {
         log.info("Parser utils: found Period with no segment. ",
                  "Going to previous one to calculate last position");
-        return undefined;
+        return { safe: undefined, unsafe: undefined };
       }
 
       if (maximumVideoPosition !== null) {
         if (maximumAudioPosition !== null) {
-          return Math.min(maximumAudioPosition, maximumVideoPosition);
+          return { safe: Math.min(maximumAudioPosition, maximumVideoPosition),
+                   unsafe: Math.max(maximumAudioPosition, maximumVideoPosition) };
         }
-        return maximumVideoPosition;
+        return { safe: maximumVideoPosition,
+                 unsafe: maximumVideoPosition };
       }
       if (maximumAudioPosition !== null) {
-        return maximumAudioPosition;
+        return { safe: maximumAudioPosition,
+                 unsafe: maximumAudioPosition };
       }
     }
   }
+  return { safe: undefined, unsafe: undefined };
 }

package/dist/_esm5.processed/core/init/duration_updater.d.ts

@@ -1,27 +0,0 @@
-/**
- * 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 { Observable } from "rxjs";
-import Manifest from "../../manifest";
-/**
- * Keep the MediaSource duration up-to-date with the Manifest one on
- * subscription:
- * Set the current duration initially and then update if needed after
- * each Manifest updates.
- * @param {Object} manifest
- * @param {MediaSource} mediaSource
- * @returns {Observable}
- */
-export default function DurationUpdater(manifest: Manifest, mediaSource: MediaSource): Observable<never>;

package/dist/_esm5.processed/core/init/duration_updater.js

@@ -1,136 +0,0 @@
-/**
- * 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 { catchError, combineLatest as observableCombineLatest, defer as observableDefer, distinctUntilChanged, EMPTY, filter, fromEvent as observableFromEvent, ignoreElements, interval as observableInterval, map, merge as observableMerge, mergeMap, of as observableOf, startWith, switchMap, take, tap, } from "rxjs";
-import { onSourceOpen$, onSourceClose$, onSourceEnded$, } from "../../compat/event_listeners";
-import log from "../../log";
-import { fromEvent } from "../../utils/event_emitter";
-/** Number of seconds in a regular year. */
-var YEAR_IN_SECONDS = 365 * 24 * 3600;
-/**
- * Keep the MediaSource duration up-to-date with the Manifest one on
- * subscription:
- * Set the current duration initially and then update if needed after
- * each Manifest updates.
- * @param {Object} manifest
- * @param {MediaSource} mediaSource
- * @returns {Observable}
- */
-export default function DurationUpdater(manifest, mediaSource) {
-    return observableDefer(function () {
-        var lastDurationUpdate;
-        return setMediaSourceDuration(mediaSource, manifest).pipe(mergeMap(function (initialDurationUpdate) {
-            // only update `lastDurationUpdate` if the MediaSource's duration has
-            // been updated.
-            if (initialDurationUpdate !== null) {
-                lastDurationUpdate = initialDurationUpdate;
-            }
-            return fromEvent(manifest, "manifestUpdate").pipe(switchMap(function () { return setMediaSourceDuration(mediaSource, manifest, lastDurationUpdate); }), tap(function (durationUpdate) {
-                if (durationUpdate !== null) {
-                    lastDurationUpdate = durationUpdate;
-                }
-            }));
-        }), 
-        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-        // first type parameter as `any` instead of the perfectly fine `unknown`,
-        // leading to linter issues, as it forbids the usage of `any`.
-        // This is why we're disabling the eslint rule.
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
-        ignoreElements());
-    });
-}
-/**
- * Checks that duration can be updated on the MediaSource, and then
- * sets it.
- *
- * Returns either:
- *   - the new duration it has been updated to if it has
- *   - `null` if it hasn'nt been updated
- *
- * @param {MediaSource} mediaSource
- * @param {Object} manifest
- * @param {number | undefined} lastSetDuration
- * @returns {Observable.<number | null>}
- */
-function setMediaSourceDuration(mediaSource, manifest, lastSetDuration) {
-    return isMediaSourceOpened$(mediaSource).pipe(switchMap(function (isMediaSourceOpened) {
-        if (!isMediaSourceOpened) {
-            return EMPTY;
-        }
-        return whenSourceBuffersEndedUpdates$(mediaSource.sourceBuffers);
-    }), take(1), map(function () {
-        var maximumPosition = manifest.getMaximumPosition();
-        var isLive = manifest.isLive;
-        // Some targets poorly support setting a very high number for durations.
-        // Yet, in live contents, we would prefer setting a value as high as possible
-        // to still be able to seek anywhere we want to (even ahead of the Manifest if
-        // we want to). As such, we put it at a safe default value of 2^32 excepted
-        // when the maximum position is already relatively close to that value, where
-        // we authorize exceptionally going over it.
-        var newDuration = !isLive ? maximumPosition :
-            Math.max(Math.pow(2, 32), maximumPosition + YEAR_IN_SECONDS);
-        if (mediaSource.duration >= newDuration ||
-            // Even if the MediaSource duration is different than the duration that
-            // we want to set now, the last duration we wanted to set may be the same,
-            // as the MediaSource duration may have been changed by the browser.
-            //
-            // In that case, we do not want to update it.
-            //
-            newDuration === lastSetDuration) {
-            return null;
-        }
-        if (isNaN(mediaSource.duration) || !isFinite(mediaSource.duration) ||
-            newDuration - mediaSource.duration > 0.01) {
-            log.info("Init: Updating duration", newDuration);
-            mediaSource.duration = newDuration;
-            return newDuration;
-        }
-        return null;
-    }), catchError(function (err) {
-        log.warn("Duration Updater: Can't update duration on the MediaSource.", err);
-        return observableOf(null);
-    }));
-}
-/**
- * Returns an Observable which will emit only when all the SourceBuffers ended
- * all pending updates.
- * @param {SourceBufferList} sourceBuffers
- * @returns {Observable}
- */
-function whenSourceBuffersEndedUpdates$(sourceBuffers) {
-    if (sourceBuffers.length === 0) {
-        return observableOf(undefined);
-    }
-    var sourceBufferUpdatingStatuses = [];
-    var _loop_1 = function (i) {
-        var sourceBuffer = sourceBuffers[i];
-        sourceBufferUpdatingStatuses.push(observableMerge(observableFromEvent(sourceBuffer, "updatestart").pipe(map(function () { return true; })), observableFromEvent(sourceBuffer, "update").pipe(map(function () { return false; })), observableInterval(500).pipe(map(function () { return sourceBuffer.updating; }))).pipe(startWith(sourceBuffer.updating), distinctUntilChanged()));
-    };
-    for (var i = 0; i < sourceBuffers.length; i++) {
-        _loop_1(i);
-    }
-    return observableCombineLatest(sourceBufferUpdatingStatuses).pipe(filter(function (areUpdating) {
-        return areUpdating.every(function (isUpdating) { return !isUpdating; });
-    }), map(function () { return undefined; }));
-}
-/**
- * Emit a boolean that tells if the media source is opened or not.
- * @param {MediaSource} mediaSource
- * @returns {Object}
- */
-function isMediaSourceOpened$(mediaSource) {
-    return observableMerge(onSourceOpen$(mediaSource).pipe(map(function () { return true; })), onSourceEnded$(mediaSource).pipe(map(function () { return false; })), onSourceClose$(mediaSource).pipe(map(function () { return false; }))).pipe(startWith(mediaSource.readyState === "open"), distinctUntilChanged());
-}
-/* eslint-enable @typescript-eslint/no-unsafe-argument */

package/src/core/init/duration_updater.ts

@@ -1,206 +0,0 @@
-/**
- * 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 {
-  catchError,
-  combineLatest as observableCombineLatest,
-  defer as observableDefer,
-  distinctUntilChanged,
-  EMPTY,
-  filter,
-  fromEvent as observableFromEvent,
-  ignoreElements,
-  interval as observableInterval,
-  map,
-  merge as observableMerge,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  startWith,
-  switchMap,
-  take,
-  tap,
-} from "rxjs";
-import {
-  onSourceOpen$,
-  onSourceClose$,
-  onSourceEnded$,
-} from "../../compat/event_listeners";
-import log from "../../log";
-import Manifest from "../../manifest";
-import { fromEvent } from "../../utils/event_emitter";
-
-/** Number of seconds in a regular year. */
-const YEAR_IN_SECONDS = 365 * 24 * 3600;
-
-/**
- * Keep the MediaSource duration up-to-date with the Manifest one on
- * subscription:
- * Set the current duration initially and then update if needed after
- * each Manifest updates.
- * @param {Object} manifest
- * @param {MediaSource} mediaSource
- * @returns {Observable}
- */
-export default function DurationUpdater(
-  manifest : Manifest,
-  mediaSource : MediaSource
-) : Observable<never> {
-  return observableDefer(() => {
-    let lastDurationUpdate: number | undefined;
-    return setMediaSourceDuration(mediaSource, manifest).pipe(
-      mergeMap((initialDurationUpdate) => {
-        // only update `lastDurationUpdate` if the MediaSource's duration has
-        // been updated.
-        if (initialDurationUpdate !== null) {
-          lastDurationUpdate = initialDurationUpdate;
-        }
-
-        return fromEvent(manifest, "manifestUpdate").pipe(
-          switchMap(() => setMediaSourceDuration(mediaSource,
-                                                 manifest,
-                                                 lastDurationUpdate)),
-          tap((durationUpdate) => {
-            if (durationUpdate !== null) {
-              lastDurationUpdate = durationUpdate;
-            }
-          })
-        );
-      }),
-      // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-      // first type parameter as `any` instead of the perfectly fine `unknown`,
-      // leading to linter issues, as it forbids the usage of `any`.
-      // This is why we're disabling the eslint rule.
-      /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
-      ignoreElements()
-    );
-  });
-}
-
-/**
- * Checks that duration can be updated on the MediaSource, and then
- * sets it.
- *
- * Returns either:
- *   - the new duration it has been updated to if it has
- *   - `null` if it hasn'nt been updated
- *
- * @param {MediaSource} mediaSource
- * @param {Object} manifest
- * @param {number | undefined} lastSetDuration
- * @returns {Observable.<number | null>}
- */
-function setMediaSourceDuration(
-  mediaSource: MediaSource,
-  manifest: Manifest,
-  lastSetDuration?: number
-): Observable<number | null> {
-  return isMediaSourceOpened$(mediaSource).pipe(
-    switchMap((isMediaSourceOpened) => {
-      if (!isMediaSourceOpened) {
-        return EMPTY;
-      }
-      return whenSourceBuffersEndedUpdates$(mediaSource.sourceBuffers);
-    }),
-    take(1),
-    map(() : number | null => {
-      const maximumPosition = manifest.getMaximumPosition();
-      const { isLive } = manifest;
-      // Some targets poorly support setting a very high number for durations.
-      // Yet, in live contents, we would prefer setting a value as high as possible
-      // to still be able to seek anywhere we want to (even ahead of the Manifest if
-      // we want to). As such, we put it at a safe default value of 2^32 excepted
-      // when the maximum position is already relatively close to that value, where
-      // we authorize exceptionally going over it.
-      const newDuration = !isLive ? maximumPosition :
-                                    Math.max(Math.pow(2, 32),
-                                             maximumPosition + YEAR_IN_SECONDS);
-
-      if (mediaSource.duration >= newDuration ||
-          // Even if the MediaSource duration is different than the duration that
-          // we want to set now, the last duration we wanted to set may be the same,
-          // as the MediaSource duration may have been changed by the browser.
-          //
-          // In that case, we do not want to update it.
-          //
-          newDuration === lastSetDuration) {
-        return null;
-      }
-      if (isNaN(mediaSource.duration) || !isFinite(mediaSource.duration) ||
-          newDuration - mediaSource.duration > 0.01) {
-        log.info("Init: Updating duration", newDuration);
-        mediaSource.duration = newDuration;
-        return newDuration;
-      }
-      return null;
-    }),
-    catchError((err) => {
-      log.warn("Duration Updater: Can't update duration on the MediaSource.", err);
-      return observableOf(null);
-    })
-  );
-}
-
-/**
- * Returns an Observable which will emit only when all the SourceBuffers ended
- * all pending updates.
- * @param {SourceBufferList} sourceBuffers
- * @returns {Observable}
- */
-function whenSourceBuffersEndedUpdates$(
-  sourceBuffers: SourceBufferList
-) : Observable<undefined> {
-  if (sourceBuffers.length === 0) {
-    return observableOf(undefined);
-  }
-  const sourceBufferUpdatingStatuses : Array<Observable<boolean>> = [];
-
-  for (let i = 0; i < sourceBuffers.length; i++) {
-    const sourceBuffer = sourceBuffers[i];
-    sourceBufferUpdatingStatuses.push(
-      observableMerge(
-        observableFromEvent(sourceBuffer, "updatestart").pipe(map(() => true)),
-        observableFromEvent(sourceBuffer, "update").pipe(map(() => false)),
-        observableInterval(500).pipe(map(() => sourceBuffer.updating))
-      ).pipe(
-        startWith(sourceBuffer.updating),
-        distinctUntilChanged()
-      )
-    );
-  }
-  return observableCombineLatest(sourceBufferUpdatingStatuses).pipe(
-    filter((areUpdating) => {
-      return areUpdating.every((isUpdating) => !isUpdating);
-    }),
-    map(() => undefined)
-  );
-}
-
-/**
- * Emit a boolean that tells if the media source is opened or not.
- * @param {MediaSource} mediaSource
- * @returns {Object}
- */
-function isMediaSourceOpened$(mediaSource: MediaSource): Observable<boolean> {
-  return observableMerge(onSourceOpen$(mediaSource).pipe(map(() => true)),
-                         onSourceEnded$(mediaSource).pipe(map(() => false)),
-                         onSourceClose$(mediaSource).pipe(map(() => false))
-  ).pipe(
-    startWith(mediaSource.readyState === "open"),
-    distinctUntilChanged()
-  );
-}
-/* eslint-enable @typescript-eslint/no-unsafe-argument */