rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/es2017/experimental/tools/VideoThumbnailLoader/load_and_push_segment.js

@@ -0,0 +1,60 @@
+/**
+ * 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 log from "../../../log";
+/**
+ * @param {Object} segmentInfo
+ * @param {Object} sourceBufferInterface
+ * @param {Object} segmentFetcher
+ * @param {Object} cancelSignal
+ * @returns {Promise}
+ */
+export default function loadAndPushSegment(segmentInfo, sourceBufferInterface, segmentFetcher, cancelSignal) {
+    const pushOperations = [];
+    return segmentFetcher(segmentInfo, {
+        onChunk(parseChunk) {
+            const parsed = parseChunk(undefined);
+            let data;
+            let timestampOffset;
+            const codec = segmentInfo.representation.getMimeTypeString();
+            if (parsed.segmentType === "init") {
+                data = parsed.initializationData;
+                timestampOffset = 0;
+            }
+            else {
+                data = parsed.chunkData;
+                timestampOffset = parsed.chunkOffset;
+            }
+            let pushOperation;
+            if (data === null) {
+                pushOperation = Promise.resolve(null);
+            }
+            else {
+                pushOperation = sourceBufferInterface.appendBuffer(data, {
+                    appendWindow: [segmentInfo.period.start, segmentInfo.period.end],
+                    timestampOffset,
+                    codec,
+                });
+            }
+            pushOperations.push(pushOperation);
+        },
+        onAllChunksReceived() {
+            return;
+        },
+        onRetry(error) {
+            log.warn("VideoThumbnailLoader", "Retrying segment request", error);
+        },
+    }, cancelSignal).then(() => Promise.all(pushOperations));
+}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 type { IMediaElement } from "../../../compat/browser_compatibility_types";
+import type { MainSourceBufferInterface } from "../../../mse/main_media_source_interface";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+/**
+ * Open the media source and create the `MainMediaSourceInterface`.
+ * @param {HTMLVideoElement} videoElement
+ * @param {string} codec
+ * @param {Object} cleanUpSignal
+ * @returns {Promise.<Object>}
+ */
+export default function prepareSourceBuffer(videoElement: IMediaElement, codec: string, cleanUpSignal: CancellationSignal): Promise<MainSourceBufferInterface>;
+//# sourceMappingURL=prepare_source_buffer.d.ts.map

package/dist/es2017/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare_source_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAKjF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AAM1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAIxE;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,YAAY,EAAE,aAAa,EAC3B,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,kBAAkB,GAChC,OAAO,CAAC,yBAAyB,CAAC,CA8CpC"}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.js

