rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/fetchers/segment/create_segment_loader.ts

@@ -1,251 +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 {
-  concat as observableConcat,
-  EMPTY,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
-  catchError,
-  map,
-  mergeMap,
-} from "rxjs/operators";
-import { ICustomError } from "../../../errors";
-import Manifest, {
-  Adaptation,
-  ISegment,
-  Period,
-  Representation,
-} from "../../../manifest";
-import {
-  ILoaderDataLoadedValue,
-  ILoaderProgressEvent,
-  ISegmentLoaderArguments,
-  ISegmentLoaderEvent as ITransportSegmentLoaderEvent,
-} from "../../../transports";
-import assertUnreachable from "../../../utils/assert_unreachable";
-import castToObservable from "../../../utils/cast_to_observable";
-import objectAssign from "../../../utils/object_assign";
-import tryCatch from "../../../utils/rx-try_catch";
-import { IABRMetricsEvent } from "../../abr";
-import errorSelector from "../utils/error_selector";
-import tryURLsWithBackoff, {
-  IBackoffOptions,
-} from "../utils/try_urls_with_backoff";
-
-/** Data comes from a local JS cache maintained here, no request was done. */
-interface ISegmentLoaderCachedSegmentEvent<T> { type : "cache";
-                                                value : ILoaderDataLoadedValue<T>; }
-
-/** An Error happened while loading (usually a request error). */
-export interface ISegmentLoaderWarning { type : "warning";
-                                         value : ICustomError; }
-
-/** The request begins to be done. */
-export interface ISegmentLoaderRequest { type : "request";
-                                         value : ISegmentLoaderArguments; }
-
-/** The whole segment's data (not only a chunk) is available. */
-export interface ISegmentLoaderData<T> { type : "data";
-                                         value : { responseData : T }; }
-
-/**
- * A chunk of the data is available.
- * You will receive every chunk through such events until a
- * ISegmentLoaderChunkComplete event is received.
- */
-export interface ISegmentLoaderChunk { type : "chunk";
-                                       value : { responseData : null |
-                                                                ArrayBuffer |
-                                                                Uint8Array; }; }
-
-/** The data has been entirely sent through "chunk" events. */
-export interface ISegmentLoaderChunkComplete { type : "chunk-complete";
-                                               value : null; }
-
-/**
- * Every events the segment loader emits.
- * Type parameters: T: Argument given to the loader
- *                  U: ResponseType of the request
- */
-export type ISegmentLoaderEvent<T> = ISegmentLoaderData<T> |
-                                     ISegmentLoaderRequest |
-                                     ILoaderProgressEvent |
-                                     ISegmentLoaderWarning |
-                                     ISegmentLoaderChunk |
-                                     ISegmentLoaderChunkComplete |
-                                     IABRMetricsEvent;
-
-/** Cache implementation to avoid re-requesting segment */
-export interface ISegmentLoaderCache<T> {
-  /** Add a segment to the cache. */
-  add : (obj : ISegmentLoaderContent, arg : ILoaderDataLoadedValue<T>) => void;
-  /** Retrieve a segment from the cache */
-  get : (obj : ISegmentLoaderContent) => ILoaderDataLoadedValue<T> | null;
-}
-
-/** Abstraction to load a segment in the current transport protocol. */
-export type ISegmentPipelineLoader<T> =
-  (x : ISegmentLoaderArguments) => Observable< ITransportSegmentLoaderEvent<T> >;
-
-/** Content used by the segment loader as a context to load a new segment. */
-export interface ISegmentLoaderContent { manifest : Manifest;
-                                         period : Period;
-                                         adaptation : Adaptation;
-                                         representation : Representation;
-                                         segment : ISegment; }
-
-/**
- * Returns a function allowing to load any wanted segment.
- *
- * The function returned takes in argument information about the wanted segment
- * and returns an Observable which will emit various events related to the
- * segment request (see ISegmentLoaderEvent).
- *
- * This observable will throw if, following the options given, the request and
- * possible retry all failed.
- *
- * This observable will complete after emitting all the segment's data.
- *
- * Type parameters:
- *   - T: type of the data emitted
- *
- * @param {Function} loader
- * @param {Object | undefined} cache
- * @param {Object} options
- * @returns {Function}
- */
-export default function createSegmentLoader<T>(
-  loader : ISegmentPipelineLoader<T>,
-  cache : ISegmentLoaderCache<T> | undefined,
-  backoffOptions : IBackoffOptions
-) : (x : ISegmentLoaderContent) => Observable<ISegmentLoaderEvent<T>> {
-  /**
-   * Try to retrieve the segment from the cache and if not found call the
-   * pipeline's loader (with possible retries) to load it.
-   * @param {Object} loaderArgument - Context for the wanted segment.
-   * @returns {Observable}
-   */
-  function loadData(
-    wantedContent : ISegmentLoaderContent
-  ) : Observable< ITransportSegmentLoaderEvent<T> |
-                  ISegmentLoaderRequest |
-                  ISegmentLoaderWarning |
-                  ISegmentLoaderCachedSegmentEvent<T>>
-  {
-
-    /**
-     * Call the Pipeline's loader with an exponential Backoff.
-     * @returns {Observable}
-     */
-    function startLoaderWithBackoff(
-    ) : Observable< ITransportSegmentLoaderEvent<T> |
-                    ISegmentLoaderRequest |
-                    ISegmentLoaderWarning >
-    {
-      const request$ = (url : string | null) => {
-        const loaderArgument = objectAssign({ url }, wantedContent);
-        return observableConcat(
-          observableOf({ type: "request" as const, value: loaderArgument }),
-          tryCatch(loader, loaderArgument));
-      };
-      return tryURLsWithBackoff(wantedContent.segment.mediaURLs ?? [null],
-                                request$,
-                                backoffOptions).pipe(
-        catchError((error : unknown) : Observable<never> => {
-          throw errorSelector(error);
-        }),
-
-        map((evt) : ITransportSegmentLoaderEvent<T> |
-                    ISegmentLoaderWarning |
-                    ISegmentLoaderRequest => {
-          if (evt.type === "retry") {
-            return { type: "warning" as const,
-                     value: errorSelector(evt.value) };
-          } else if (evt.value.type === "request") {
-            return evt.value;
-          }
-
-          const response = evt.value;
-          if (response.type === "data-loaded" && cache != null) {
-            cache.add(wantedContent, response.value);
-          }
-          return evt.value;
-        }));
-    }
-
-    const dataFromCache = cache != null ? cache.get(wantedContent) :
-                                          null;
-
-    if (dataFromCache != null) {
-      return castToObservable(dataFromCache).pipe(
-        map(response => ({ type: "cache" as const, value: response })),
-        catchError(startLoaderWithBackoff)
-      );
-    }
-
-    return startLoaderWithBackoff();
-  }
-
-  /**
-   * Load the corresponding segment.
-   * @param {Object} content
-   * @returns {Observable}
-   */
-  return function loadSegment(
-    content : ISegmentLoaderContent
-  ) : Observable<ISegmentLoaderEvent<T>> {
-    return loadData(content).pipe(
-      mergeMap((arg) : Observable<ISegmentLoaderEvent<T>> => {
-        let metrics$ : Observable<IABRMetricsEvent>;
-        if ((arg.type === "data-chunk-complete" || arg.type === "data-loaded") &&
-            arg.value.size !== undefined && arg.value.duration !== undefined)
-        {
-          metrics$ = observableOf({ type: "metrics",
-                                    value: { size: arg.value.size,
-                                             duration: arg.value.duration,
-                                             content } });
-        } else {
-          metrics$ = EMPTY;
-        }
-
-        switch (arg.type) {
-          case "warning":
-          case "request":
-          case "progress":
-            return observableOf(arg);
-          case "cache":
-          case "data-created":
-          case "data-loaded":
-            return observableConcat(observableOf({ type: "data" as const,
-                                                   value: arg.value }),
-                                    metrics$);
-
-          case "data-chunk":
-            return observableOf({ type: "chunk", value: arg.value });
-          case "data-chunk-complete":
-            return observableConcat(observableOf({ type: "chunk-complete" as const,
-                                                   value: null }),
-                                    metrics$);
-
-          default:
-            assertUnreachable(arg);
-        }
-      }));
-  };
-}

