rx-player 3.27.0-dev.2022032800 → 3.27.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.27.0-dev.2022032800",
+  "version": "3.27.0",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.27.0-dev.2022032800
+sonar.projectVersion=3.27.0
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/compat/get_start_date.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+/**
+ * Calculating a live-offseted media position necessitate to obtain first an
+ * offset, and then adding that offset to the wanted position.
+ *
+ * That offset is in most case present inside the Manifest file, yet in cases
+ * without it or without a Manifest, such as the "directfile" mode, the RxPlayer
+ * won't know that offset.
+ *
+ * Thankfully Safari declares a `getStartDate` method allowing to obtain that
+ * offset when available. This logic is mainly useful when playing HLS contents
+ * in directfile mode on Safari.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {number|undefined}
+ */
+export default function getStartDate(
+  mediaElement : HTMLMediaElement
+) : number | undefined {
+  const _mediaElement : HTMLMediaElement & {
+    getStartDate? : () => number | Date | null | undefined;
+  } = mediaElement;
+  if (typeof _mediaElement.getStartDate === "function") {
+    const startDate = _mediaElement.getStartDate();
+    if (typeof startDate === "object" && startDate !== null) {
+      const startDateNum = +startDate;
+      if (!isNaN(startDateNum)) {
+        return startDateNum / 1000;
+      }
+    } else if (typeof startDate === "number" && !isNaN(startDate)) {
+      return startDate;
+    }
+  }
+}

package/src/compat/index.ts

@@ -44,6 +44,7 @@ import {
   isFullscreen,
   requestFullscreen,
 } from "./fullscreen";
+import getStartDate from "./get_start_date";
 import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
