rx-player 3.26.1 → 3.26.2

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

@@ -52,7 +52,8 @@ function getWantedRepeatIndex(
  * @returns {Array.<Object>}
  */
 export default function getSegmentsFromTimeline(
-  index : { mediaURLs : string[] | null;
+  index : { availabilityTimeComplete? : boolean;
+            mediaURLs : string[] | null;
             startNumber? : number;
             timeline : IIndexSegment[];
             timescale : number;
@@ -66,9 +67,7 @@ export default function getSegmentsFromTimeline(
   const scaledTo = toIndexTime(from + durationWanted, index);
   const { timeline, timescale, mediaURLs, startNumber } = index;
 
-  let currentNumber = startNumber != null ? startNumber :
-                                            undefined;
-
+  let currentNumber = startNumber ?? 1;
   const segments : ISegment[] = [];
 
   const timelineLength = timeline.length;
@@ -85,11 +84,13 @@ export default function getSegmentsFromTimeline(
     maxEncounteredDuration = Math.max(maxEncounteredDuration, duration);
 
     const repeat = calculateRepeat(timelineItem, timeline[i + 1], maximumTime);
+    const complete = index.availabilityTimeComplete !== false ||
+                     i !== timelineLength - 1 &&
+                     repeat !== 0;
     let segmentNumberInCurrentRange = getWantedRepeatIndex(start, duration, scaledUp);
     let segmentTime = start + segmentNumberInCurrentRange * duration;
     while (segmentTime < scaledTo && segmentNumberInCurrentRange <= repeat) {
-      const segmentNumber = currentNumber != null ?
-        currentNumber + segmentNumberInCurrentRange : undefined;
+      const segmentNumber = currentNumber + segmentNumberInCurrentRange;
 
       const detokenizedURLs = mediaURLs === null ?
         null :
@@ -106,6 +107,7 @@ export default function getSegmentsFromTimeline(
                         mediaURLs: detokenizedURLs,
                         number: segmentNumber,
                         timestampOffset: -(index.indexTimeOffset / timescale),
+                        complete,
                         privateInfos: { isEMSGWhitelisted } };
       segments.push(segment);
 
@@ -119,9 +121,7 @@ export default function getSegmentsFromTimeline(
       return segments;
     }
 
-    if (currentNumber != null) {
-      currentNumber += repeat + 1;
-    }
+    currentNumber += repeat + 1;
   }
 
   return segments;

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

@@ -21,6 +21,7 @@ import {
 } from "../../../../../manifest";
 import { IEMSG } from "../../../../containers/isobmff";
 import { getTimescaledRange } from "../../../utils/index_helpers";
+import { IResolvedBaseUrl } from "../resolve_base_urls";
 import getInitSegment from "./get_init_segment";
 import { createIndexURLs } from "./tokens";
 
@@ -106,7 +107,7 @@ export interface IListIndexContextArgument {
   /** Start of the period concerned by this RepresentationIndex, in seconds. */
   periodStart : number;
   /** Base URL for the Representation concerned. */
-  representationBaseURLs : string[];
+  representationBaseURLs : IResolvedBaseUrl[];
   /** ID of the Representation concerned. */
   representationId? : string;
   /** Bitrate of the Representation concerned. */
@@ -145,8 +146,9 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
     const timescale = index.timescale ?? 1;
     const indexTimeOffset = presentationTimeOffset - periodStart * timescale;
 
+    const urlSources : string[] = representationBaseURLs.map(b => b.url);
     const list = index.list.map((lItem) => ({
-      mediaURLs: createIndexURLs(representationBaseURLs,
+      mediaURLs: createIndexURLs(urlSources,
                                  lItem.media,
                                  representationId,
                                  representationBitrate),
@@ -158,7 +160,7 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
                     indexRange: index.indexRange,
                     initialization: index.initialization == null ?
                       undefined :
-                      { mediaURLs: createIndexURLs(representationBaseURLs,
+                      { mediaURLs: createIndexURLs(urlSources,
                                                    index.initialization.media,
                                                    representationId,
                                                    representationBitrate),
@@ -207,6 +209,7 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
           end: time + durationInSeconds,
           mediaURLs,
           timestampOffset: -(index.indexTimeOffset / timescale),
+          complete: true,
           privateInfos: { isEMSGWhitelisted:
                             this._isEMSGWhitelisted } };
       segments.push(segment);

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

@@ -21,6 +21,7 @@ import {
 } from "../../../../../manifest";
 import { IEMSG } from "../../../../containers/isobmff";
 import ManifestBoundsCalculator from "../manifest_bounds_calculator";
+import { IResolvedBaseUrl } from "../resolve_base_urls";
 import getInitSegment from "./get_init_segment";
 import isPeriodFulfilled from "./is_period_fulfilled";
 import {
@@ -122,7 +123,7 @@ export interface ITemplateIndexContextArgument {
   /** Whether the corresponding Manifest can be updated and changed. */
   isDynamic : boolean;
   /** Base URL for the Representation concerned. */
-  representationBaseURLs : string[];
+  representationBaseURLs : IResolvedBaseUrl[];
   /** ID of the Representation concerned. */
   representationId? : string;
   /** Bitrate of the Representation concerned. */
@@ -177,7 +178,12 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
             isEMSGWhitelisted } = context;
     const timescale = index.timescale ?? 1;
 
-    this._availabilityTimeOffset = availabilityTimeOffset;
+    const minBaseUrlAto = representationBaseURLs.length === 0 ?
+      0 :
+      representationBaseURLs.reduce((acc, rbu) => {
+        return Math.min(acc, rbu.availabilityTimeOffset);
+      }, Infinity);
+    this._availabilityTimeOffset = availabilityTimeOffset + minBaseUrlAto;
 
     this._manifestBoundsCalculator = manifestBoundsCalculator;
     this._aggressiveMode = aggressiveMode;
@@ -192,18 +198,19 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
       throw new Error("Invalid SegmentTemplate: no duration");
     }
 
+    const urlSources : string[] = representationBaseURLs.map(b => b.url);
     this._index = { duration: index.duration,
                     timescale,
                     indexRange: index.indexRange,
                     indexTimeOffset,
                     initialization: index.initialization == null ?
                       undefined :
-                      { mediaURLs: createIndexURLs(representationBaseURLs,
+                      { mediaURLs: createIndexURLs(urlSources,
                                                    index.initialization.media,
                                                    representationId,
                                                    representationBitrate),
                         range: index.initialization.range },
-                    mediaURLs: createIndexURLs(representationBaseURLs,
+                    mediaURLs: createIndexURLs(urlSources,
                                                index.media,
                                                representationId,
                                                representationBitrate),
@@ -257,8 +264,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     const segments : ISegment[] = [];
 
     // number corresponding to the Period's start
-    const numberOffset = startNumber == null ? 1 :
-                                               startNumber;
+    const numberOffset = startNumber ?? 1;
 
     // calcul initial time from Period start, where the first segment would have
     // the `0` number
@@ -293,6 +299,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
                      scaledDuration: realDuration / timescale,
                      mediaURLs: detokenizedURLs,
                      timestampOffset: -(index.indexTimeOffset / timescale),
+                     complete: true,
                      privateInfos: {
                        isEMSGWhitelisted: this._isEMSGWhitelisted,
                      } };

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

@@ -15,6 +15,7 @@
  */
 
 import log from "../../../../../../log";
+import isNullOrUndefined from "../../../../../../utils/is_null_or_undefined";
 import { IIndexSegment } from "../../../../utils/index_helpers";
 
 /**
@@ -40,23 +41,23 @@ export default function convertElementsToIndexSegment(
   let start = item.start;
   let duration = item.duration;
   const repeatCount = item.repeatCount;
-  if (start == null) {
-    if (previousItem == null) {
+  if (start === undefined) {
+    if (previousItem === null) {
       start = timelineStart;
-    } else if (previousItem.duration != null) {
+    } else if (!isNullOrUndefined(previousItem.duration)) {
       start = previousItem.start +
               (previousItem.duration * (previousItem.repeatCount + 1));
     }
   }
-  if ((duration == null || isNaN(duration)) &&
-      nextItem != null && nextItem.start != null && !isNaN(nextItem.start) &&
-      start != null && !isNaN(start)
+  if ((duration === undefined || isNaN(duration)) &&
+      nextItem !== null && nextItem.start !== undefined && !isNaN(nextItem.start) &&
+      start !== undefined && !isNaN(start)
   ) {
     duration = nextItem.start - start;
   }
-  if ((start != null && !isNaN(start)) &&
-      (duration != null && !isNaN(duration)) &&
-      (repeatCount == null || !isNaN(repeatCount))
+  if ((start !== undefined && !isNaN(start)) &&
+      (duration !== undefined && !isNaN(duration)) &&
+      (repeatCount === undefined || !isNaN(repeatCount))
   ) {
     return { start,
              duration,

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

@@ -38,6 +38,7 @@ import isSegmentStillAvailable from "../../../../utils/is_segment_still_availabl
 import updateSegmentTimeline from "../../../../utils/update_segment_timeline";
 import { ISegmentTimelineElement } from "../../../node_parser_types";
 import ManifestBoundsCalculator from "../../manifest_bounds_calculator";
+import { IResolvedBaseUrl } from "../../resolve_base_urls";
 import getInitSegment from "../get_init_segment";
 import getSegmentsFromTimeline from "../get_segments_from_timeline";
 import isPeriodFulfilled from "../is_period_fulfilled";
@@ -54,6 +55,8 @@ const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config;
  * given media time.
  */
 export interface ITimelineIndex {
+  /** If `false`, the last segment anounced might be still incomplete. */
+  availabilityTimeComplete : boolean;
   /** Byte range for a possible index of segments in the server. */
   indexRange?: [number, number];
   /**
@@ -141,6 +144,8 @@ export interface ITimelineIndexIndexArgument {
 
 /** Aditional context needed by a SegmentTimeline RepresentationIndex. */
 export interface ITimelineIndexContextArgument {
+  /** If `false`, the last segment anounced might be still incomplete. */
+  availabilityTimeComplete : boolean;
   /** Allows to obtain the minimum and maximum positions of a content. */
   manifestBoundsCalculator : ManifestBoundsCalculator;
   /** Start of the period concerned by this RepresentationIndex, in seconds. */
@@ -155,7 +160,7 @@ export interface ITimelineIndexContextArgument {
    */
   receivedTime? : number;
   /** Base URL for the Representation concerned. */
-  representationBaseURLs : string[];
+  representationBaseURLs : IResolvedBaseUrl[];
   /** ID of the Representation concerned. */
   representationId? : string;
   /** Bitrate of the Representation concerned. */
@@ -231,7 +236,8 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
       throw new Error("The given index is not compatible with a " +
                       "TimelineRepresentationIndex.");
     }
-    const { manifestBoundsCalculator,
+    const { availabilityTimeComplete,
+            manifestBoundsCalculator,
             isDynamic,
             representationBaseURLs,
             representationId,
@@ -269,18 +275,20 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
 
     this._isDynamic = isDynamic;
     this._parseTimeline = index.timelineParser ?? null;
-    this._index = { indexRange: index.indexRange,
+    const urlSources : string[] = representationBaseURLs.map(b => b.url);
+    this._index = { availabilityTimeComplete,
+                    indexRange: index.indexRange,
                     indexTimeOffset,
                     initialization: index.initialization == null ?
                       undefined :
                       {
-                        mediaURLs: createIndexURLs(representationBaseURLs,
+                        mediaURLs: createIndexURLs(urlSources,
                                                    index.initialization.media,
                                                    representationId,
                                                    representationBitrate),
                         range: index.initialization.range,
                       },
-                    mediaURLs: createIndexURLs(representationBaseURLs,
+                    mediaURLs: createIndexURLs(urlSources,
                                                index.media,
                                                representationId,
                                                representationBitrate),

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

@@ -47,7 +47,7 @@ function processFormatedToken(
 }
 
 /**
- * @param {string} representationURL
+ * @param {string} baseURLs
  * @param {string|undefined} media
  * @param {string|undefined} id
  * @param {number|undefined} bitrate
@@ -89,7 +89,7 @@ export function replaceRepresentationDASHTokens(
     return path
       .replace(/\$\$/g, "$")
       .replace(/\$RepresentationID\$/g, String(id))
-      .replace(/\$Bandwidth(|\%0(\d+)d)\$/g,
+      .replace(/\$Bandwidth(\%0(\d+)d)?\$/g,
                processFormatedToken(bitrate === undefined ? 0 :
                                                             bitrate));
   }
@@ -121,13 +121,13 @@ export function createDashUrlDetokenizer(
     } else {
       return url
         .replace(/\$\$/g, "$")
-        .replace(/\$Number(|\%0(\d+)d)\$/g, (_x, _y, widthStr : string) => {
+        .replace(/\$Number(\%0(\d+)d)?\$/g, (_x, _y, widthStr : string) => {
           if (nb === undefined) {
             throw new Error("Segment number not defined in a $Number$ scheme");
           }
           return processFormatedToken(nb)(_x, _y, widthStr);
         })
-        .replace(/\$Time(|\%0(\d+)d)\$/g, (_x, _y, widthStr : string) => {
+        .replace(/\$Time(\%0(\d+)d)?\$/g, (_x, _y, widthStr : string) => {
           if (time === undefined) {
             throw new Error("Segment time not defined in a $Time$ scheme");
           }

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

@@ -30,22 +30,24 @@ import {
 } from "../node_parser_types";
 import attachTrickModeTrack from "./attach_trickmode_track";
 // eslint-disable-next-line max-len
-import extractMinimumAvailabilityTimeOffset from "./extract_minimum_availability_time_offset";
 import inferAdaptationType from "./infer_adaptation_type";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseRepresentations, {
   IAdaptationInfos,
 } from "./parse_representations";
-import resolveBaseURLs from "./resolve_base_urls";
+import resolveBaseURLs, {
+  IResolvedBaseUrl,
+} from "./resolve_base_urls";
 
 /** Context needed when calling `parseAdaptationSets`. */
 export interface IAdaptationSetsContextInfos {
   /** Whether we should request new segments even if they are not yet finished. */
   aggressiveMode : boolean;
+  availabilityTimeComplete: boolean;
   /** availabilityTimeOffset of the concerned period. */
   availabilityTimeOffset: number;
   /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : string[];
+  baseURLs : IResolvedBaseUrl[];
   /** Allows to obtain the first available position of a content. */
   manifestBoundsCalculator : ManifestBoundsCalculator;
   /* End time of the current period, in seconds. */
@@ -302,8 +304,11 @@ export default function parseAdaptationSets(
       roles.some((role) => role.schemeIdUri === "urn:mpeg:dash:role:2011");
 
     const representationsIR = adaptation.children.representations;
+    const availabilityTimeComplete =
+      adaptation.attributes.availabilityTimeComplete ??
+      periodInfos.availabilityTimeComplete;
     const availabilityTimeOffset =
-      extractMinimumAvailabilityTimeOffset(adaptation.children.baseURLs) +
+      (adaptation.attributes.availabilityTimeOffset ?? 0) +
       periodInfos.availabilityTimeOffset;
 
     const adaptationMimeType = adaptation.attributes.mimeType;
@@ -335,6 +340,7 @@ export default function parseAdaptationSets(
 
     const adaptationInfos : IAdaptationInfos = {
       aggressiveMode: periodInfos.aggressiveMode,
+      availabilityTimeComplete,
       availabilityTimeOffset,
       baseURLs: resolveBaseURLs(periodInfos.baseURLs, adaptationChildren.baseURLs),
       manifestBoundsCalculator: periodInfos.manifestBoundsCalculator,

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

@@ -24,8 +24,8 @@ import {
   IMPDIntermediateRepresentation,
   IPeriodIntermediateRepresentation,
 } from "../node_parser_types";
+import { IResponseData } from "../parsers_types";
 // eslint-disable-next-line max-len
-import extractMinimumAvailabilityTimeOffset from "./extract_minimum_availability_time_offset";
 import getClockOffset from "./get_clock_offset";
 import getHTTPUTCTimingURL from "./get_http_utc-timing_url";
 import getMinimumAndMaximumPosition from "./get_minimum_and_maximum_positions";
@@ -33,7 +33,9 @@ import parseAvailabilityStartTime from "./parse_availability_start_time";
 import parsePeriods, {
   IXLinkInfos,
 } from "./parse_periods";
-import resolveBaseURLs from "./resolve_base_urls";
+import resolveBaseURLs, {
+  IResolvedBaseUrl,
+} from "./resolve_base_urls";
 
 const { DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 } = config;
 
@@ -85,7 +87,7 @@ export interface IIrParserResponseNeedsClock {
      * Callback to call with the fetched clock data in argument to continue
      * parsing the MPD.
      */
-    continue : (clockValue : string) => IIrParserResponse;
+    continue : (clockValue : IResponseData<string>) => IIrParserResponse;
   };
 }
 
@@ -157,8 +159,15 @@ export default function parseMpdIr(
           type: "needs-clock",
           value: {
             url: UTCTimingHTTPURL,
-            continue: function continueParsingMPD(clockValue : string) {
-              args.externalClockOffset = getClockOffset(clockValue);
+            continue: function continueParsingMPD(
+              responseDataClock : IResponseData<string>) {
+              if (!responseDataClock.success) {
+                warnings.push(responseDataClock.error);
+                log.warn("DASH Parser: Error on fetching the clock ressource",
+                         responseDataClock.error);
+                return parseMpdIr(mpdIR, args, warnings, true);
+              }
+              args.externalClockOffset = getClockOffset(responseDataClock.data);
               return parseMpdIr(mpdIR, args, warnings, true);
             },
           },
@@ -232,22 +241,21 @@ function parseCompleteIntermediateRepresentation(
   const { children: rootChildren,
           attributes: rootAttributes } = mpdIR;
   const isDynamic : boolean = rootAttributes.type === "dynamic";
-  const baseURLs = resolveBaseURLs(args.url === undefined ?
-                                     [] :
-                                     [normalizeBaseURL(args.url)],
-                                   rootChildren.baseURLs);
+  const initialBaseUrl : IResolvedBaseUrl[] = args.url !== undefined ?
+    [{ url: normalizeBaseURL(args.url),
+       availabilityTimeOffset: 0,
+       availabilityTimeComplete: true }] :
+    [];
+  const mpdBaseUrls = resolveBaseURLs(initialBaseUrl, rootChildren.baseURLs);
   const availabilityStartTime = parseAvailabilityStartTime(rootAttributes,
                                                            args.referenceDateTime);
   const timeShiftBufferDepth = rootAttributes.timeShiftBufferDepth;
   const { externalClockOffset: clockOffset,
           unsafelyBaseOnPreviousManifest } = args;
-  const availabilityTimeOffset =
-    extractMinimumAvailabilityTimeOffset(rootChildren.baseURLs);
 
   const manifestInfos = { aggressiveMode: args.aggressiveMode,
                           availabilityStartTime,
-                          availabilityTimeOffset,
-                          baseURLs,
+                          baseURLs: mpdBaseUrls,
                           clockOffset,
                           duration: rootAttributes.duration,
                           isDynamic,

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

@@ -31,12 +31,13 @@ import {
   IPeriodIntermediateRepresentation,
 } from "../node_parser_types";
 // eslint-disable-next-line max-len
-import extractMinimumAvailabilityTimeOffset from "./extract_minimum_availability_time_offset";
 import flattenOverlappingPeriods from "./flatten_overlapping_periods";
 import getPeriodsTimeInformation from "./get_periods_time_infos";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseAdaptationSets from "./parse_adaptation_sets";
-import resolveBaseURLs from "./resolve_base_urls";
+import resolveBaseURLs, {
+  IResolvedBaseUrl,
+} from "./resolve_base_urls";
 
 const generatePeriodID = idGenerator();
 
@@ -54,9 +55,8 @@ export type IXLinkInfos = WeakMap<IPeriodIntermediateRepresentation, {
 export interface IPeriodsContextInfos {
   /** Whether we should request new segments even if they are not yet finished. */
   aggressiveMode : boolean;
-  availabilityTimeOffset: number;
   availabilityStartTime : number;
-  baseURLs : string[];
+  baseURLs : IResolvedBaseUrl[];
   clockOffset? : number;
   duration? : number;
   isDynamic : boolean;
@@ -141,14 +141,13 @@ export default function parsePeriods(
     const receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime :
                                                     contextInfos.receivedTime;
 
-    const availabilityTimeOffset =
-      extractMinimumAvailabilityTimeOffset(periodIR.children.baseURLs) +
-      contextInfos.availabilityTimeOffset;
-
     const unsafelyBaseOnPreviousPeriod = contextInfos
       .unsafelyBaseOnPreviousManifest?.getPeriod(periodID) ?? null;
 
+    const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete ?? true;
+    const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset ?? 0;
     const periodInfos = { aggressiveMode: contextInfos.aggressiveMode,
+                          availabilityTimeComplete,
                           availabilityTimeOffset,
                           baseURLs: periodBaseURLs,
                           manifestBoundsCalculator,

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

@@ -26,8 +26,6 @@ import {
   ISegmentTemplateIntermediateRepresentation,
   IScheme,
 } from "../node_parser_types";
-// eslint-disable-next-line max-len
-import extractMinimumAvailabilityTimeOffset from "./extract_minimum_availability_time_offset";
 import {
   BaseRepresentationIndex,
   ListRepresentationIndex,
@@ -35,7 +33,9 @@ import {
   TimelineRepresentationIndex,
 } from "./indexes";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import resolveBaseURLs from "./resolve_base_urls";
+import resolveBaseURLs, {
+  IResolvedBaseUrl,
+} from "./resolve_base_urls";
 
 /** Supplementary context needed to parse a RepresentationIndex. */
 export interface IRepresentationInfos {
@@ -43,10 +43,11 @@ export interface IRepresentationInfos {
   adaptation : IAdaptationSetIntermediateRepresentation;
   /** Whether we should request new segments even if they are not yet finished. */
   aggressiveMode : boolean;
+  availabilityTimeComplete : boolean;
   /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset: number;
+  availabilityTimeOffset : number;
   /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : string[];
+  baseURLs : IResolvedBaseUrl[];
   /** Allows to obtain the first/last available position of a dynamic content. */
   manifestBoundsCalculator : ManifestBoundsCalculator;
   /** End time of the current period, in seconds. */
@@ -111,6 +112,7 @@ export default function parseRepresentationIndex(
       .some(({ schemeIdUri }) => schemeIdUri === inbandEvent.schemeIdUri);
   };
   const context = { aggressiveMode,
+                    availabilityTimeComplete: true,
                     availabilityTimeOffset,
                     unsafelyBaseOnPreviousRepresentation,
                     isEMSGWhitelisted,
@@ -126,10 +128,6 @@ export default function parseRepresentationIndex(
   let representationIndex : IRepresentationIndex;
   if (representation.children.segmentBase !== undefined) {
     const { segmentBase } = representation.children;
-    context.availabilityTimeOffset =
-      representationInfos.availabilityTimeOffset +
-      extractMinimumAvailabilityTimeOffset(representation.children.baseURLs) +
-      (segmentBase.availabilityTimeOffset ?? 0);
     representationIndex = new BaseRepresentationIndex(segmentBase, context);
   } else if (representation.children.segmentList !== undefined) {
     const { segmentList } = representation.children;
@@ -147,10 +145,12 @@ export default function parseRepresentationIndex(
                    ...segmentTemplates as [
                      ISegmentTemplateIntermediateRepresentation
                    ] /* Ugly TS Hack */);
+    context.availabilityTimeComplete =
+      segmentTemplate.availabilityTimeComplete ??
+      representationInfos.availabilityTimeComplete;
     context.availabilityTimeOffset =
-      representationInfos.availabilityTimeOffset +
-      extractMinimumAvailabilityTimeOffset(representation.children.baseURLs) +
-      (segmentTemplate.availabilityTimeOffset ?? 0);
+      (segmentTemplate.availabilityTimeOffset ?? 0) +
+      representationInfos.availabilityTimeOffset;
     representationIndex = TimelineRepresentationIndex
       .isTimelineIndexArgument(segmentTemplate) ?
         new TimelineRepresentationIndex(segmentTemplate, context) :

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

@@ -28,10 +28,12 @@ import {
   IRepresentationIntermediateRepresentation,
   ISegmentTemplateIntermediateRepresentation,
   IScheme,
+  IContentProtectionIntermediateRepresentation,
 } from "../node_parser_types";
 import { getWEBMHDRInformation } from "./get_hdr_information";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseRepresentationIndex from "./parse_representation_index";
+import { IResolvedBaseUrl } from "./resolve_base_urls";
 
 /**
  * Combine inband event streams from representation and
@@ -61,10 +63,11 @@ function combineInbandEventStreams(
 export interface IAdaptationInfos {
   /** Whether we should request new segments even if they are not yet finished. */
   aggressiveMode : boolean;
+  availabilityTimeComplete: boolean;
   /** availability time offset of the concerned Adaptation. */
   availabilityTimeOffset: number;
   /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : string[];
+  baseURLs : IResolvedBaseUrl[];
   /** Allows to obtain the first/last available position of a dynamic content. */
   manifestBoundsCalculator : ManifestBoundsCalculator;
   /** End time of the current period, in seconds. */
@@ -175,8 +178,16 @@ export default function parseRepresentations(
     const inbandEventStreams =
       combineInbandEventStreams(representation, adaptation);
 
+    const availabilityTimeComplete =
+      representation.attributes.availabilityTimeComplete ??
+      adaptationInfos.availabilityTimeComplete;
+    const availabilityTimeOffset =
+      (representation.attributes.availabilityTimeOffset ?? 0) +
+      adaptationInfos.availabilityTimeOffset;
     const representationInfos = objectAssign({}, adaptationInfos,
-                                             { unsafelyBaseOnPreviousRepresentation,
+                                             { availabilityTimeOffset,
+                                               availabilityTimeComplete,
+                                               unsafelyBaseOnPreviousRepresentation,
                                                adaptation,
                                                inbandEventStreams });
     const representationIndex = parseRepresentationIndex(representation,
@@ -237,8 +248,16 @@ export default function parseRepresentations(
         adaptation.attributes.width;
     }
 
-    if (adaptation.children.contentProtections != null) {
-      const contentProtections = adaptation.children.contentProtections
+    const contentProtectionsIr : IContentProtectionIntermediateRepresentation[] =
+      adaptation.children.contentProtections !== undefined ?
+        adaptation.children.contentProtections :
+        [];
+    if (representation.children.contentProtections !== undefined) {
+      contentProtectionsIr.push(...representation.children.contentProtections);
+    }
+
+    if (contentProtectionsIr.length > 0) {
+      const contentProtections = contentProtectionsIr
         .reduce<IContentProtections>((acc, cp) => {
           let systemId : string|undefined;
           if (cp.attributes.schemeIdUri !== undefined &&