package/src/core/fetchers/segment/get_segment_backoff_options.ts

@@ -1,45 +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 config from "../../../config";
-import { IBackoffOptions } from "../utils/try_urls_with_backoff";
-
-const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
-        DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
-        INITIAL_BACKOFF_DELAY_BASE,
-        MAX_BACKOFF_DELAY_BASE } = config;
-
-/**
- * @param {string} bufferType
- * @param {Object}
- * @returns {Object}
- */
-export default function getSegmentBackoffOptions(
-  bufferType : string,
-  { maxRetryRegular,
-    maxRetryOffline,
-    lowLatencyMode } : { maxRetryRegular? : number;
-                         maxRetryOffline? : number;
-                         lowLatencyMode : boolean; }
-) : IBackoffOptions {
-  return { maxRetryRegular: bufferType === "image" ? 0 :
-                            maxRetryRegular ?? DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
-           maxRetryOffline: maxRetryOffline ?? DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
-           baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
-                                       INITIAL_BACKOFF_DELAY_BASE.REGULAR,
-           maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-                                      MAX_BACKOFF_DELAY_BASE.REGULAR };
-}

package/src/core/fetchers/utils/create_request_scheduler.ts

@@ -1,56 +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,
-  Subject,
-} from "rxjs";
-import { catchError } from "rxjs/operators";
-import { ICustomError } from "../../../errors";
-import filterMap from "../../../utils/filter_map";
-import tryCatch from "../../../utils/rx-try_catch";
-import errorSelector from "./error_selector";
-import {
-  IBackoffEvent,
-  IBackoffOptions,
-  tryRequestObservableWithBackoff,
-} from "./try_urls_with_backoff";
-
-export default function createRequestScheduler<T>(
-  backoffOptions : IBackoffOptions,
-  warning$ : Subject<ICustomError>
-) : ((fn: () => Observable<T>) => Observable<T>) {
-
-  /**
-   * Allow the parser to schedule a new request.
-   * @param {Function} request - Function performing the request.
-   * @returns {Function}
-   */
-  return function scheduleRequest(request : () => Observable<T>) : Observable<T> {
-    return tryRequestObservableWithBackoff(tryCatch(request, undefined),
-                                           backoffOptions).pipe(
-      filterMap<IBackoffEvent<T>, T, null>((evt) => {
-        if (evt.type === "retry") {
-          warning$.next(errorSelector(evt.value));
-          return null;
-        }
-        return evt.value;
-      }, null),
-      catchError((error : unknown) : Observable<never> => {
-        throw errorSelector(error);
-      }));
-  };
-}

