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

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -84,9 +84,15 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     /** Saved initialization segment state for this representation. */
     var initSegmentState = {
         segment: representation.index.getInitSegment(),
-        segmentData: null,
+        uniqueId: null,
         isLoaded: false,
     };
+    globalCanceller.signal.register(function () {
+        // Free initialization segment if one has been declared
+        if (initSegmentState.uniqueId !== null) {
+            segmentBuffer.freeInitSegment(initSegmentState.uniqueId);
+        }
+    });
     /** Emit the last scheduled downloading queue for segments. */
     var lastSegmentQueue = createSharedReference({
         initSegment: null,
@@ -95,7 +101,6 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     /** If `true`, the current Representation has a linked initialization segment. */
     var hasInitSegment = initSegmentState.segment !== null;
     if (!hasInitSegment) {
-        initSegmentState.segmentData = null;
         initSegmentState.isLoaded = true;
     }
     /**
@@ -303,16 +308,20 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                 evt.segmentList !== undefined) {
                 representation.index.initialize(evt.segmentList);
             }
-            initSegmentState.segmentData = evt.initializationData;
             initSegmentState.isLoaded = true;
-            pushInitSegment({ playbackObserver: playbackObserver, content: content, segment: evt.segment,
-                segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
-                .then(function (result) {
-                if (result !== null) {
-                    callbacks.addedSegment(result);
-                }
-            })
-                .catch(onFatalBufferError);
+            if (evt.initializationData !== null) {
+                var initSegmentUniqueId = representation.uniqueId;
+                initSegmentState.uniqueId = initSegmentUniqueId;
+                segmentBuffer.declareInitSegment(initSegmentUniqueId, evt.initializationData);
+                pushInitSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
+                    segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
+                    .then(function (result) {
+                    if (result !== null) {
+                        callbacks.addedSegment(result);
+                    }
+                })
+                    .catch(onFatalBufferError);
+            }
             // Sometimes the segment list is only known once the initialization segment
             // is parsed. Thus we immediately re-check if there's new segments to load.
             checkStatus();
@@ -335,8 +344,8 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                     return; // previous callback has stopped everything by side-effect
                 }
             }
-            var initSegmentData = initSegmentState.segmentData;
-            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentData: initSegmentData, parsedSegment: evt,
+            var initSegmentUniqueId = initSegmentState.uniqueId;
+            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
                 segment: evt.segment, segmentBuffer: segmentBuffer }, globalCanceller.signal)
                 .then(function (result) {
                 if (result !== null) {

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.d.ts

@@ -15,7 +15,7 @@
  */
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
-import { IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
+import { IInsertedChunkInfos, IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
 import { IRepresentationStreamPlaybackObservation } from "../types";
 /**
  * Append a segment to the given segmentBuffer.
@@ -27,4 +27,6 @@ import { IRepresentationStreamPlaybackObservation } from "../types";
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
-export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T>, cancellationSignal: CancellationSignal): Promise<void>;
+export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T> & {
+    inventoryInfos: IInsertedChunkInfos;
+}, cancellationSignal: CancellationSignal): Promise<void>;

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.js

@@ -87,7 +87,7 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                         reason = appendError_1 instanceof Error ?
                             appendError_1.toString() :
                             "An unknown error happened when pushing content";
-                        throw new MediaError("BUFFER_APPEND_ERROR", reason);
+                        throw new MediaError("BUFFER_APPEND_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
                     }
                     position = playbackObserver.getReference().getValue().position;
                     currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
@@ -105,7 +105,7 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                     err2_1 = _b.sent();
                     reason = err2_1 instanceof Error ? err2_1.toString() :
                         "Could not clean the buffer";
-                    throw new MediaError("BUFFER_FULL_ERROR", reason);
+                    throw new MediaError("BUFFER_FULL_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
                 case 7: return [3 /*break*/, 8];
                 case 8: return [2 /*return*/];
             }

package/dist/_esm5.processed/core/stream/representation/utils/push_init_segment.d.ts

@@ -24,7 +24,7 @@ import { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPaylo
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function pushInitSegment<T>({ playbackObserver, content, segment, segmentData, segmentBuffer, }: {
+export default function pushInitSegment<T>({ playbackObserver, content, initSegmentUniqueId, segment, segmentData, segmentBuffer, }: {
     playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
     content: {
         adaptation: Adaptation;
@@ -32,7 +32,8 @@ export default function pushInitSegment<T>({ playbackObserver, content, segment,
         period: Period;
         representation: Representation;
     };
-    segmentData: T | null;
+    initSegmentUniqueId: string;
+    segmentData: T;
     segment: ISegment;
     segmentBuffer: SegmentBuffer;
 }, cancelSignal: CancellationSignal): Promise<IStreamEventAddedSegmentPayload<T> | null>;

package/dist/_esm5.processed/core/stream/representation/utils/push_init_segment.js

@@ -49,6 +49,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+import objectAssign from "../../../../utils/object_assign";
 import appendSegmentToBuffer from "./append_segment_to_buffer";
 /**
  * Push the initialization segment to the SegmentBuffer.
@@ -57,24 +58,23 @@ import appendSegmentToBuffer from "./append_segment_to_buffer";
  * @returns {Promise}
  */
 export default function pushInitSegment(_a, cancelSignal) {
-    var playbackObserver = _a.playbackObserver, content = _a.content, segment = _a.segment, segmentData = _a.segmentData, segmentBuffer = _a.segmentBuffer;
+    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentUniqueId = _a.initSegmentUniqueId, segment = _a.segment, segmentData = _a.segmentData, segmentBuffer = _a.segmentBuffer;
     return __awaiter(this, void 0, void 0, function () {
-        var codec, data, buffered;
+        var codec, data, inventoryInfos, buffered;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    if (segmentData === null) {
-                        return [2 /*return*/, null];
-                    }
                     if (cancelSignal.cancellationError !== null) {
                         throw cancelSignal.cancellationError;
                     }
                     codec = content.representation.getMimeTypeString();
-                    data = { initSegment: segmentData,
-                        chunk: null,
+                    data = { initSegmentUniqueId: initSegmentUniqueId, chunk: null,
                         timestampOffset: 0,
                         appendWindow: [undefined, undefined], codec: codec };
-                    return [4 /*yield*/, appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: null }, cancelSignal)];
+                    inventoryInfos = objectAssign({ segment: segment, chunkSize: undefined,
+                        start: 0,
+                        end: 0 }, content);
+                    return [4 /*yield*/, appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }, cancelSignal)];
                 case 1:
                     _b.sent();
                     buffered = segmentBuffer.getBufferedRanges();

package/dist/_esm5.processed/core/stream/representation/utils/push_media_segment.d.ts

@@ -25,7 +25,7 @@ import { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPaylo
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function pushMediaSegment<T>({ playbackObserver, content, initSegmentData, parsedSegment, segment, segmentBuffer }: {
+export default function pushMediaSegment<T>({ playbackObserver, content, initSegmentUniqueId, parsedSegment, segment, segmentBuffer }: {
     playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
     content: {
         adaptation: Adaptation;
@@ -33,7 +33,7 @@ export default function pushMediaSegment<T>({ playbackObserver, content, initSeg
         period: Period;
         representation: Representation;
     };
-    initSegmentData: T | null;
+    initSegmentUniqueId: string | null;
     parsedSegment: ISegmentParserParsedMediaChunk<T>;
     segment: ISegment;
     segmentBuffer: SegmentBuffer;

package/dist/_esm5.processed/core/stream/representation/utils/push_media_segment.js

@@ -60,7 +60,7 @@ import appendSegmentToBuffer from "./append_segment_to_buffer";
  */
 export default function pushMediaSegment(_a, cancelSignal) {
     var _b, _c;
-    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentData = _a.initSegmentData, parsedSegment = _a.parsedSegment, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
+    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentUniqueId = _a.initSegmentUniqueId, parsedSegment = _a.parsedSegment, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
     return __awaiter(this, void 0, void 0, function () {
         var chunkData, chunkInfos, chunkOffset, chunkSize, appendWindow, codec, APPEND_WINDOW_SECURITIES, safeAppendWindow, data, estimatedStart, estimatedDuration, estimatedEnd, inventoryInfos, buffered;
         return __generator(this, function (_d) {
@@ -83,8 +83,7 @@ export default function pushMediaSegment(_a, cancelSignal) {
                             appendWindow[1] + APPEND_WINDOW_SECURITIES.END :
                             undefined,
                     ];
-                    data = { initSegment: initSegmentData,
-                        chunk: chunkData,
+                    data = { initSegmentUniqueId: initSegmentUniqueId, chunk: chunkData,
                         timestampOffset: chunkOffset,
                         appendWindow: safeAppendWindow, codec: codec };
                     estimatedStart = (_b = chunkInfos === null || chunkInfos === void 0 ? void 0 : chunkInfos.time) !== null && _b !== void 0 ? _b : segment.time;

package/dist/_esm5.processed/default_config.d.ts

@@ -334,6 +334,31 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     SAMPLING_INTERVAL_NO_MEDIASOURCE: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
     /**
      * Minimum number of bytes sampled before we trust the estimate.
      * If we have not sampled much data, our estimate may not be accurate

package/dist/_esm5.processed/default_config.js

@@ -340,6 +340,31 @@ var DEFAULT_CONFIG = {
      * @type {Number}
      */
     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
@@ -375,8 +400,8 @@ var DEFAULT_CONFIG = {
      * @type {Object}
      */
     ABR_REGULAR_FACTOR: {
-        DEFAULT: 0.8,
-        LOW_LATENCY: 0.8,
+        DEFAULT: 0.72,
+        LOW_LATENCY: 0.72,
     },
     /**
      * If a media buffer has less than ABR_STARVATION_GAP in seconds ahead of the

package/dist/_esm5.processed/errors/index.d.ts

@@ -19,8 +19,8 @@ import EncryptedMediaError from "./encrypted_media_error";
 import { ErrorCodes, ErrorTypes, IErrorCode, IErrorType, NetworkErrorTypes } 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";
-export { AssertionError, CustomLoaderError, EncryptedMediaError, ErrorCodes, ErrorTypes, IErrorCode, IErrorType, formatError, MediaError as MediaError, NetworkError, OtherError, RequestError, NetworkErrorTypes, isKnownError, };
+export { AssertionError, CustomLoaderError, EncryptedMediaError, ErrorCodes, ErrorTypes, IErrorCode, IErrorType, IMediaErrorTrackContext, formatError, MediaError as MediaError, NetworkError, OtherError, RequestError, NetworkErrorTypes, isKnownError, };

package/dist/_esm5.processed/errors/media_error.d.ts

@@ -13,7 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Adaptation } from "../manifest";
+import { IAudioTrack, ITextTrack, IVideoTrack } from "../public_types";
 import { IMediaErrorCode } from "./error_codes";
+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.
  *
@@ -25,10 +41,16 @@ export default class MediaError extends Error {
     readonly type: "MEDIA_ERROR";
     readonly message: string;
     readonly code: IMediaErrorCode;
+    readonly trackInfo: IMediaErrorTrackContext | undefined;
     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);
 }
+export {};

package/dist/_esm5.processed/errors/media_error.js

@@ -38,11 +38,7 @@ import errorMessage from "./error_message";
  */
 var MediaError = /** @class */ (function (_super) {
     __extends(MediaError, _super);
-    /**
-     * @param {string} code
-     * @param {string} reason
-     */
-    function MediaError(code, reason) {
+    function MediaError(code, reason, context) {
         var _this = _super.call(this) || this;
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
         Object.setPrototypeOf(_this, MediaError.prototype);
@@ -51,6 +47,23 @@ var MediaError = /** @class */ (function (_super) {
         _this.code = code;
         _this.message = errorMessage(_this.name, _this.code, reason);
         _this.fatal = false;
+        var adaptation = context === null || context === void 0 ? void 0 : 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;
+            }
+        }
         return _this;
     }
     return MediaError;

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/load_and_push_segment.d.ts

@@ -23,4 +23,4 @@ import { CancellationSignal } from "../../../utils/task_canceller";
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function loadAndPushSegment(segmentInfo: ISegmentLoaderContent, segmentBuffer: AudioVideoSegmentBuffer, segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>, cancelSignal: CancellationSignal): Promise<unknown>;
+export default function loadAndPushSegment(segmentInfo: ISegmentLoaderContent, segmentBuffer: AudioVideoSegmentBuffer, segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>, initSegmentUniqueId: string | null, cancelSignal: CancellationSignal): Promise<unknown>;

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/load_and_push_segment.js

@@ -21,29 +21,30 @@ import log from "../../../log";
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function loadAndPushSegment(segmentInfo, segmentBuffer, segmentFetcher, cancelSignal) {
+export default function loadAndPushSegment(segmentInfo, segmentBuffer, segmentFetcher, initSegmentUniqueId, cancelSignal) {
     var pushOperations = [];
     return segmentFetcher(segmentInfo, {
         onChunk: function (parseChunk) {
             var parsed = parseChunk(undefined);
-            var isIsInitSegment;
+            var isInitSegment;
             var data;
             var timestampOffset;
             var 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;
             }
             var pushOperation = segmentBuffer.pushChunk({
-                data: { initSegment: isIsInitSegment ? data :
-                        null,
-                    chunk: isIsInitSegment ? null :
+                data: { initSegmentUniqueId: initSegmentUniqueId, chunk: isInitSegment ? null :
                         data,
                     appendWindow: [segmentInfo.period.start, segmentInfo.period.end], timestampOffset: timestampOffset, codec: codec },
                 inventoryInfos: null,

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.js

@@ -161,34 +161,42 @@ var VideoThumbnailLoader = /** @class */ (function () {
         }
         var lastRepInfo;
         if (this._lastRepresentationInfo === null) {
-            var cleaner_1 = new TaskCanceller();
+            var lastRepInfoCleaner_1 = new TaskCanceller();
             var segmentFetcher = createSegmentFetcher("video", loader.video, null, 
             // We don't care about the SegmentFetcher's lifecycle events
             {}, { baseDelay: 0,
                 maxDelay: 0,
                 maxRetry: 0,
                 requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT });
-            var segmentBufferProm = prepareSourceBuffer(this._videoElement, content.representation.getMimeTypeString(), cleaner_1.signal).then(function (segmentBuffer) { return __awaiter(_this, void 0, void 0, function () {
-                var initSegment, segmentInfo;
+            var initSegment_1 = content.representation.index.getInitSegment();
+            var initSegmentUniqueId_1 = initSegment_1 !== null ?
+                content.representation.uniqueId :
+                null;
+            var segmentBufferProm = prepareSourceBuffer(this._videoElement, content.representation.getMimeTypeString(), lastRepInfoCleaner_1.signal).then(function (segmentBuffer) { return __awaiter(_this, void 0, void 0, function () {
+                var segmentInfo;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            initSegment = content.representation.index.getInitSegment();
-                            if (initSegment === null) {
+                            if (initSegment_1 === null || initSegmentUniqueId_1 === null) {
+                                lastRepInfo.initSegmentUniqueId = null;
                                 return [2 /*return*/, segmentBuffer];
                             }
-                            segmentInfo = objectAssign({ segment: initSegment }, content);
-                            return [4 /*yield*/, loadAndPushSegment(segmentInfo, segmentBuffer, lastRepInfo.segmentFetcher, cleaner_1.signal)];
+                            segmentInfo = objectAssign({ segment: initSegment_1 }, content);
+                            return [4 /*yield*/, loadAndPushSegment(segmentInfo, segmentBuffer, lastRepInfo.segmentFetcher, initSegmentUniqueId_1, lastRepInfoCleaner_1.signal)];
                         case 1:
                             _a.sent();
+                            lastRepInfoCleaner_1.signal.register(function () {
+                                segmentBuffer.freeInitSegment(initSegmentUniqueId_1);
+                            });
                             return [2 /*return*/, segmentBuffer];
                     }
                 });
             }); });
             lastRepInfo = {
-                cleaner: cleaner_1,
+                cleaner: lastRepInfoCleaner_1,
                 segmentBuffer: segmentBufferProm,
                 content: content,
+                initSegmentUniqueId: initSegmentUniqueId_1,
                 segmentFetcher: segmentFetcher,
                 pendingRequests: [],
             };
@@ -233,7 +241,7 @@ var VideoThumbnailLoader = /** @class */ (function () {
                                 var unlinkSignal_1 = requestCanceller
                                     .linkToSignal(lastRepInfo.cleaner.signal);
                                 var segmentInfo = objectAssign({ segment: segment }, content);
-                                var prom = loadAndPushSegment(segmentInfo, segmentBuffer, lastRepInfo.segmentFetcher, requestCanceller.signal)
+                                var prom = loadAndPushSegment(segmentInfo, segmentBuffer, lastRepInfo.segmentFetcher, lastRepInfo.initSegmentUniqueId, requestCanceller.signal)
                                     .then(unlinkSignal_1, function (err) {
                                     unlinkSignal_1();
                                     throw err;

package/dist/_esm5.processed/experimental/tools/mediaCapabilitiesProber/index.js

@@ -14,6 +14,4 @@
  * limitations under the License.
  */
 import MediaCapabilitiesProber from "./api";
-import log from "./log";
-log.setLevel("WARNING");
 export default MediaCapabilitiesProber;

package/dist/_esm5.processed/manifest/adaptation.d.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 import { IParsedAdaptation } from "../parsers/manifest";
-import { ITrackType, IRepresentationFilter } from "../public_types";
+import { IAudioTrack, ITrackType, IRepresentationFilter, ITextTrack, IVideoTrack } from "../public_types";
 import Representation from "./representation";
 /** List in an array every possible value for the Adaptation's `type` property. */
 export declare const SUPPORTED_ADAPTATIONS_TYPE: ITrackType[];
 /**
  * Normalized Adaptation structure.
- * An Adaptation describes a single `Track`. For example a specific audio
+ * An `Adaptation` describes a single `Track`. For example a specific audio
  * track (in a given language) or a specific video track.
  * It istelf can be represented in different qualities, which we call here
  * `Representation`.
@@ -91,4 +91,23 @@ export default class Adaptation {
      * @returns {Object|undefined}
      */
     getRepresentation(wantedId: number | string): Representation | undefined;
+    /**
+     * Format an `Adaptation`, generally of type `"audio"`, as an `IAudioTrack`.
+     * @param {boolean} filterPlayable - If `true` only "playable" Representation
+     * will be returned.
+     * @returns {Object}
+     */
+    toAudioTrack(filterPlayable: boolean): IAudioTrack;
+    /**
+     * Format an `Adaptation`, generally of type `"audio"`, as an `IAudioTrack`.
+     * @returns {Object}
+     */
+    toTextTrack(): ITextTrack;
+    /**
+     * Format an `Adaptation`, generally of type `"video"`, as an `IAudioTrack`.
+     * @param {boolean} filterPlayable - If `true` only "playable" Representation
+     * will be returned.
+     * @returns {Object}
+     */
+    toVideoTrack(filterPlayable: boolean): IVideoTrack;
 }

package/dist/_esm5.processed/manifest/adaptation.js

@@ -22,7 +22,7 @@ import Representation from "./representation";
 export var SUPPORTED_ADAPTATIONS_TYPE = ["audio", "video", "text"];
 /**
  * Normalized Adaptation structure.
- * An Adaptation describes a single `Track`. For example a specific audio
+ * An `Adaptation` describes a single `Track`. For example a specific audio
  * track (in a given language) or a specific video track.
  * It istelf can be represented in different qualities, which we call here
  * `Representation`.
@@ -139,6 +139,81 @@ var Adaptation = /** @class */ (function () {
             return wantedId === id;
         });
     };
+    /**
+     * Format an `Adaptation`, generally of type `"audio"`, as an `IAudioTrack`.
+     * @param {boolean} filterPlayable - If `true` only "playable" Representation
+     * will be returned.
+     * @returns {Object}
+     */
+    Adaptation.prototype.toAudioTrack = function (filterPlayable) {
+        var _a, _b;
+        var formatted = {
+            language: (_a = this.language) !== null && _a !== void 0 ? _a : "",
+            normalized: (_b = this.normalizedLanguage) !== null && _b !== void 0 ? _b : "",
+            audioDescription: this.isAudioDescription === true,
+            id: this.id,
+            representations: (filterPlayable ?
+                this.getPlayableRepresentations() :
+                this.representations).map(function (r) { return r.toAudioRepresentation(); }),
+            label: this.label,
+        };
+        if (this.isDub === true) {
+            formatted.dub = true;
+        }
+        return formatted;
+    };
+    /**
+     * Format an `Adaptation`, generally of type `"audio"`, as an `IAudioTrack`.
+     * @returns {Object}
+     */
+    Adaptation.prototype.toTextTrack = function () {
+        var _a, _b;
+        return {
+            language: (_a = this.language) !== null && _a !== void 0 ? _a : "",
+            normalized: (_b = this.normalizedLanguage) !== null && _b !== void 0 ? _b : "",
+            closedCaption: this.isClosedCaption === true,
+            id: this.id,
+            label: this.label,
+            forced: this.isForcedSubtitles,
+        };
+    };
+    /**
+     * Format an `Adaptation`, generally of type `"video"`, as an `IAudioTrack`.
+     * @param {boolean} filterPlayable - If `true` only "playable" Representation
+     * will be returned.
+     * @returns {Object}
+     */
+    Adaptation.prototype.toVideoTrack = function (filterPlayable) {
+        var trickModeTracks = this.trickModeTracks !== undefined ?
+            this.trickModeTracks.map(function (trickModeAdaptation) {
+                var representations = (filterPlayable ?
+                    trickModeAdaptation.getPlayableRepresentations() :
+                    trickModeAdaptation.representations).map(function (r) { return r.toVideoRepresentation(); });
+                var trickMode = { id: trickModeAdaptation.id, representations: representations, isTrickModeTrack: true };
+                if (trickModeAdaptation.isSignInterpreted === true) {
+                    trickMode.signInterpreted = true;
+                }
+                return trickMode;
+            }) :
+            undefined;
+        var videoTrack = {
+            id: this.id,
+            representations: (filterPlayable ?
+                this.getPlayableRepresentations() :
+                this.representations).map(function (r) { return r.toVideoRepresentation(); }),
+            label: this.label,
+        };
+        if (this.isSignInterpreted === true) {
+            videoTrack.signInterpreted = true;
+        }
+        if (this.isTrickModeTrack === true) {
+            videoTrack.isTrickModeTrack = true;
+        }
+        if (trickModeTracks !== undefined) {
+            videoTrack.trickModeTracks = trickModeTracks;
+        }
+        return videoTrack;
+    };
     return Adaptation;
 }());
 export default Adaptation;

package/dist/_esm5.processed/manifest/manifest.js

@@ -373,8 +373,8 @@ function updateDeciperability(manifest, isDecipherable) {
                 var result = isDecipherable(representation);
                 if (result !== representation.decipherable) {
                     updates.push({ manifest: manifest, period: period, adaptation: adaptation, representation: representation });
-                    log.debug("Decipherability changed for \"".concat(representation.id, "\""), "(".concat(representation.bitrate, ")"), String(representation.decipherable));
                     representation.decipherable = result;
+                    log.debug("Decipherability changed for \"".concat(representation.id, "\""), "(".concat(representation.bitrate, ")"), String(representation.decipherable));
                 }
             }
         }