@@ -79,6 +80,7 @@ export {
   exitFullscreen,
   generateKeyRequest,
   getInitData,
+  getStartDate,
   hasEMEAPIs,
   ICompatTextTrack,
   ICompatVTTCue,

package/src/core/api/public_api.ts

@@ -46,6 +46,7 @@ import {
 import {
   events,
   exitFullscreen,
+  getStartDate,
   isFullscreen,
   requestFullscreen,
 } from "../../compat";
@@ -427,7 +428,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.27.0-dev.2022032800";
+    this.version = /* PLAYER_VERSION */"3.27.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -1276,24 +1277,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     const { isDirectFile, manifest } = this._priv_contentInfos;
     if (isDirectFile) {
-      // Calculating the "wall-clock time" necessitate to obtain first an offset,
-      // and then adding that offset to the HTMLMediaElement's current position.
-      // That offset is in most case present inside the Manifest file, yet in
-      // directfile mode, the RxPlayer won't parse that file, the browser does it.
-      //
-      // Thankfully Safari declares a `getStartDate` method allowing to obtain
-      // that offset when available. This logic is thus mainly useful when
-      // playing HLS contents in directfile mode on Safari.
-      const mediaElement : HTMLMediaElement & {
-        getStartDate? : () => number | null | undefined;
-      } = this.videoElement;
-      if (typeof mediaElement.getStartDate === "function") {
-        const startDate = mediaElement.getStartDate();
-        if (typeof startDate === "number" && !isNaN(startDate)) {
-          return startDate + mediaElement.currentTime;
-        }
-      }
-      return mediaElement.currentTime;
+      const startDate = getStartDate(this.videoElement);
+      return (startDate ?? 0) + this.videoElement.currentTime;
     }
     if (manifest !== null) {
       const currentTime = this.videoElement.currentTime;
@@ -1596,12 +1581,19 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       } else if (!isNullOrUndefined(timeObj.position)) {
         positionWanted = timeObj.position;
       } else if (!isNullOrUndefined(timeObj.wallClockTime)) {
-        positionWanted = (isDirectFile || manifest === null) ?
-          timeObj.wallClockTime :
-          timeObj.wallClockTime - (
-            manifest.availabilityStartTime !== undefined ?
-              manifest.availabilityStartTime :
-              0);
+        if (manifest !== null) {
+          positionWanted = timeObj.wallClockTime - (
+            manifest.availabilityStartTime ?? 0
+          );
+        } else if (isDirectFile && this.videoElement !== null) {
+          const startDate = getStartDate(this.videoElement);
+          if (startDate !== undefined) {
+            positionWanted = timeObj.wallClockTime - startDate;
+          }
+        }
+        if (positionWanted === undefined) {
+          positionWanted = timeObj.wallClockTime;
+        }
       } else {
         throw new Error("invalid time object. You must set one of the " +
                         "following properties: \"relative\", \"position\" or " +
@@ -2893,8 +2885,12 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       const ast = manifest.availabilityStartTime ?? 0;
       positionData.wallClockTime = observation.position + ast;
       positionData.liveGap = maximumPosition - observation.position;
+    } else if (isDirectFile && this.videoElement !== null) {
+      const startDate = getStartDate(this.videoElement);
+      if (startDate !== undefined) {
+        positionData.wallClockTime = startDate + observation.position;
+      }
     }
-
     this.trigger("positionUpdate", positionData);
   }
 
@@ -2946,7 +2942,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.27.0-dev.2022032800";
+Player.version = /* PLAYER_VERSION */"3.27.0";
 
 /** Payload emitted with a `positionUpdate` event. */
 export interface IPositionUpdateItem {

package/src/core/segment_buffers/garbage_collector.ts

@@ -22,6 +22,7 @@ import {
   ignoreElements,
   mergeMap,
   Observable,
+  of as observableOf,
 } from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
@@ -152,6 +153,9 @@ function clearBuffer(
   const clean$ = observableFrom(
     cleanedupRanges.map((range) => {
       log.debug("GC: cleaning range from SegmentBuffer", range);
+      if (range.start >= range.end) {
+        return observableOf(null);
+      }
       return segmentBuffer.removeBuffer(range.start, range.end);
     })
   ).pipe(concatAll(),

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -348,7 +348,8 @@ export default function StreamOrchestrator(
 
         return observableConcat(
           ...rangesToClean.map(({ start, end }) =>
-            segmentBuffer.removeBuffer(start, end).pipe(ignoreElements())),
+            start >= end ? EMPTY :
+                           segmentBuffer.removeBuffer(start, end).pipe(ignoreElements())),
           playbackObserver.observe(true).pipe(
             take(1),
             mergeMap((observation) => {

package/src/core/stream/period/period_stream.ts

@@ -170,10 +170,15 @@ export default function PeriodStream({
           if (SegmentBuffersStore.isNative(bufferType)) {
             return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
           }
-          cleanBuffer$ = segmentBufferStatus.value
-            .removeBuffer(period.start,
-                          period.end == null ? Infinity :
-                                               period.end);
+          if (period.end === undefined) {
+            cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start,
+                                                                  Infinity);
+          } else if (period.end <= period.start) {
+            cleanBuffer$ = observableOf(null);
+          } else {
+            cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start,
+                                                                  period.end);
+          }
         } else {
           if (segmentBufferStatus.type === "uninitialized") {
             segmentBuffersStore.disableSegmentBuffer(bufferType);

package/src/core/stream/representation/force_garbage_collection.ts

@@ -19,6 +19,7 @@ import {
   defer as observableDefer,
   from as observableFrom,
   Observable,
+  of as observableOf,
 } from "rxjs";
 import config from "../../../config";
 import log from "../../../log";
@@ -54,7 +55,9 @@ export default function forceGarbageCollection(
 
     log.debug("Stream: GC cleaning", cleanedupRanges);
     return observableFrom(
-      cleanedupRanges.map(({ start, end }) => bufferingQueue.removeBuffer(start, end))
+      cleanedupRanges.map(({ start, end }) =>
+        start >= end ? observableOf(null) :
+                       bufferingQueue.removeBuffer(start, end))
     ).pipe(concatAll());
   });
 }

package/src/core/stream/representation/get_buffer_status.ts

@@ -62,8 +62,8 @@ export interface IBufferStatus {
    */
   shouldRefreshManifest : boolean;
   /**
-   * If 'true', the buffer memory is saturated before being able to download
-   * at least MIN_REQUIRED_BUFFER_AHEAD ( default : 10sec )
+   * If 'true', the buffer memory is saturated, thus we may have issues loading
+   * new segments.
    */
   isBufferFull: boolean;
 }
@@ -123,16 +123,18 @@ export default function getBufferStatus(
   const getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
 
   /** List of segments we will need to download. */
-  const { neededSegments, isBufferFull } = getNeededSegments({ content,
-                                                               bufferedSegments,
-                                                               currentPlaybackTime,
-                                                               fastSwitchThreshold,
-                                                               getBufferedHistory,
-                                                               neededRange,
-                                                               segmentsBeingPushed,
-                                                               maxBufferSize });
-
-  const prioritizedNeededSegments: IQueuedSegment[] =  neededSegments.map((segment) => (
+  const { segmentsToLoad,
+          segmentsOnHold,
+          isBufferFull } = getNeededSegments({ content,
+                                               bufferedSegments,
+                                               currentPlaybackTime,
+                                               fastSwitchThreshold,
+                                               getBufferedHistory,
+                                               neededRange,
+                                               segmentsBeingPushed,
+                                               maxBufferSize });
+
+  const prioritizedNeededSegments: IQueuedSegment[] = segmentsToLoad.map((segment) => (
     {
       priority: getSegmentPriority(segment.time, wantedStartPosition),
       segment,
@@ -148,7 +150,8 @@ export default function getBufferStatus(
   const lastPosition = representation.index.getLastPosition();
   if (!representation.index.isInitialized() ||
       period.end === undefined ||
-      prioritizedNeededSegments.length > 0)
+      prioritizedNeededSegments.length > 0 ||
+      segmentsOnHold.length  > 0)
   {
     hasFinishedLoading = false;
   } else {
@@ -192,6 +195,11 @@ export default function getBufferStatus(
     if (segmentsBeingPushed.length > 0) {
       nextSegmentStart = Math.min(...segmentsBeingPushed.map(info => info.segment.time));
     }
+    if (segmentsOnHold.length > 0) {
+      nextSegmentStart = nextSegmentStart !== null ?
+        Math.min(nextSegmentStart, segmentsOnHold[0].time) :
+        segmentsOnHold[0].time;
+    }
     if (prioritizedNeededSegments.length > 0) {
       nextSegmentStart = nextSegmentStart !== null ?
         Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :

package/src/core/stream/representation/get_needed_segments.ts

@@ -84,7 +84,17 @@ export interface IGetNeededSegmentsArguments {
 
 
 interface INeededSegments {
-  neededSegments: ISegment[];
+  /** Segments that should be loaded right now, by chronological order. */
+  segmentsToLoad: ISegment[];
+  /**
+   * Segments that should be loaded, but not right now, due to some other
+   * constraints, such as memory limitations.
+   */
+  segmentsOnHold : ISegment[];
+  /**
+   * If `true` the buffer is currently full according to the given limits.
+   * Memory should be freed if possible, for example by cleaning the buffers.
+   */
   isBufferFull: boolean;
 }
 /**
@@ -112,8 +122,6 @@ export default function getNeededSegments({
                                                    segmentsBeingPushed,
                                                    maxBufferSize);
 
-  // Current buffer length in seconds
-  let bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
   const availableSegmentsForRange = representation.index
     .getSegments(neededRange.start, neededRange.end - neededRange.start);
 
@@ -151,16 +159,16 @@ export default function getNeededSegments({
       return true;
     });
   const { MINIMUM_SEGMENT_SIZE,
-          MIN_BUFFER_LENGTH,
-          MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP } = config.getCurrent();
-  let isMemorySaturated = false;
+          MIN_BUFFER_AHEAD } = config.getCurrent();
+  let shouldStopLoadingSegments = false;
   /**
    * Epsilon compensating for rounding errors when comparing the start and end
    * time of multiple segments.
    */
   const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
   let isBufferFull = false;
-  const neededSegments = availableSegmentsForRange.filter(segment => {
+  const segmentsOnHold : ISegment[] = [];
+  const segmentsToLoad = availableSegmentsForRange.filter(segment => {
     const contentObject = objectAssign({ segment }, content);
 
     // First, check that the segment is not already being pushed
@@ -176,21 +184,10 @@ export default function getNeededSegments({
     if (segment.isInit) {
       return true; // never skip initialization segments
     }
-    if (isMemorySaturated) {
-      // If we are so saturated in memory
-      // That we cannot download atleast till
-      // NeededRange.Start ( current position ) + a CONST
-      // Then the buffer is full
-      if (time < neededRange.start + MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP) {
-        isBufferFull = true;
-      }
-    }
-    if (isMemorySaturated &&
-      bufferLength > MIN_BUFFER_LENGTH) {
-
+    if (shouldStopLoadingSegments) {
+      segmentsOnHold.push(segment);
       return false;
     }
-
     if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
       return false; // too small, don't download
     }
@@ -239,29 +236,36 @@ export default function getNeededSegments({
       }
     }
 
+    const estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
+    if (availableBufferSize - estimatedSegmentSize < 0) {
+      isBufferFull = true;
+      if (time > neededRange.start + MIN_BUFFER_AHEAD) {
+        shouldStopLoadingSegments = true;
+        segmentsOnHold.push(segment);
+        return false;
+      }
+    }
+
     // check if there is an hole in place of the segment currently
     for (let i = 0; i < segmentsToKeep.length; i++) {
       const completeSeg = segmentsToKeep[i];
-      if (completeSeg.end > time) {
-        // `true` if `completeSeg` starts too far after `time`
-        return completeSeg.start > time + ROUNDING_ERROR ||
-          // `true` if `completeSeg` ends too soon before `end`
-          getLastContiguousSegment(segmentsToKeep, i).end < end - ROUNDING_ERROR;
-      }
-    }
 
-    const estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
-    if (availableBufferSize - estimatedSegmentSize < 0 &&
-        bufferLength > MIN_BUFFER_LENGTH) {
-      isMemorySaturated = true;
-      return false;
+      // For the first already-loaded segment, take the first one ending after
+      // this one' s start
+      if ((completeSeg.end + ROUNDING_ERROR) > time) {
+        const shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
+                           getLastContiguousSegment(segmentsToKeep, i).end <
+                             end - ROUNDING_ERROR;
+        if (shouldLoad) {
+          availableBufferSize -= estimatedSegmentSize;
+        }
+        return shouldLoad;
+      }
     }
     availableBufferSize -= estimatedSegmentSize;
-    bufferLength += duration;
-
     return true;
   });
-  return { neededSegments, isBufferFull };
+  return { segmentsToLoad, segmentsOnHold, isBufferFull };
 
 }
 /**
@@ -286,7 +290,7 @@ function getAvailableBufferSize(
   }, 0);
   return bufferedSegments.reduce((size, chunk) => {
     if (chunk.chunkSize !== undefined) {
-      return size - (chunk.chunkSize / 8000);
+      return size - (chunk.chunkSize / 1000);
     } else {
       return size;
     }
@@ -294,25 +298,6 @@ function getAvailableBufferSize(
   } , availableBufferSize);
 }
 
-/**
- * Compute the length of the buffer in seconds
- * @param bufferedSegments
- * @param segmentsBeingPushed
- * @returns bufferLength in seconds
- */
-function getBufferLength(
-  bufferedSegments: IBufferedChunk[],
-  segmentsBeingPushed: IEndOfSegmentInfos[]
-) : number {
-  const bufferLength = bufferedSegments.reduce((length, segment) => {
-    return length + (segment.end - segment.start);
-  }, 0);
-  const bufferBeingPushed = segmentsBeingPushed.reduce((length, segment) => {
-    return length + segment.segment.duration;
-  }, 0);
-  return bufferLength + bufferBeingPushed;
-}
-
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
  * buffered chunk contiguous with the one at the `startIndex` index given.

package/src/core/stream/representation/representation_stream.ts

@@ -384,10 +384,12 @@ export default function RepresentationStream<TSegmentDataType>({
         const gcedPosition = Math.max(
           0,
           wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
-        bufferRemoval = segmentBuffer
-          .removeBuffer(0, gcedPosition)
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-          .pipe(ignoreElements());
+        if (gcedPosition > 0) {
+          bufferRemoval = segmentBuffer
+            .removeBuffer(0, gcedPosition)
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            .pipe(ignoreElements());
+        }
       }
       return status.shouldRefreshManifest ?
         observableConcat(observableOf(EVENTS.needsManifestRefresh()),

package/src/default_config.ts

@@ -1164,40 +1164,33 @@ const DEFAULT_CONFIG = {
      */
   DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR: 1 / 1000,
 
-    /**
-     * RxPlayer's media buffers have a linked history registering recent events
-     * that happened on those.
-     * The reason is to implement various heuristics in case of weird browser
-     * behavior.
-     *
-     * The `BUFFERED_HISTORY_RETENTION_TIME` is the minimum age an entry of
-     * that history can have before being removed from the history.
-     */
+  /**
+   * RxPlayer's media buffers have a linked history registering recent events
+   * that happened on those.
+   * The reason is to implement various heuristics in case of weird browser
+   * behavior.
+   *
+   * The `BUFFERED_HISTORY_RETENTION_TIME` is the minimum age an entry of
+   * that history can have before being removed from the history.
+   */
   BUFFERED_HISTORY_RETENTION_TIME: 60000,
 
-    /**
-     * RxPlayer's media buffers have a linked history registering recent events
-     * that happened on those.
-     * The reason is to implement various heuristics in case of weird browser
-     * behavior.
-     *
-     * The `BUFFERED_HISTORY_RETENTION_TIME` is the maximum number of entries
-     * there can be in that history.
-     */
+  /**
+   * RxPlayer's media buffers have a linked history registering recent events
+   * that happened on those.
+   * The reason is to implement various heuristics in case of weird browser
+   * behavior.
+   *
+   * The `BUFFERED_HISTORY_RETENTION_TIME` is the maximum number of entries
+   * there can be in that history.
+   */
   BUFFERED_HISTORY_MAXIMUM_ENTRIES: 200,
 
-    /**
-     * Minimum buffer (in seconds) we should have, regardless of memory
-     * constraints
-     */
-  MIN_BUFFER_LENGTH : 5,
-
   /**
    * Minimum buffer in seconds ahead relative to current time
-   * we should be able to download
-   * Before trying to agressively free up memory
+   * we should be able to download, even in cases of saturated memory.
    */
-  MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: 10,
+  MIN_BUFFER_AHEAD: 5,
 
   /**
    * Distance in seconds behind the current position

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-import TaskCanceller, {
-  CancellationError,
-} from "../../utils/task_canceller";
+import TaskCanceller from "../../utils/task_canceller";
 import { ISegmentLoader } from "../types";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import inferSegmentContainer from "../utils/infer_segment_container";
@@ -32,61 +30,60 @@ export default function addSegmentIntegrityChecks<T>(
   segmentLoader : ISegmentLoader<T>
 ) : ISegmentLoader<T> {
   return (url, content, initialCancelSignal, callbacks) => {
-    return new Promise((res, rej) => {
-      const canceller = new TaskCanceller();
-      const unregisterCancelLstnr = initialCancelSignal
-        .register(function onCheckCancellation(err : CancellationError) {
-          canceller.cancel();
-          rej(err);
-        });
+    return new Promise((resolve, reject) => {
+      const requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
 
-      /**
-       * If the data's seems to be corrupted, cancel the loading task and reject
-       * with an `INTEGRITY_ERROR` error.
-       * @param {*} data
-       */
-      function cancelAndRejectOnBadIntegrity(data : T) : void {
-        if (!(data instanceof Array) && !(data instanceof Uint8Array) ||
-            inferSegmentContainer(content.adaptation.type,
-                                  content.representation) !== "mp4")
-        {
-          return;
-        }
-        try {
-          checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
-        } catch (err) {
-          unregisterCancelLstnr();
-          canceller.cancel();
-          rej(err);
-        }
-      }
+      // Reject the `CancellationError` when `requestCanceller`'s signal emits
+      // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
+      const stopRejectingOnCancel = requestCanceller.signal.register(reject);
 
-      segmentLoader(url, content, canceller.signal, {
+      segmentLoader(url, content, requestCanceller.signal, {
         ...callbacks,
         onNewChunk(data) {
-          cancelAndRejectOnBadIntegrity(data);
-          if (!canceller.isUsed) {
+          try {
+            trowOnIntegrityError(data);
             callbacks.onNewChunk(data);
+          } catch (err) {
+            // Do not reject with a `CancellationError` after cancelling the request
+            stopRejectingOnCancel();
+            // Cancel the request
+            requestCanceller.cancel();
+            // Reject with thrown error
+            reject(err);
           }
         },
       }).then((info) => {
-        if (canceller.isUsed) {
+        if (requestCanceller.isUsed) {
           return;
         }
-        unregisterCancelLstnr();
-
+        stopRejectingOnCancel();
         if (info.resultType === "segment-loaded") {
-          cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+          try {
+            trowOnIntegrityError(info.resultData.responseData);
+          } catch (err) {
+            reject(err);
+            return;
+          }
         }
-        res(info);
-
+        resolve(info);
       }, (error : unknown) => {
-        // The segmentLoader's cancellations cases are all handled here
-        if (!TaskCanceller.isCancellationError(error)) {
-          unregisterCancelLstnr();
-          rej(error);
-        }
+        stopRejectingOnCancel();
+        reject(error);
       });
     });
+
+    /**
+     * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+     * @param {*} data
+     */
+    function trowOnIntegrityError(data : T) : void {
+      if (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array) ||
+          inferSegmentContainer(content.adaptation.type,
+                                content.representation) !== "mp4")
+      {
+        return;
+      }
+      checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
+    }
   };
 }