package/src/core/init/create_stream_clock.ts

@@ -1,94 +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 {
-  combineLatest as observableCombineLatest,
-  merge as observableMerge,
-  Observable,
-} from "rxjs";
-import {
-  ignoreElements,
-  map,
-  tap,
-} from "rxjs/operators";
-import Manifest from "../../manifest";
-import { IStreamOrchestratorClockTick } from "../stream";
-import { IInitClockTick } from "./types";
-
-export interface IStreamClockArguments {
-  autoPlay : boolean; // If true, the player will auto-play when initialPlay$ emits
-  initialPlay$ : Observable<unknown>; // The initial play has been done
-  initialSeek$ : Observable<unknown>; // The initial seek has been done
-  manifest : Manifest;
-  speed$ : Observable<number>; // The last speed requested by the user
-  startTime : number; // The time the player will seek when initialSeek$ emits
-}
-
-/**
- * Create clock Observable for the `Stream` part of the code.
- * @param {Observable} initClock$
- * @param {Object} streamClockArgument
- * @returns {Observable}
- */
-export default function createStreamClock(
-  initClock$ : Observable<IInitClockTick>,
-  { autoPlay,
-    initialPlay$,
-    initialSeek$,
-    manifest,
-    speed$,
-    startTime } : IStreamClockArguments
-) : Observable<IStreamOrchestratorClockTick> {
-  let initialPlayPerformed = false;
-  let initialSeekPerformed = false;
-
-  const updateIsPaused$ = initialPlay$.pipe(
-    tap(() => { initialPlayPerformed = true; }),
-    ignoreElements());
-
-  const updateTimeOffset$ = initialSeek$.pipe(
-    tap(() => { initialSeekPerformed = true; }),
-    ignoreElements());
-
-  const clock$ : Observable<IStreamOrchestratorClockTick> =
-    observableCombineLatest([initClock$, speed$])
-      .pipe(map(([tick, speed]) => {
-        const { isLive } = manifest;
-        return {
-          position: tick.position,
-          getCurrentTime: tick.getCurrentTime,
-          duration: tick.duration,
-          isPaused: initialPlayPerformed ? tick.paused :
-                                           !autoPlay,
-          liveGap: isLive ? manifest.getMaximumPosition() - tick.position :
-                            Infinity,
-          readyState: tick.readyState,
-          speed,
-          stalled: tick.stalled,
-
-          // wantedTimeOffset is an offset to add to the timing's current time to have
-          // the "real" wanted position.
-          // For now, this is seen when the media element has not yet seeked to its
-          // initial position, the currentTime will most probably be 0 where the
-          // effective starting position will be _startTime_.
-          // Thus we initially set a wantedTimeOffset equal to startTime.
-          wantedTimeOffset: initialSeekPerformed ? 0 :
-                                                   startTime - tick.position,
-        };
-      }));
-
-  return observableMerge(updateIsPaused$, updateTimeOffset$, clock$);
-}

package/src/core/stream/utils.ts