@@ -0,0 +1,72 @@
+/**
+ * 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 { MediaSource_ } from "../../../compat/browser_compatibility_types";
+import disableRemotePlaybackOnManagedMediaSource from "../../../compat/disable_remote_playback_on_managed_media_source";
+import resetMediaElement from "../../../compat/reset_media_element";
+import log from "../../../log";
+import MainMediaSourceInterface from "../../../mse/main_media_source_interface";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
+import idGenerator from "../../../utils/id_generator";
+import isNonEmptyString from "../../../utils/is_non_empty_string";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+const generateMediaSourceId = idGenerator();
+/**
+ * Open the media source and create the `MainMediaSourceInterface`.
+ * @param {HTMLVideoElement} videoElement
+ * @param {string} codec
+ * @param {Object} cleanUpSignal
+ * @returns {Promise.<Object>}
+ */
+export default function prepareSourceBuffer(videoElement, codec, cleanUpSignal) {
+    return createCancellablePromise(cleanUpSignal, (resolve, reject) => {
+        if (isNullOrUndefined(MediaSource_)) {
+            throw new Error("No MediaSource Object was found in the current browser.");
+        }
+        // make sure the media has been correctly reset
+        const oldSrc = isNonEmptyString(videoElement.src) ? videoElement.src : null;
+        resetMediaElement(videoElement, oldSrc);
+        log.info("VideoThumbnailLoader", "Creating MediaSource");
+        const mediaSource = new MainMediaSourceInterface(generateMediaSourceId());
+        if (mediaSource.handle.type === "handle") {
+            videoElement.srcObject = mediaSource.handle.value;
+            cleanUpSignal.register(() => {
+                resetMediaElement(videoElement, null);
+            });
+        }
+        else {
+            const objectURL = URL.createObjectURL(mediaSource.handle.value);
+            log.info("VideoThumbnailLoader", "Attaching MediaSource URL to the media element", objectURL);
+            videoElement.src = objectURL;
+            cleanUpSignal.register(() => {
+                resetMediaElement(videoElement, objectURL);
+            });
+        }
+        disableRemotePlaybackOnManagedMediaSource(videoElement, cleanUpSignal);
+        mediaSource.addEventListener("mediaSourceOpen", onSourceOpen);
+        return () => {
+            mediaSource.removeEventListener("mediaSourceOpen", onSourceOpen);
+        };
+        function onSourceOpen() {
+            try {
+                mediaSource.removeEventListener("mediaSourceOpen", onSourceOpen);
+                resolve(mediaSource.addSourceBuffer("video" /* SourceBufferType.Video */, codec));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }
+    });
+}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 type { IMediaElement } from "../../../compat/browser_compatibility_types";
+import type { MainSourceBufferInterface } from "../../../mse/main_media_source_interface";
+/**
+ * Remove buffer around wanted time, considering a margin around
+ * it that defines what must be kept :
+ * If time is 10 and margin is 2, cleaned ranges will be :
+ * [0, 8] and [12, videoElement.duration]
+ * @param {HTMLMediaElement} videoElement
+ * @param {Object} sourceBufferInterface
+ * @param {Number} time
+ * @param {Number|undefined} margin
+ * @returns {Promise}
+ */
+export default function removeBufferAroundTime(videoElement: IMediaElement, sourceBufferInterface: MainSourceBufferInterface, time: number, margin: number | undefined): Promise<unknown>;
+//# sourceMappingURL=remove_buffer_around_time.d.ts.map

package/dist/es2017/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove_buffer_around_time.d.ts","sourceRoot":"","sources":["../../../../../src/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AAE1F;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,YAAY,EAAE,aAAa,EAC3B,qBAAqB,EAAE,yBAAyB,EAChD,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,OAAO,CAAC,OAAO,CAAC,CAelB"}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.js

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+/**
+ * Remove buffer around wanted time, considering a margin around
+ * it that defines what must be kept :
+ * If time is 10 and margin is 2, cleaned ranges will be :
+ * [0, 8] and [12, videoElement.duration]
+ * @param {HTMLMediaElement} videoElement
+ * @param {Object} sourceBufferInterface
+ * @param {Number} time
+ * @param {Number|undefined} margin
+ * @returns {Promise}
+ */
+export default function removeBufferAroundTime(videoElement, sourceBufferInterface, time, margin) {
+    const removalMargin = margin !== null && margin !== void 0 ? margin : 10 * 60;
+    if (videoElement.buffered.length === 0) {
+        return Promise.resolve();
+    }
+    const bufferRemovals = [];
+    if (time - removalMargin > 0) {
+        bufferRemovals.push(sourceBufferInterface.remove(0, time - removalMargin));
+    }
+    if (time + removalMargin < videoElement.duration) {
+        bufferRemovals.push(sourceBufferInterface.remove(time + removalMargin, videoElement.duration));
+    }
+    return Promise.all(bufferRemovals);
+}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 type { IManifest, IAdaptation, IPeriod, IRepresentation } from "../../../manifest";
+import type { ISegmentParser, ITransportPipelines } from "../../../transports";
+export interface IContentInfo {
+    manifest: IManifest;
+    period: IPeriod;
+    adaptation: IAdaptation;
+    representation: IRepresentation;
+}
+export type ILoaders = Partial<Record<string, ITransportPipelines>>;
+export type IThumbnailLoaderSegmentParser = ISegmentParser<Uint8Array | ArrayBuffer | null, Uint8Array | ArrayBuffer | null>;
+//# sourceMappingURL=types.d.ts.map

package/dist/es2017/experimental/tools/VideoThumbnailLoader/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/experimental/tools/VideoThumbnailLoader/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC1F,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/E,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,WAAW,CAAC;IACxB,cAAc,EAAE,eAAe,CAAC;CACjC;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;AAEpE,MAAM,MAAM,6BAA6B,GAAG,cAAc,CACxD,UAAU,GAAG,WAAW,GAAG,IAAI,EAC/B,UAAU,GAAG,WAAW,GAAG,IAAI,CAChC,CAAC"}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/types.js

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 type { IRxPlayer } from "../../../main_thread/types";
+import type { ILoaders } from "./types";
+/**
+ * This tool, as a supplement to the RxPlayer, intent to help creating thumbnails
+ * from a video source.
+ *
+ * The tools will extract a "thumbnail track" either from a video track (whose light
+ * chunks are adapted from such use case) or direclty from the media content.
+ */
+export default class VideoThumbnailLoader {
+    private readonly _videoElement;
+    private _player;
+    private _lastRepresentationInfo;
+    constructor(videoElement: HTMLVideoElement, player: IRxPlayer);
+    /**
+     * Add imported loader to thumbnail loader loader object.
+     * It allows to use it when setting time.
+     * @param {function} loaderFunc
+     */
+    static addLoader(loaderFunc: (features: ILoaders) => void): void;
+    /**
+     * Set time of thumbnail video media element :
+     * - Remove buffer when too much buffered data
+     * - Search for thumbnail track element to display
+     * - Load data
+     * - Append data
+     * Resolves when time is set.
+     * @param {number} time
+     * @returns {Promise}
+     */
+    setTime(time: number): Promise<number>;
+    /**
+     * Dispose thumbnail loader.
+     * @returns {void}
+     */
+    dispose(): void;
+}
+export { default as DASH_LOADER } from "./features/dash";
+export { default as MPL_LOADER } from "./features/metaplaylist";
+//# sourceMappingURL=video_thumbnail_loader.d.ts.map

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video_thumbnail_loader.d.ts","sourceRoot":"","sources":["../../../../../src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAW5D,OAAO,KAAK,EAAgB,QAAQ,EAAE,MAAM,SAAS,CAAC;AAOtD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IACjD,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,uBAAuB,CAAiD;gBAEpE,YAAY,EAAE,gBAAgB,EAAE,MAAM,EAAE,SAAS;IAM7D;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;IAIhE;;;;;;;;;OASG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA0PtC;;;OAGG;IACH,OAAO,IAAI,IAAI;CAMhB;AA+GD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.js

@@ -0,0 +1,281 @@
+/**
+ * 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 createSegmentFetcher from "../../../core/fetchers/segment/segment_fetcher";
+import log from "../../../log";
+import Manifest from "../../../manifest/classes";
+import arrayFind from "../../../utils/array_find";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import objectAssign from "../../../utils/object_assign";
+import TaskCanceller, { CancellationError } from "../../../utils/task_canceller";
+import loadAndPushSegment from "./load_and_push_segment";
+import prepareSourceBuffer from "./prepare_source_buffer";
+import removeBufferAroundTime from "./remove_buffer_around_time";
+import VideoThumbnailLoaderError from "./video_thumbnail_loader_error";
+const MIN_NEEDED_DATA_AFTER_TIME = 2;
+const loaders = {};
+/**
+ * This tool, as a supplement to the RxPlayer, intent to help creating thumbnails
+ * from a video source.
+ *
+ * The tools will extract a "thumbnail track" either from a video track (whose light
+ * chunks are adapted from such use case) or direclty from the media content.
+ */
+export default class VideoThumbnailLoader {
+    constructor(videoElement, player) {
+        this._videoElement = videoElement;
+        this._player = player;
+        this._lastRepresentationInfo = null;
+    }
+    /**
+     * Add imported loader to thumbnail loader loader object.
+     * It allows to use it when setting time.
+     * @param {function} loaderFunc
+     */
+    static addLoader(loaderFunc) {
+        loaderFunc(loaders);
+    }
+    /**
+     * Set time of thumbnail video media element :
+     * - Remove buffer when too much buffered data
+     * - Search for thumbnail track element to display
+     * - Load data
+     * - Append data
+     * Resolves when time is set.
+     * @param {number} time
+     * @returns {Promise}
+     */
+    setTime(time) {
+        // TODO cleaner way to interop than an undocumented method?
+        const manifest = this._player.__priv_getManifest();
+        if (manifest === null) {
+            if (this._lastRepresentationInfo !== null) {
+                this._lastRepresentationInfo.cleaner.cancel("VTL: no manifest");
+                this._lastRepresentationInfo = null;
+            }
+            return Promise.reject(new VideoThumbnailLoaderError("NO_MANIFEST", "No manifest available."));
+        }
+        if (!(manifest instanceof Manifest)) {
+            throw new Error("Impossible to run VideoThumbnailLoader in the current context.\n" +
+                "Are you running the RxPlayer in a WebWorker?");
+        }
+        const content = getTrickModeInfo(time, manifest);
+        if (content === null) {
+            if (this._lastRepresentationInfo !== null) {
+                this._lastRepresentationInfo.cleaner.cancel("VTL: no trickmode");
+                this._lastRepresentationInfo = null;
+            }
+            return Promise.reject(new VideoThumbnailLoaderError("NO_TRACK", "Couldn't find a trickmode track for this time."));
+        }
+        if (this._lastRepresentationInfo !== null &&
+            !areSameRepresentation(this._lastRepresentationInfo.content, content)) {
+            this._lastRepresentationInfo.cleaner.cancel("VTL: Representation is different");
+            this._lastRepresentationInfo = null;
+        }
+        const neededSegments = content.representation.index.getSegments(time, MIN_NEEDED_DATA_AFTER_TIME);
+        if (neededSegments.length === 0) {
+            if (this._lastRepresentationInfo !== null) {
+                this._lastRepresentationInfo.cleaner.cancel("VTL: no segment info");
+                this._lastRepresentationInfo = null;
+            }
+            return Promise.reject(new VideoThumbnailLoaderError("NO_THUMBNAIL", "Couldn't find any thumbnail for the given time."));
+        }
+        // Check which of `neededSegments` are already buffered
+        for (let j = 0; j < neededSegments.length; j++) {
+            const { time: stime, duration, timescale } = neededSegments[j];
+            const start = stime / timescale;
+            const end = start + duration / timescale;
+            for (let i = 0; i < this._videoElement.buffered.length; i++) {
+                if (this._videoElement.buffered.start(i) - 0.001 <= start &&
+                    this._videoElement.buffered.end(i) + 0.001 >= end) {
+                    neededSegments.splice(j, 1);
+                    j--;
+                    break;
+                }
+            }
+        }
+        if (neededSegments.length === 0) {
+            this._videoElement.currentTime = time;
+            log.debug("VideoThumbnailLoader", "Thumbnails already loaded.", time);
+            return Promise.resolve(time);
+        }
+        if (log.hasLevel("DEBUG")) {
+            log.debug("VideoThumbnailLoader", "Found thumbnail for time", time, neededSegments.map((s) => `start: ${s.time} - end: ${s.end}`).join(", "));
+        }
+        const loader = loaders[content.manifest.transport];
+        if (loader === undefined) {
+            if (this._lastRepresentationInfo !== null) {
+                this._lastRepresentationInfo.cleaner.cancel("VTL: no parser");
+                this._lastRepresentationInfo = null;
+            }
+            return Promise.reject(new VideoThumbnailLoaderError("NO_LOADER", "VideoThumbnailLoaderError: No imported loader for this transport type: " +
+                content.manifest.transport));
+        }
+        let lastRepInfo;
+        if (this._lastRepresentationInfo === null) {
+            const lastRepInfoCleaner = new TaskCanceller("VTL: Representation Info");
+            const segmentFetcher = createSegmentFetcher({
+                bufferType: "video",
+                pipeline: loader.video,
+                cdnPrioritizer: null,
+                cmcdDataBuilder: null,
+                requestOptions: {
+                    baseDelay: 0,
+                    maxDelay: 0,
+                    maxRetry: 0,
+                    requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                    connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+                },
+                // We don't care about the SegmentFetcher's lifecycle events
+                eventListeners: {},
+            });
+            const initSegment = content.representation.index.getInitSegment();
+            const initSegmentUniqueId = initSegment !== null ? content.representation.uniqueId : null;
+            const sourceBufferProm = prepareSourceBuffer(this._videoElement, content.representation.getMimeTypeString(), lastRepInfoCleaner.signal).then(async (sourceBufferInterface) => {
+                if (initSegment === null || initSegmentUniqueId === null) {
+                    lastRepInfo.initSegmentUniqueId = null;
+                    return sourceBufferInterface;
+                }
+                const segmentInfo = objectAssign({ segment: initSegment, nextSegment: undefined }, content);
+                await loadAndPushSegment(segmentInfo, sourceBufferInterface, lastRepInfo.segmentFetcher, lastRepInfoCleaner.signal);
+                return sourceBufferInterface;
+            });
+            lastRepInfo = {
+                cleaner: lastRepInfoCleaner,
+                sourceBuffer: sourceBufferProm,
+                content,
+                initSegmentUniqueId,
+                segmentFetcher,
+                pendingRequests: [],
+            };
+            this._lastRepresentationInfo = lastRepInfo;
+        }
+        else {
+            lastRepInfo = this._lastRepresentationInfo;
+        }
+        abortUnlistedSegmentRequests(lastRepInfo.pendingRequests, neededSegments);
+        const currentTaskCanceller = new TaskCanceller("VTL: Task");
+        return lastRepInfo.sourceBuffer
+            .catch((err) => {
+            if (this._lastRepresentationInfo !== null) {
+                this._lastRepresentationInfo.cleaner.cancel("VTL: SourceBuffer initialization failure");
+                this._lastRepresentationInfo = null;
+            }
+            throw new VideoThumbnailLoaderError("LOADING_ERROR", "VideoThumbnailLoaderError: Error when initializing buffers: " + String(err));
+        })
+            .then(async (sourceBufferInterface) => {
+            abortUnlistedSegmentRequests(lastRepInfo.pendingRequests, neededSegments);
+            log.debug("VideoThumbnailLoader", "Removing buffer around time.", time);
+            await removeBufferAroundTime(this._videoElement, sourceBufferInterface, time, undefined);
+            if (currentTaskCanceller.signal.cancellationError !== null) {
+                throw currentTaskCanceller.signal.cancellationError;
+            }
+            abortUnlistedSegmentRequests(lastRepInfo.pendingRequests, neededSegments);
+            const promises = [];
+            for (const segment of neededSegments) {
+                const pending = arrayFind(lastRepInfo.pendingRequests, ({ segmentId }) => segmentId === segment.id);
+                if (pending !== undefined) {
+                    promises.push(pending.promise);
+                }
+                else {
+                    const requestCanceller = new TaskCanceller("VTL: Request");
+                    const unlinkSignal = requestCanceller.linkToSignal(lastRepInfo.cleaner.signal);
+                    const segmentInfo = objectAssign({ segment, nextSegment: undefined }, content);
+                    const prom = loadAndPushSegment(segmentInfo, sourceBufferInterface, lastRepInfo.segmentFetcher, requestCanceller.signal).then(unlinkSignal, (err) => {
+                        unlinkSignal();
+                        throw err;
+                    });
+                    const newReq = {
+                        segmentId: segment.id,
+                        canceller: requestCanceller,
+                        promise: prom,
+                    };
+                    lastRepInfo.pendingRequests.push(newReq);
+                    const removePendingRequest = () => {
+                        const indexOf = lastRepInfo.pendingRequests.indexOf(newReq);
+                        if (indexOf >= 0) {
+                            lastRepInfo.pendingRequests.splice(indexOf, 1);
+                        }
+                    };
+                    prom.then(removePendingRequest, removePendingRequest);
+                    promises.push(prom);
+                }
+            }
+            await Promise.all(promises);
+            this._videoElement.currentTime = time;
+            return time;
+        })
+            .catch((err) => {
+            if (err instanceof CancellationError) {
+                throw new VideoThumbnailLoaderError("ABORTED", "VideoThumbnailLoaderError: Aborted job.");
+            }
+            throw err;
+        });
+    }
+    /**
+     * Dispose thumbnail loader.
+     * @returns {void}
+     */
+    dispose() {
+        if (this._lastRepresentationInfo !== null) {
+            this._lastRepresentationInfo.cleaner.cancel("VTL: dispose");
+            this._lastRepresentationInfo = null;
+        }
+    }
+}
+/**
+ * @param {Object} contentInfo1
+ * @param {Object} contentInfo2
+ * @returns {Boolean}
+ */
+function areSameRepresentation(contentInfo1, contentInfo2) {
+    return (contentInfo1.representation.id === contentInfo2.representation.id &&
+        contentInfo1.adaptation.id === contentInfo2.adaptation.id &&
+        contentInfo1.period.id === contentInfo2.period.id &&
+        contentInfo1.manifest.id === contentInfo2.manifest.id);
+}
+/**
+ * From a given time, find the trickmode representation and return
+ * the content information.
+ * @param {number} time
+ * @param {Object} manifest
+ * @returns {Object|null}
+ */
+function getTrickModeInfo(time, manifest) {
+    var _a, _b;
+    const period = manifest.getPeriodForTime(time);
+    if (period === undefined ||
+        period.adaptations.video === undefined ||
+        period.adaptations.video.length === 0) {
+        return null;
+    }
+    for (const videoAdaptation of period.adaptations.video) {
+        const representation = (_b = (_a = videoAdaptation.trickModeTracks) === null || _a === void 0 ? void 0 : _a[0].representations) === null || _b === void 0 ? void 0 : _b[0];
+        if (!isNullOrUndefined(representation)) {
+            return { manifest, period, adaptation: videoAdaptation, representation };
+        }
+    }
+    return null;
+}
+function abortUnlistedSegmentRequests(pendingRequests, neededSegments) {
+    pendingRequests
+        .filter((req) => !neededSegments.some(({ id }) => id === req.segmentId))
+        .forEach((req) => {
+        req.canceller.cancel("VTL: abort unlisted segments");
+    });
+}
+export { default as DASH_LOADER } from "./features/dash";
+export { default as MPL_LOADER } from "./features/metaplaylist";

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader_error.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+export default class VideoThumbnailLoaderError extends Error {
+    readonly name: "VideoThumbnailLoaderError";
+    readonly code: string;
+    /**
+     * @param {string} code
+     * @param {string} message
+     */
+    constructor(code: string, message: string);
+}
+//# sourceMappingURL=video_thumbnail_loader_error.d.ts.map

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video_thumbnail_loader_error.d.ts","sourceRoot":"","sources":["../../../../../src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader_error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,MAAM,CAAC,OAAO,OAAO,yBAA0B,SAAQ,KAAK;IAC1D,SAAgB,IAAI,EAAE,2BAA2B,CAAC;IAClD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;OAGG;gBACS,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAM1C"}