rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

package/src/parsers/manifest/dash/common/indexes/is_period_fulfilled.ts

@@ -16,7 +16,6 @@
 
 import config from "../../../../../config";
 
-const { DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR } = config;
 
 /**
  * In Javascript, numbers are encoded in a way that a floating number may be
@@ -36,7 +35,7 @@ export default function isPeriodFulfilled(
   periodEnd: number
 ): boolean {
   const scaledRoundingError =
-    DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
+    config.getCurrent().DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
   return (lastSegmentEnd + scaledRoundingError) >= periodEnd;
 }
 

package/src/parsers/manifest/dash/common/indexes/template.ts

@@ -29,7 +29,6 @@ import {
   createIndexURLs,
 } from "./tokens";
 
-const { MINIMUM_SEGMENT_SIZE } = config;
 
 /**
  * Index property defined for a SegmentTemplate RepresentationIndex
@@ -533,7 +532,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
       // segment that there actually is due to a very little difference between
       // the period's duration and a multiple of a segment's duration.
       // Check that we're within a good margin
-      const minimumDuration = MINIMUM_SEGMENT_SIZE * timescale;
+      const minimumDuration = config.getCurrent().MINIMUM_SEGMENT_SIZE * timescale;
       if (maximumTime - regularLastSegmentStart > minimumDuration ||
           numberIndexedToZero === 0)
       {

package/src/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.ts

@@ -47,7 +47,6 @@ import constructTimelineFromElements from "./construct_timeline_from_elements";
 // eslint-disable-next-line max-len
 import constructTimelineFromPreviousTimeline from "./construct_timeline_from_previous_timeline";
 
-const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config;
 
 /**
  * Index property defined for a SegmentTimeline RepresentationIndex
@@ -606,6 +605,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     const newElements = this._parseTimeline();
     this._parseTimeline = null; // Free memory
 
+    const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config.getCurrent();
     if (this._unsafelyBaseOnPreviousIndex === null ||
         newElements.length < MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY)
     {

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

@@ -15,14 +15,18 @@
  */
 
 import log from "../../../../log";
-import { Period } from "../../../../manifest";
+import {
+  IAdaptationType,
+  Period,
+  SUPPORTED_ADAPTATIONS_TYPE,
+} from "../../../../manifest";
 import arrayFind from "../../../../utils/array_find";