@@ -1,97 +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,
-  of as observableOf,
-} from "rxjs";
-import {
-  map,
-  mergeMap,
-  take,
-} from "rxjs/operators";
-import { Period } from "../../manifest";
-import EVENTS from "./events_generators";
-import { INeedsMediaSourceReload } from "./types";
-
-/**
- * Switching to another `Adaptation` and or `Representation` can necessitate a
- * complete reload of the MediaSource.
- *
- * This is done through the `INeedsMediaSourceReload` event which among other
- * things indicate the position the player should seek to after "reloading".
- * That position depends on the playback conditions at the time of the switch.
- *
- * When you already know you have to reload, you can call this function to take
- * care of that complex behavior:
- *
- *   - If `period` is not being played when that function is called, this
- *     function will emit regularly the `INeedsMediaSourceReload` event after
- *     applying the given `deltaPos` value to the reloading position.
- *
- *   - If `period` is not being when that function is called, it emits regularly
- *     the `INeedsMediaSourceReload` without applying the given `deltaPos` value
- *     to the reloading position.
- *     This is because that value is only applied when the previous Adaptation
- *     or Representation for the current Period was being played and should not
- *     be for cases like entering the current Period, or seeking _into_ th
- *     current Period.
- *     The main point of that configuration variable being to give back some
- *     context, there is no context to give back on those cases (as the Period
- *     was not already playing).
- *
- * @param {Object} period - The Period linked to the Adaptation or
- * Representation that you want to switch to.
- * @param {Observable} clock$ - Observable emitting playback conditions.
- * Has to emit last playback conditions immediately on subscribe.
- * @param {number} deltaPos - If the concerned Period is playing at the time
- * this function is called, we will add this value, in seconds, to the current
- * position to indicate the position we should reload at.
- * This value allows to give back context (by replaying some media data) after
- * a switch.
- * @returns {Observable}
- */
-export default function reloadAfterSwitch(
-  period : Period,
-  clock$ : Observable<{
-    getCurrentTime : () => number;
-    position : number;
-    isPaused : boolean;
-  }>,
-  deltaPos : number
-) : Observable<INeedsMediaSourceReload> {
-  return clock$.pipe(
-    take(1), // only the first (current) event interests us here
-    mergeMap((initialTick) => {
-      if (period.start <= initialTick.position &&
-          (period.end === undefined || period.end > initialTick.position))
-      {
-        // if the Period was playing at the time of the switch
-        const pos = initialTick.getCurrentTime() + deltaPos;
-        const reloadAt = Math.min(Math.max(period.start, pos),
-                                  period.end ?? Infinity);
-        return observableOf(EVENTS.needsMediaSourceReload(period,
-                                                          reloadAt,
-                                                          !initialTick.isPaused));
-      }
-
-      // If the Period was not playing, just ask to reload to the exact same position
-      return clock$.pipe(
-        map(tick => EVENTS.needsMediaSourceReload(period,
-                                                  tick.getCurrentTime(),
-                                                  !tick.isPaused)));
-    }));
-}

package/src/parsers/manifest/dash/common/extract_minimum_availability_time_offset.ts

@@ -1,41 +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 { IBaseUrlIntermediateRepresentation } from "../node_parser_types";
-
-/**
- * From 0 to N baseURL elements takes the minimum availabilityTimeOffset
- * possible.
- *
- * `0` if no baseURL was given (which means `no delay added`: coherent with how
- * this value is used).
- *
- * Taking the minimum time allow to simplify its processing:
- * Instead of having multiple URL each with a different pool of available
- * segment at a given instant, let's always consider every URLs by aligning with
- * the one with the most segment.
- *
- * @param {Array.<Object>} baseURLs
- */
-export default function extractMinimumAvailabilityTimeOffset(
-  baseURLs : IBaseUrlIntermediateRepresentation[]
-) : number {
-  return baseURLs.length === 0 ?
-    0 :
-    baseURLs.reduce((acc, baseURL) => {
-      return Math.min(baseURL.attributes.availabilityTimeOffset ?? 0, acc);
-    }, Infinity);
-}

package/src/transports/utils/return_parsed_manifest.ts

@@ -1,47 +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 {
-  concat as observableConcat,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import Manifest from "../../manifest";
-import {
-  IManifestParserResponseEvent,
-  IManifestParserWarningEvent,
-} from "../types";
-
-/**
- * As a Manifest instance is obtained, emit the right `warning` events
- * (according to the Manifest's `parsingErrors` property`) followed by the right
- * `parsed` event, as expected from a Manifest parser.
- * @param {Manifest} manifest
- * @param {string|undefined} url
- * @returns {Observable}
- */
-export default function returnParsedManifest(
-  manifest : Manifest,
-  url? : string
-) : Observable<IManifestParserWarningEvent | IManifestParserResponseEvent> {
-  const warningEvts$ = observableOf(...manifest.parsingErrors.map(error => ({
-    type: "warning" as const,
-    value: error,
-  })));
-  return observableConcat(warningEvts$,
-                          observableOf({ type: "parsed" as const,
-                                         value: { manifest, url } }));
-}