+import arrayFindIndex from "../../../../utils/array_find_index";
 import arrayIncludes from "../../../../utils/array_includes";
 import isNonEmptyString from "../../../../utils/is_non_empty_string";
 import {
   IParsedAdaptation,
   IParsedAdaptations,
-  IParsedAdaptationType,
 } from "../../types";
 import {
   IAdaptationSetIntermediateRepresentation,
@@ -235,30 +239,31 @@ export default function parseAdaptationSets(
   adaptationsIR : IAdaptationSetIntermediateRepresentation[],
   context : IAdaptationSetContext
 ): IParsedAdaptations {
-  const parsedAdaptations : IParsedAdaptations = {};
+  const parsedAdaptations : Record<
+    IAdaptationType,
+    Array<[ IParsedAdaptation,
+            IAdaptationSetOrderingData ]>
+  > = { video: [],
+        audio: [],
+        text: [],
+        image: [] };
   const trickModeAdaptations: Array<{ adaptation: IParsedAdaptation;
                                       trickModeAttachedAdaptationIds: string[]; }> = [];
   const adaptationSwitchingInfos : IAdaptationSwitchingInfos = {};
+
   const parsedAdaptationsIDs : string[] = [];
 
   /**
-   * Index of the last parsed AdaptationSet with a Role set as "main" in
-   * `parsedAdaptations` for a given type.
-   * Not defined for a type with no main Adaptation inside.
-   * This is used to put main AdaptationSet first in the resulting array of
-   * Adaptation while still preserving the MPD order among them.
+   * Index of the last parsed Video AdaptationSet with a Role set as "main" in
+   * `parsedAdaptations.video`.
+   * `-1` if not yet encountered.
+   * Used as we merge all main video AdaptationSet due to a comprehension of the
+   * DASH-IF IOP.
    */
-  const lastMainAdaptationIndex : Partial<Record<IParsedAdaptationType, number>> = {};
-
-  // first sort AdaptationSets by absolute priority.
-  adaptationsIR.sort((a, b) => {
-    /* As of DASH-IF 4.3, `1` is the default value. */
-    const priority1 = a.attributes.selectionPriority ?? 1;
-    const priority2 = b.attributes.selectionPriority ?? 1;
-    return priority2 - priority1;
-  });
+  let lastMainVideoAdapIdx = -1;
 
-  for (const adaptation of adaptationsIR) {
+  for (let adaptationIdx = 0; adaptationIdx < adaptationsIR.length; adaptationIdx++) {
+    const adaptation = adaptationsIR[adaptationIdx];
     const adaptationChildren = adaptation.children;
     const { essentialProperties,
             roles } = adaptationChildren;
@@ -291,6 +296,7 @@ export default function parseAdaptationSets(
       continue;
     }
 
+    const priority = adaptation.attributes.selectionPriority ?? 1;
     const originalID = adaptation.attributes.id;
     let newID : string;
     const adaptationSetSwitchingIDs = getAdaptationSetSwitchingIDs(adaptation);
@@ -334,14 +340,11 @@ export default function parseAdaptationSets(
 
     if (type === "video" &&
         isMainAdaptation &&
-        parsedAdaptations.video !== undefined &&
-        parsedAdaptations.video.length > 0 &&
-        lastMainAdaptationIndex.video !== undefined &&
+        lastMainVideoAdapIdx >= 0 &&
+        parsedAdaptations.video.length > lastMainVideoAdapIdx &&
         !isTrickModeTrack)
     {
-      // Add to the already existing main video adaptation
-      // TODO remove that ugly custom logic?
-      const videoMainAdaptation = parsedAdaptations.video[lastMainAdaptationIndex.video];
+      const videoMainAdaptation = parsedAdaptations.video[lastMainVideoAdapIdx][0];
       reprCtxt.unsafelyBaseOnPreviousAdaptation = context
         .unsafelyBaseOnPreviousPeriod?.getAdaptation(videoMainAdaptation.id) ?? null;
       const representations = parseRepresentations(representationsIR,
@@ -422,65 +425,56 @@ export default function parseAdaptationSets(
         parsedAdaptationSet.isSignInterpreted = true;
       }
 
-      const adaptationsOfTheSameType = parsedAdaptations[type];
       if (trickModeAttachedAdaptationIds !== undefined) {
         trickModeAdaptations.push({ adaptation: parsedAdaptationSet,
                                     trickModeAttachedAdaptationIds });
-      } else if (adaptationsOfTheSameType === undefined) {
-        parsedAdaptations[type] = [parsedAdaptationSet];
-        if (isMainAdaptation) {
-          lastMainAdaptationIndex[type] = 0;
-        }
       } else {
-        let mergedInto : IParsedAdaptation|null = null;
 
         // look if we have to merge this into another Adaptation
+        let mergedIntoIdx = -1;
         for (const id of adaptationSetSwitchingIDs) {
           const switchingInfos = adaptationSwitchingInfos[id];
-          if (switchingInfos != null &&
+          if (switchingInfos !== undefined &&
               switchingInfos.newID !== newID &&
               arrayIncludes(switchingInfos.adaptationSetSwitchingIDs, originalID))
           {
-            const adaptationToMergeInto = arrayFind(adaptationsOfTheSameType,
-                                                    (a) => a.id === id);
-            if (adaptationToMergeInto != null &&
-                adaptationToMergeInto.audioDescription ===
+            mergedIntoIdx = arrayFindIndex(parsedAdaptations[type],
+                                           (a) => a[0].id === id);
+            const mergedInto = parsedAdaptations[type][mergedIntoIdx];
+            if (mergedInto !== undefined &&
+                mergedInto[0].audioDescription ===
                   parsedAdaptationSet.audioDescription &&
-                adaptationToMergeInto.closedCaption ===
+                mergedInto[0].closedCaption ===
                   parsedAdaptationSet.closedCaption &&
-                adaptationToMergeInto.language === parsedAdaptationSet.language)
+                mergedInto[0].language === parsedAdaptationSet.language)
             {
               log.info("DASH Parser: merging \"switchable\" AdaptationSets",
                        originalID, id);
-              adaptationToMergeInto.representations
-                .push(...parsedAdaptationSet.representations);
-              mergedInto = adaptationToMergeInto;
+              mergedInto[0].representations.push(...parsedAdaptationSet.representations);
+              if (type === "video" &&
+                  isMainAdaptation &&
+                  !mergedInto[1].isMainAdaptation)
+              {
+                lastMainVideoAdapIdx = Math.max(lastMainVideoAdapIdx, mergedIntoIdx);
+              }
+              mergedInto[1] = {
+                priority: Math.max(priority, mergedInto[1].priority),
+                isMainAdaptation: isMainAdaptation ||
+                                  mergedInto[1].isMainAdaptation,
+                indexInMpd: Math.min(adaptationIdx, mergedInto[1].indexInMpd),
+              };
             }
           }
         }
 
-        if (isMainAdaptation) {
-          const oldLastMainIdx = lastMainAdaptationIndex[type];
-          const newLastMainIdx = oldLastMainIdx === undefined ? 0 :
-                                                                oldLastMainIdx + 1;
-          if (mergedInto === null) {
-            // put "main" Adaptation after all other Main Adaptations
-            adaptationsOfTheSameType.splice(newLastMainIdx, 0, parsedAdaptationSet);
-            lastMainAdaptationIndex[type] = newLastMainIdx;
-          } else {
-            const indexOf = adaptationsOfTheSameType.indexOf(mergedInto);
-            if (indexOf < 0) { // Weird, not found
-              adaptationsOfTheSameType.splice(newLastMainIdx, 0, parsedAdaptationSet);
-              lastMainAdaptationIndex[type] = newLastMainIdx;
-            } else if (oldLastMainIdx === undefined || indexOf > oldLastMainIdx) {
-              // Found but was not main
-              adaptationsOfTheSameType.splice(indexOf, 1);
-              adaptationsOfTheSameType.splice(newLastMainIdx, 0, mergedInto);
-              lastMainAdaptationIndex[type] = newLastMainIdx;
-            }
+        if (mergedIntoIdx < 0) {
+          parsedAdaptations[type].push([ parsedAdaptationSet,
+                                         { priority,
+                                           isMainAdaptation,
+                                           indexInMpd: adaptationIdx }]);
+          if (type === "video" && isMainAdaptation) {
+            lastMainVideoAdapIdx = parsedAdaptations.video.length - 1;
           }
-        } else if (mergedInto === null) {
-          adaptationsOfTheSameType.push(parsedAdaptationSet);
         }
       }
     }
@@ -490,8 +484,59 @@ export default function parseAdaptationSets(
                                                adaptationSetSwitchingIDs };
     }
   }
-  attachTrickModeTrack(parsedAdaptations, trickModeAdaptations);
-  return parsedAdaptations;
+
+  const adaptationsPerType = SUPPORTED_ADAPTATIONS_TYPE
+    .reduce((acc : IParsedAdaptations, adaptationType : IAdaptationType) => {
+      const adaptationsParsedForType = parsedAdaptations[adaptationType];
+      if (adaptationsParsedForType.length > 0) {
+        adaptationsParsedForType.sort(compareAdaptations);
+        acc[adaptationType] = adaptationsParsedForType
+          .map(([parsedAdaptation]) => parsedAdaptation);
+      }
+      return acc;
+    }, {});
+  parsedAdaptations.video.sort(compareAdaptations);
+  attachTrickModeTrack(adaptationsPerType, trickModeAdaptations);
+  return adaptationsPerType;
+}
+
+/** Metadata allowing to order AdaptationSets between one another. */
+interface IAdaptationSetOrderingData {
+  /**
+   * If `true`, this AdaptationSet is considered as a "main" one (e.g. it had a
+   * Role set to "main").
+   */
+  isMainAdaptation : boolean;
+  /**
+   * Set to the `selectionPriority` attribute of the corresponding AdaptationSet
+   * or to `1` by default.
+   */
+  priority : number;
+  /** Index of this AdaptationSet in the original MPD, starting from `0`. */
+  indexInMpd : number;
+}
+
+/**
+ * Compare groups of parsed AdaptationSet, alongside some ordering metadata,
+ * allowing to easily sort them through JavaScript's `Array.prototype.sort`
+ * method.
+ * @param {Array.<Object>} a
+ * @param {Array.<Object>} b
+ * @returns {number}
+ */
+function compareAdaptations(
+  a : [IParsedAdaptation, IAdaptationSetOrderingData],
+  b : [IParsedAdaptation, IAdaptationSetOrderingData]
+) : number {
+  const priorityDiff = b[1].priority - a[1].priority;
+  if (priorityDiff !== 0) {
+    return priorityDiff;
+  }
+  if (a[1].isMainAdaptation !== b[1].isMainAdaptation) {
+    return a[1].isMainAdaptation ? -1 :
+      1;
+  }
+  return a[1].indexInMpd - b[1].indexInMpd;
 }
 
 /** Context needed when calling `parseAdaptationSets`. */

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

@@ -37,7 +37,6 @@ import resolveBaseURLs, {
   IResolvedBaseUrl,
 } from "./resolve_base_urls";
 
-const { DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 } = config;
 
 /** Possible options for `parseMPD`.  */
 export interface IMPDParserArguments {
@@ -277,7 +276,7 @@ function parseCompleteIntermediateRepresentation(
       rootAttributes.minimumUpdatePeriod >= 0)
   {
     lifetime = rootAttributes.minimumUpdatePeriod === 0 ?
-      DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 :
+      config.getCurrent().DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 :
       rootAttributes.minimumUpdatePeriod;
   }
 

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -17,7 +17,6 @@
 import log from "../../../../../log";
 import assertUnreachable from "../../../../../utils/assert_unreachable";
 import noop from "../../../../../utils/noop";
-import PPromise from "../../../../../utils/promise";
 import parseMpdIr, {
   IIrParserResponse,
   ILoadedXlinkData,
@@ -136,15 +135,15 @@ export default class DashWasmParser {
    */
   public waitForInitialization() : Promise<void> {
     return this._initProm ??
-           PPromise.reject("No initialization performed yet.");
+           Promise.reject("No initialization performed yet.");
   }
 
   public async initialize(opts : IDashWasmParserOptions) : Promise<void> {
     if (this.status !== "uninitialized") {
-      return PPromise.reject(new Error("DashWasmParser already initialized."));
+      return Promise.reject(new Error("DashWasmParser already initialized."));
     } else if (!this.isCompatible()) {
       this.status = "failure";
-      return PPromise.reject(new Error("Target not compatible with WebAssembly."));
+      return Promise.reject(new Error("Target not compatible with WebAssembly."));
     }
     this.status = "initializing";
 
@@ -175,7 +174,7 @@ export default class DashWasmParser {
 
     const streamingProm = typeof WebAssembly.instantiateStreaming === "function" ?
       WebAssembly.instantiateStreaming(fetchedWasm, imports) :
-      PPromise.reject("`WebAssembly.instantiateStreaming` API not available");
+      Promise.reject("`WebAssembly.instantiateStreaming` API not available");
 
     this._initProm = streamingProm
       .catch(async (e) => {

package/src/parsers/manifest/smooth/create_parser.ts

@@ -83,6 +83,7 @@ const MIME_TYPES : Partial<Record<string, string>> = {
   AVC1: "video/mp4",
   H264: "video/mp4",
   TTML: "application/ttml+xml+mp4",
+  DFXP: "application/ttml+xml+mp4",
 };
 
 export interface IHSSParserConfiguration {

package/src/parsers/texttracks/webvtt/html/__tests__/create_styled_element.test.ts

@@ -75,6 +75,7 @@ describe("parsers - webvtt - createStyledElement", () => {
     node.appendChild(textNode);
 
     const styleElements = {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
       "#text": "color: yellow",
     };
 

package/src/public_types.ts

@@ -45,13 +45,18 @@ export {
   ITextTrackPreference,
   IVideoTrackPreference,
 
+  IBitrateEstimate,
+  IPositionUpdateItem as IPositionUpdate,
+  IPlayerState,
+
   IStreamEvent,
   IStreamEventData,
 } from "./core/api";
 export {
   IPersistentSessionInfo,
   IPersistentSessionStorage,
-} from "./core/eme";
+} from "./core/decrypt";
+export { IAudioTrackSwitchingMode } from "./core/stream";
 export { ICustomError as IPlayerError } from "./errors";
 export {
   IExposedAdaptation as IAdaptation,

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "../../utils/promise";
 import TaskCanceller, {
   CancellationError,
 } from "../../utils/task_canceller";
@@ -33,7 +32,7 @@ export default function addSegmentIntegrityChecks<T>(
   segmentLoader : ISegmentLoader<T>
 ) : ISegmentLoader<T> {
   return (url, content, initialCancelSignal, callbacks) => {
-    return new PPromise((res, rej) => {
+    return new Promise((res, rej) => {
       const canceller = new TaskCanceller();
       const unregisterCancelLstnr = initialCancelSignal
         .register(function onCheckCancellation(err : CancellationError) {

package/src/transports/dash/image_pipelines.ts

@@ -15,7 +15,6 @@
  */
 
 import features from "../../features";
-import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import takeFirstSet from "../../utils/take_first_set";
 import { CancellationSignal } from "../../utils/task_canceller";
@@ -24,7 +23,6 @@ import {
   ILoadedImageSegmentFormat,
   ISegmentContext,
   ISegmentLoaderCallbacks,
-  ISegmentLoaderResultChunkedComplete,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
   ISegmentParserParsedInitChunk,
@@ -39,31 +37,31 @@ import {
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export function imageLoader(
+export async function imageLoader(
   url : string | null,
   content : ISegmentContext,
   cancelSignal : CancellationSignal,
   callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
-            ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat> |
-            ISegmentLoaderResultChunkedComplete>
+            ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat>>
 {
   const { segment } = content;
   if (segment.isInit || url === null) {
-    return PPromise.resolve({ resultType: "segment-created",
-                              resultData: null });
+    return { resultType: "segment-created",
+             resultData: null };
   }
-  return request({ url,
-                   responseType: "arraybuffer",
-                   onProgress: callbacks.onProgress,
-                   cancelSignal })
-    .then((data) => ({ resultType: "segment-loaded",
-                       resultData: data }));
+  const data = await request({ url,
+                               responseType: "arraybuffer",
+                               onProgress: callbacks.onProgress,
+                               cancelSignal });
+  return { resultType: "segment-loaded",
+           resultData: data };
 }
 
 /**
  * Parses an image segment.
- * @param {Object} args
+ * @param {Object} loadedSegment
+ * @param {Object} content
  * @returns {Object}
  */
 export function imageParser(
@@ -78,6 +76,7 @@ export function imageParser(
   if (content.segment.isInit) { // image init segment has no use
     return { segmentType: "init",
              initializationData: null,
+             initializationDataSize: 0,
              protectionDataUpdate: false,
              initTimescale: undefined };
   }
@@ -92,6 +91,7 @@ export function imageParser(
   if (data === null || features.imageParser === null) {
     return { segmentType: "media",
              chunkData: null,
+             chunkSize: 0,
              chunkInfos: { duration: segment.duration,
                            time: segment.time },
              chunkOffset,
@@ -107,6 +107,7 @@ export function imageParser(
                         end: Number.MAX_VALUE,
                         timescale: 1,
                         type: "bif" },
+           chunkSize: undefined,
            chunkInfos: { time: 0,
                          duration: Number.MAX_VALUE },
            chunkOffset,

package/src/transports/dash/init_segment_loader.ts

@@ -16,7 +16,6 @@
 
 import { ISegment } from "../../manifest";
 import { concat } from "../../utils/byte_parsing";
-import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {
@@ -86,7 +85,7 @@ export default function initSegmentLoader(
                                   cancelSignal,
                                   onProgress: callbacks.onProgress });
 
-  return PPromise.all([rangeRequest$, indexRequest$])
+  return Promise.all([rangeRequest$, indexRequest$])
     .then(([ initData, indexData ]) => {
       const data = concat(new Uint8Array(initData.responseData),
                           new Uint8Array(indexData.responseData));

package/src/transports/dash/manifest_parser.ts

@@ -23,7 +23,6 @@ import {
   ILoadedResource,
 } from "../../parsers/manifest/dash/parsers_types";
 import objectAssign from "../../utils/object_assign";
-import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import {
   strToUtf8,
@@ -140,7 +139,7 @@ export default function generateManifestParser(
           onWarnings(parserResponse.value.warnings);
         }
         if (cancelSignal.isCancelled) {
-          return PPromise.reject(cancelSignal.cancellationError);
+          return Promise.reject(cancelSignal.cancellationError);
         }
         const manifest = new Manifest(parserResponse.value.parsed, options);
         return { manifest, url };
@@ -192,7 +191,7 @@ export default function generateManifestParser(
         });
       });
 
-      return PPromise.all(externalResources).then(loadedResources => {
+      return Promise.all(externalResources).then(loadedResources => {
         if (value.format === "string") {
           assertLoadedResourcesFormatString(loadedResources);
           return processMpdParserResponse(value.continue(loadedResources));

package/src/transports/dash/segment_loader.ts

@@ -15,7 +15,6 @@
  */
 
 import { CustomLoaderError } from "../../errors";
-import PPromise from "../../utils/promise";
 import request, {
   fetchIsSupported,
 } from "../../utils/request";
@@ -42,7 +41,7 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
 
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} uri
+ * @param {string} url
  * @param {Object} content
  * @param {boolean} lowLatencyMode
  * @param {Object} callbacks
@@ -114,8 +113,8 @@ export default function generateSegmentLoader(
               ISegmentLoaderResultChunkedComplete>
   {
     if (url == null) {
-      return PPromise.resolve({ resultType: "segment-created",
-                                resultData: null });
+      return Promise.resolve({ resultType: "segment-created",
+                               resultData: null });
     }
 
     if (lowLatencyMode || customSegmentLoader === undefined) {
@@ -130,7 +129,7 @@ export default function generateSegmentLoader(
                    transport: "dash",
                    url };
 
-    return new PPromise((res, rej) => {
+    return new Promise((res, rej) => {
       /** `true` when the custom segmentLoader should not be active anymore. */
       let hasFinished = false;
 

package/src/transports/dash/segment_parser.ts

@@ -64,11 +64,13 @@ export default function generateAudioVideoSegmentParser(
       if (segment.isInit) {
         return { segmentType: "init",
                  initializationData: null,
+                 initializationDataSize: 0,
                  protectionDataUpdate: false,
                  initTimescale: undefined };
       }
       return { segmentType: "media",
                chunkData: null,
+               chunkSize: 0,
                chunkInfos: null,
                chunkOffset: 0,
                protectionDataUpdate: false,
@@ -115,6 +117,7 @@ export default function generateAudioVideoSegmentParser(
             const { needsManifestRefresh, inbandEvents } = events;
             return { segmentType: "media",
                      chunkData,
+                     chunkSize: chunkData.length,
                      chunkInfos,
                      chunkOffset,
                      appendWindow,
@@ -127,6 +130,7 @@ export default function generateAudioVideoSegmentParser(
 
       return { segmentType: "media",
                chunkData,
+               chunkSize: chunkData.length,
                chunkInfos,
                chunkOffset,
                protectionDataUpdate,
@@ -177,6 +181,7 @@ export default function generateAudioVideoSegmentParser(
 
     return { segmentType: "init",
              initializationData: chunkData,
+             initializationDataSize: chunkData.length,
              protectionDataUpdate,
              initTimescale: parsedTimescale };
   };

package/src/transports/dash/text_loader.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "../../utils/promise";
 import request, {
   fetchIsSupported,
 } from "../../utils/request";
@@ -68,8 +67,8 @@ export default function generateTextTrackLoader(
     const { range } = segment;
 
     if (url === null) {
-      return PPromise.resolve({ resultType: "segment-created",
-                                resultData: null });
+      return Promise.resolve({ resultType: "segment-created",
+                               resultData: null });
     }
 
     if (segment.isInit) {