rx-player 4.0.0-dev.2023110700 → 4.0.0-dev.2023120600

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

@@ -20,16 +20,6 @@ import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
  * This class allows to easily calculate the first and last available positions
  * in a content at any time.
  *
- * That task can be an hard for dynamic DASH contents: it depends on a
- * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
- * position.
- *
- * The latter can come from either a clock synchronization mechanism or the
- * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
- * Periods.
- * As such, it might only be known once a large chunk of the MPD has already
- * been parsed.
- *
  * By centralizing the manifest bounds calculation in this class and by giving
  * an instance of it to each parsed elements which might depend on it, we
  * ensure that we can provide it once it is known to every one of those
@@ -37,8 +27,18 @@ import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
  * @class ManifestBoundsCalculator
  */
 export default class ManifestBoundsCalculator {
-  /** Value of MPD@timeShiftBufferDepth. */
+  /**
+   * Value of MPD@timeShiftBufferDepth.
+   * `null` if not defined.
+   */
   private _timeShiftBufferDepth : number | null;
+  /**
+   * Value of MPD@availabilityStartTime as an unix timestamp in seconds.
+   * `0` if it wasn't defined.
+   */
+  private _availabilityStartTime : number;
+  /** `true` if MPD@type is equal to "dynamic". */
+  private _isDynamic : boolean;
   /**
    * Monotonically-raising timestamp (the one used by the RxPlayer) when
    * `lastPosition` was calculated.
@@ -46,20 +46,30 @@ export default class ManifestBoundsCalculator {
   private _positionTime : number | undefined;
   /** Last position calculated at a given moment (itself indicated by `_positionTime`. */
   private _lastPosition : number | undefined;
-  /** `true` if MPD@type is equal to "dynamic". */
-  private _isDynamic : boolean;
+  /**
+   * Offset to add to `performance.now` to obtain a good estimation of the
+   * server-side unix timestamp.
+   *
+   * `undefined` if unknown.
+   */
+  private _serverTimestampOffset : number | undefined;
 
   /**
    * @param {Object} args
    */
-  constructor(args : { timeShiftBufferDepth : number | undefined;
-                       isDynamic : boolean; }
-  ) {
+  constructor(args : {
+    availabilityStartTime : number;
+    timeShiftBufferDepth : number | undefined;
+    isDynamic : boolean;
+    serverTimestampOffset: number | undefined;
+  }) {
     this._isDynamic = args.isDynamic;
     this._timeShiftBufferDepth = !args.isDynamic ||
                                  args.timeShiftBufferDepth === undefined ?
                                    null :
                                    args.timeShiftBufferDepth;
+    this._serverTimestampOffset = args.serverTimestampOffset;
+    this._availabilityStartTime = args.availabilityStartTime;
   }
 
   /**
@@ -102,11 +112,12 @@ export default class ManifestBoundsCalculator {
    * Consider that it is only an estimation, not the real value.
    * @return {number|undefined}
    */
-  estimateMinimumBound(): number | undefined {
+  getEstimatedMinimumSegmentTime(): number | undefined {
     if (!this._isDynamic || this._timeShiftBufferDepth === null) {
       return 0;
     }
-    const maximumBound = this.estimateMaximumBound();
+    const maximumBound = this.getEstimatedLiveEdge() ??
+                         this.getEstimatedMaximumPosition(0);
     if (maximumBound === undefined) {
       return undefined;
     }
@@ -115,15 +126,42 @@ export default class ManifestBoundsCalculator {
   }
 
   /**
-   * Estimate a maximum bound for the content from the last set segment time.
-   * Consider that it is only an estimation, not the real value.
+   * Estimate the segment time in seconds that corresponds to what could be
+   * considered the live edge (or `undefined` for non-live contents).
+   *
+   * Note that for some contents which just anounce segments in advance, this
+   * value might be very different than the maximum position that is
+   * requestable.
    * @return {number|undefined}
    */
-  estimateMaximumBound() : number | undefined {
-    if (this._isDynamic &&
-        this._positionTime != null &&
-        this._lastPosition != null)
-    {
+  getEstimatedLiveEdge() : number | undefined {
+    if (!this._isDynamic || this._serverTimestampOffset === undefined) {
+      return undefined;
+    }
+    return (getMonotonicTimeStamp() + this._serverTimestampOffset) / 1000 -
+      this._availabilityStartTime;
+  }
+
+  /**
+   * Produce a rough estimate of the ending time of the last requestable segment
+   * in that content.
+   *
+   * This value is only an estimate and may be far from reality.
+   *
+   * The `availabilityTimeOffset` in argument is the corresponding
+   * `availabilityTimeOffset` that applies to the current wanted segment, or `0`
+   * if none exist. It will be applied on live content to deduce the maximum
+   * segment time available.
+   */
+  getEstimatedMaximumPosition(availabilityTimeOffset: number) : number | undefined {
+    if (!this._isDynamic) {
+      return this._lastPosition;
+    }
+
+    const liveEdge = this.getEstimatedLiveEdge();
+    if (liveEdge !== undefined && availabilityTimeOffset !== Infinity) {
+      return liveEdge + availabilityTimeOffset;
+    } else if (this._positionTime !== undefined && this._lastPosition !== undefined) {
       return Math.max((this._lastPosition - this._positionTime) +
                         (getMonotonicTimeStamp() / 1000),
                       0);

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

@@ -281,12 +281,19 @@ export default function parseAdaptationSets(
       roles.some((role) => role.schemeIdUri === "urn:mpeg:dash:role:2011");
 
     const representationsIR = adaptation.children.representations;
+
     const availabilityTimeComplete =
       adaptation.attributes.availabilityTimeComplete ??
       context.availabilityTimeComplete;
-    const availabilityTimeOffset =
-      (adaptation.attributes.availabilityTimeOffset ?? 0) +
-      context.availabilityTimeOffset;
+
+    let availabilityTimeOffset;
+    if (
+      adaptation.attributes.availabilityTimeOffset !== undefined ||
+      context.availabilityTimeOffset !== undefined
+    ) {
+      availabilityTimeOffset = (adaptation.attributes.availabilityTimeOffset ?? 0) +
+                               (context.availabilityTimeOffset ?? 0);
+    }
 
     const adaptationMimeType = adaptation.attributes.mimeType;
     const adaptationCodecs = adaptation.attributes.codecs;
@@ -327,7 +334,6 @@ export default function parseAdaptationSets(
       parentSegmentTemplates,
       receivedTime: context.receivedTime,
       start: context.start,
-      timeShiftBufferDepth: context.timeShiftBufferDepth,
       unsafelyBaseOnPreviousAdaptation: null,
     };
 

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

@@ -30,6 +30,7 @@ import { IResponseData } from "../parsers_types";
 import getClockOffset from "./get_clock_offset";
 import getHTTPUTCTimingURL from "./get_http_utc-timing_url";
 import getMinimumAndMaximumPositions from "./get_minimum_and_maximum_positions";
+import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseAvailabilityStartTime from "./parse_availability_start_time";
 import parsePeriods, {
   IXLinkInfos,
@@ -252,11 +253,19 @@ function parseCompleteIntermediateRepresentation(
   const { externalClockOffset: clockOffset,
           unsafelyBaseOnPreviousManifest } = args;
 
+  const { externalClockOffset } = args;
+  const manifestBoundsCalculator = new ManifestBoundsCalculator({
+    availabilityStartTime,
+    isDynamic,
+    timeShiftBufferDepth,
+    serverTimestampOffset: externalClockOffset,
+  });
   const manifestInfos = { availabilityStartTime,
                           baseURLs: mpdBaseUrls,
                           clockOffset,
                           duration: rootAttributes.duration,
                           isDynamic,
+                          manifestBoundsCalculator,
                           manifestProfiles: mpdIR.attributes.profiles,
                           receivedTime: args.manifestReceivedTime,
                           timeShiftBufferDepth,
@@ -313,31 +322,33 @@ function parseCompleteIntermediateRepresentation(
                         livePosition: undefined,
                         time: now };
   } else {
-    minimumTime = minimumSafePosition;
-    timeshiftDepth = timeShiftBufferDepth ?? null;
+    // Determine the maximum seekable position
     let finalMaximumSafePosition : number;
-    let livePosition;
-
-    if (maximumUnsafePosition !== undefined) {
-      livePosition = maximumUnsafePosition;
-    }
-
     if (maximumSafePosition !== undefined) {
       finalMaximumSafePosition = maximumSafePosition;
     } else {
-      const ast = availabilityStartTime ?? 0;
-      const { externalClockOffset } = args;
       if (externalClockOffset === undefined) {
         log.warn("DASH Parser: use system clock to define maximum position");
-        finalMaximumSafePosition = (Date.now() / 1000) - ast;
+        finalMaximumSafePosition = (Date.now() / 1000) - availabilityStartTime;
       } else {
         const serverTime = getMonotonicTimeStamp() + externalClockOffset;
-        finalMaximumSafePosition = (serverTime / 1000) - ast;
+        finalMaximumSafePosition = (serverTime / 1000) - availabilityStartTime;
       }
     }
+
+    // Determine live edge (what position corresponds to live content, can be
+    // inferior or superior to the maximum anounced position in some specific
+    // scenarios). However, the `timeShiftBufferDepth` should be based on it.
+    let livePosition = manifestBoundsCalculator.getEstimatedLiveEdge();
     if (livePosition === undefined) {
-      livePosition = finalMaximumSafePosition;
+      if (maximumUnsafePosition !== undefined) {
+        livePosition = maximumUnsafePosition;
+      } else {
+        livePosition = finalMaximumSafePosition;
+      }
+      // manifestBoundsCalculator.forceLiveEdge(livePosition);
     }
+
     maximumTimeData = { isLinear: true,
                         maximumSafePosition: finalMaximumSafePosition,
                         livePosition,
@@ -345,10 +356,12 @@ function parseCompleteIntermediateRepresentation(
 
     // if the minimum calculated time is even below the buffer depth, perhaps we
     // can go even lower in terms of depth
+    minimumTime = minimumSafePosition;
+    timeshiftDepth = timeShiftBufferDepth ?? null;
     if (timeshiftDepth !== null && minimumTime !== undefined &&
-        finalMaximumSafePosition - minimumTime > timeshiftDepth)
+        livePosition - minimumTime > timeshiftDepth)
     {
-      timeshiftDepth = finalMaximumSafePosition - minimumTime;
+      timeshiftDepth = livePosition - minimumTime;
     }
   }
 

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

@@ -18,6 +18,7 @@ import log from "../../../../log";
 import Manifest from "../../../../manifest";
 import flatMap from "../../../../utils/flat_map";
 import idGenerator from "../../../../utils/id_generator";
+import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
 import objectValues from "../../../../utils/object_values";
 import { utf8ToStr } from "../../../../utils/string_parsing";
@@ -34,7 +35,6 @@ import {
 // eslint-disable-next-line max-len
 import flattenOverlappingPeriods from "./flatten_overlapping_periods";
 import getPeriodsTimeInformation from "./get_periods_time_infos";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseAdaptationSets, {
   IAdaptationSetContext,
 } from "./parse_adaptation_sets";
@@ -68,12 +68,9 @@ export default function parsePeriods(
     throw new Error("MPD parsing error: the time information are incoherent.");
   }
 
-  const { isDynamic,
-          timeShiftBufferDepth } = context;
-  const manifestBoundsCalculator = new ManifestBoundsCalculator({ isDynamic,
-                                                                  timeShiftBufferDepth });
+  const { isDynamic, manifestBoundsCalculator } = context;
 
-  if (!isDynamic && context.duration != null) {
+  if (!isDynamic && !isNullOrUndefined(context.duration)) {
     manifestBoundsCalculator.setLastPosition(context.duration);
   }
 
@@ -91,7 +88,7 @@ export default function parsePeriods(
             periodEnd } = periodsTimeInformation[i];
 
     let periodID : string;
-    if (periodIR.attributes.id == null) {
+    if (isNullOrUndefined(periodIR.attributes.id)) {
       log.warn("DASH: No usable id found in the Period. Generating one.");
       periodID = "gen-dash-period-" + generatePeriodID();
     } else {
@@ -109,8 +106,8 @@ export default function parsePeriods(
     const unsafelyBaseOnPreviousPeriod = context
       .unsafelyBaseOnPreviousManifest?.getPeriod(periodID) ?? null;
 
-    const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete ?? true;
-    const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset ?? 0;
+    const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete;
+    const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset;
     const { manifestProfiles } = context;
     const { segmentTemplate } = periodIR.children;
     const adapCtxt : IAdaptationSetContext = { availabilityTimeComplete,
@@ -124,7 +121,6 @@ export default function parsePeriods(
                                                receivedTime,
                                                segmentTemplate,
                                                start: periodStart,
-                                               timeShiftBufferDepth,
                                                unsafelyBaseOnPreviousPeriod };
     const adaptations = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
 
@@ -208,7 +204,7 @@ function guessLastPositionFromClock(
   context : IPeriodContext,
   minimumTime : number
 ) : [number, number] | undefined {
-  if (context.clockOffset != null) {
+  if (!isNullOrUndefined(context.clockOffset)) {
     const lastPosition = context.clockOffset / 1000 -
       context.availabilityStartTime;
     const positionTime = getMonotonicTimeStamp() / 1000;
@@ -245,7 +241,7 @@ function getMaximumLastPosition(
   let maxEncounteredPosition : number | null = null;
   let allIndexAreEmpty = true;
   const adaptationsVal = objectValues(adaptationsPerType)
-    .filter((ada) : ada is IParsedAdaptation[] => ada != null);
+    .filter((ada) : ada is IParsedAdaptation[] => !isNullOrUndefined(ada));
   const allAdaptations = flatMap(adaptationsVal,
                                  (adaptationsForType) => adaptationsForType);
   for (const adaptation of allAdaptations) {
@@ -256,15 +252,15 @@ function getMaximumLastPosition(
         allIndexAreEmpty = false;
         if (typeof position === "number") {
           maxEncounteredPosition =
-            maxEncounteredPosition == null ? position :
-                                             Math.max(maxEncounteredPosition,
-                                                      position);
+            isNullOrUndefined(maxEncounteredPosition) ? position :
+                                                        Math.max(maxEncounteredPosition,
+                                                                 position);
         }
       }
     }
   }
 
-  if (maxEncounteredPosition != null) {
+  if (!isNullOrUndefined(maxEncounteredPosition)) {
     return maxEncounteredPosition;
   } else if (allIndexAreEmpty) {
     return null;
@@ -369,6 +365,5 @@ type IInheritedAdaptationContext = Omit<IAdaptationSetContext,
                                         "availabilityTimeOffset" |
                                         "duration" |
                                         "isLastPeriod" |
-                                        "manifestBoundsCalculator" |
                                         "start" |
                                         "unsafelyBaseOnPreviousPeriod">;

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

@@ -31,6 +31,10 @@ import {
   ListRepresentationIndex,
   TemplateRepresentationIndex,
   TimelineRepresentationIndex,
+  IBaseIndexContextArgument,
+  IListIndexContextArgument,
+  ITemplateIndexContextArgument,
+  ITimelineIndexContextArgument,
 } from "./indexes";
 import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import { IResolvedBaseUrl } from "./resolve_base_urls";
@@ -52,7 +56,6 @@ export default function parseRepresentationIndex(
           end: periodEnd,
           start: periodStart,
           receivedTime,
-          timeShiftBufferDepth,
           unsafelyBaseOnPreviousRepresentation,
           inbandEventStreams,
           isLastPeriod } = context;
@@ -64,19 +67,24 @@ export default function parseRepresentationIndex(
     return inbandEventStreams
       .some(({ schemeIdUri }) => schemeIdUri === inbandEvent.schemeIdUri);
   };
-  const reprIndexCtxt = { availabilityTimeComplete: true,
-                          availabilityTimeOffset,
-                          unsafelyBaseOnPreviousRepresentation,
-                          isEMSGWhitelisted,
-                          isLastPeriod,
-                          manifestBoundsCalculator,
-                          isDynamic,
-                          periodEnd,
-                          periodStart,
-                          receivedTime,
-                          representationBitrate: representation.attributes.bitrate,
-                          representationId: representation.attributes.id,
-                          timeShiftBufferDepth };
+  const reprIndexCtxt: ITimelineIndexContextArgument |
+                       ITemplateIndexContextArgument |
+                       IListIndexContextArgument |
+                       IBaseIndexContextArgument =
+    {
+      availabilityTimeComplete: undefined,
+      availabilityTimeOffset,
+      unsafelyBaseOnPreviousRepresentation,
+      isEMSGWhitelisted,
+      isLastPeriod,
+      manifestBoundsCalculator,
+      isDynamic,
+      periodEnd,
+      periodStart,
+      receivedTime,
+      representationBitrate: representation.attributes.bitrate,
+      representationId: representation.attributes.id,
+    };
   let representationIndex : IRepresentationIndex;
   if (representation.children.segmentBase !== undefined) {
     const { segmentBase } = representation.children;
@@ -97,12 +105,15 @@ export default function parseRepresentationIndex(
                    ...segmentTemplates as [
                      ISegmentTemplateIntermediateRepresentation
                    ] /* Ugly TS Hack */);
-    reprIndexCtxt.availabilityTimeComplete =
-      segmentTemplate.availabilityTimeComplete ??
-      context.availabilityTimeComplete;
-    reprIndexCtxt.availabilityTimeOffset =
-      (segmentTemplate.availabilityTimeOffset ?? 0) +
-      context.availabilityTimeOffset;
+    if (
+      segmentTemplate.availabilityTimeOffset !== undefined ||
+      context.availabilityTimeOffset !== undefined
+    ) {
+      reprIndexCtxt.availabilityTimeOffset =
+        (segmentTemplate.availabilityTimeOffset ?? 0) +
+        (context.availabilityTimeOffset ?? 0);
+    }
+
     representationIndex = TimelineRepresentationIndex
       .isTimelineIndexArgument(segmentTemplate) ?
         new TimelineRepresentationIndex(segmentTemplate, reprIndexCtxt) :
@@ -131,10 +142,25 @@ export default function parseRepresentationIndex(
 export interface IRepresentationIndexContext {
   /** Parsed AdaptationSet which contains the Representation. */
   adaptation : IAdaptationSetIntermediateRepresentation;
-  /** If false, declared segments in the MPD might still be not completely generated. */
-  availabilityTimeComplete : boolean;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset : number;
+  /**
+   * If `false`, declared segments in the MPD might still be not completely generated.
+   * If `true`, they are completely generated.
+   *
+   * If `undefined`, the corresponding property was not set in the MPD and it is
+   * thus assumed that they are all generated.
+   * It might however be semantically different than `true` in the RxPlayer as it
+   * means that the packager didn't include that information in the MPD.
+   */
+  availabilityTimeComplete : boolean | undefined;
+  /**
+   * availability time offset of the concerned Adaptation.
+   *
+   * If `undefined`, the corresponding property was not set in the MPD and it is
+   * thus assumed to be equal to `0`.
+   * It might however be semantically different than `0` in the RxPlayer as it
+   * means that the packager didn't include that information in the MPD.
+   */
+  availabilityTimeOffset : number | undefined;
   /** Eventual URLs from which every relative URL will be based on. */
   baseURLs : IResolvedBaseUrl[];
   /** End time of the current Period, in seconds. */
@@ -163,8 +189,6 @@ export interface IRepresentationIndexContext {
   receivedTime? : number | undefined;
   /** Start time of the current period, in seconds. */
   start : number;
-  /** Depth of the buffer for the whole content, in seconds. */
-  timeShiftBufferDepth? : number | undefined;
   /**
    * The parser should take this Representation - which is the same as this one
    * parsed at an earlier time - as a base to speed-up the parsing process.

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

@@ -29,6 +29,7 @@ import {
   IScheme,
   IContentProtectionIntermediateRepresentation,
 } from "../node_parser_types";
+import { convertSupplementalCodecsToRFC6381 } from "./convert_supplemental_codecs";
 import { getWEBMHDRInformation } from "./get_hdr_information";
 import parseRepresentationIndex, {
   IRepresentationIndexContext,
@@ -120,19 +121,19 @@ export default function parseRepresentations(
   const parsedRepresentations : IParsedRepresentation[] = [];
   for (const representation of representationsIR) {
     // Compute Representation ID
-    let representationID = representation.attributes.id != null ?
+    let representationID = representation.attributes.id !== undefined ?
       representation.attributes.id :
       (String(representation.attributes.bitrate) +
-         (representation.attributes.height != null ?
+         (representation.attributes.height !== undefined ?
             (`-${representation.attributes.height}`) :
             "") +
-         (representation.attributes.width != null ?
+         (representation.attributes.width !== undefined ?
             (`-${representation.attributes.width}`) :
             "") +
-         (representation.attributes.mimeType != null ?
+         (representation.attributes.mimeType !== undefined ?
             (`-${representation.attributes.mimeType}`) :
             "") +
-         (representation.attributes.codecs != null ?
+         (representation.attributes.codecs !== undefined ?
             (`-${representation.attributes.codecs}`) :
             ""));
 
@@ -152,9 +153,15 @@ export default function parseRepresentations(
     const availabilityTimeComplete =
       representation.attributes.availabilityTimeComplete ??
       context.availabilityTimeComplete;
-    const availabilityTimeOffset =
-      (representation.attributes.availabilityTimeOffset ?? 0) +
-      context.availabilityTimeOffset;
+
+    let availabilityTimeOffset: number | undefined;
+    if (
+      representation.attributes.availabilityTimeOffset !== undefined ||
+      context.availabilityTimeOffset !== undefined
+    ) {
+      availabilityTimeOffset = (representation.attributes.availabilityTimeOffset ?? 0) +
+                               (context.availabilityTimeOffset ?? 0);
+    }
     const reprIndexCtxt = objectAssign({},
                                        context,
                                        { availabilityTimeOffset,
@@ -167,7 +174,7 @@ export default function parseRepresentations(
 
     // Find bitrate
     let representationBitrate : number;
-    if (representation.attributes.bitrate == null) {
+    if (representation.attributes.bitrate === undefined) {
       log.warn("DASH: No usable bitrate found in the Representation.");
       representationBitrate = 0;
     } else {
@@ -204,40 +211,52 @@ export default function parseRepresentations(
 
     // Add optional attributes
     let codecs : string|undefined;
-    if (representation.attributes.codecs != null) {
+    if (representation.attributes.codecs !== undefined) {
       codecs = representation.attributes.codecs;
-    } else if (adaptation.attributes.codecs != null) {
+    } else if (adaptation.attributes.codecs !== undefined) {
       codecs = adaptation.attributes.codecs;
     }
-    if (codecs != null) {
+    if (codecs !== undefined) {
       codecs = codecs === "mp4a.40.02" ? "mp4a.40.2" : codecs;
       parsedRepresentation.codecs = codecs;
     }
-    if (representation.attributes.frameRate != null) {
+
+    let supplementalCodecs: string | undefined;
+    if (representation.attributes.supplementalCodecs !== undefined) {
+      supplementalCodecs = representation.attributes.supplementalCodecs;
+    } else if (adaptation.attributes.supplementalCodecs !== undefined) {
+      supplementalCodecs = adaptation.attributes.supplementalCodecs;
+    }
+    if (supplementalCodecs !== undefined) {
+      parsedRepresentation.supplementalCodecs =
+        convertSupplementalCodecsToRFC6381(supplementalCodecs);
+    }
+
+    if (representation.attributes.frameRate !== undefined) {
       parsedRepresentation.frameRate =
         representation.attributes.frameRate;
-    } else if (adaptation.attributes.frameRate != null) {
+    } else if (adaptation.attributes.frameRate !== undefined) {
       parsedRepresentation.frameRate =
         adaptation.attributes.frameRate;
     }
-    if (representation.attributes.height != null) {
+    if (representation.attributes.height !== undefined) {
       parsedRepresentation.height =
         representation.attributes.height;
-    } else if (adaptation.attributes.height != null) {
+    } else if (adaptation.attributes.height !== undefined) {
       parsedRepresentation.height =
         adaptation.attributes.height;
     }
-    if (representation.attributes.mimeType != null) {
+    if (representation.attributes.mimeType !== undefined) {
       parsedRepresentation.mimeType =
         representation.attributes.mimeType;
-    } else if (adaptation.attributes.mimeType != null) {
+    } else if (adaptation.attributes.mimeType !== undefined) {
       parsedRepresentation.mimeType =
         adaptation.attributes.mimeType;
     }
-    if (representation.attributes.width != null) {
+    if (representation.attributes.width !== undefined) {
       parsedRepresentation.width =
         representation.attributes.width;
-    } else if (adaptation.attributes.width != null) {
+    } else if (adaptation.attributes.width !== undefined) {
       parsedRepresentation.width =
         adaptation.attributes.width;
     }

package/src/parsers/manifest/dash/js-parser/node_parsers/AdaptationSet.ts

@@ -300,6 +300,10 @@ function parseAdaptationSetAttributes(
         parsedAdaptation.codecs = attribute.value;
         break;
 
+      case "scte214:supplementalCodecs":
+        parsedAdaptation.supplementalCodecs = attribute.value;
+        break;
+
       case "codingDependency":
         parseValue(attribute.value, { asKey: "codingDependency",
                                       parser: parseBoolean,

package/src/parsers/manifest/dash/js-parser/node_parsers/Representation.ts

@@ -187,6 +187,10 @@ function parseRepresentationAttributes(
                                  dashName: "qualityRanking" });
         break;
 
+      case "scte214:supplementalCodecs":
+        attributes.supplementalCodecs = attr.value;
+        break;
+
       case "segmentProfiles":
         attributes.segmentProfiles = attr.value;
         break;

package/src/parsers/manifest/dash/node_parser_types.ts

@@ -232,6 +232,7 @@ export interface IAdaptationSetAttributes {
   segmentAlignment? : number|boolean;
   segmentProfiles? : string;
   subsegmentAlignment? : number|boolean;
+  supplementalCodecs?: string;
   width? : number;
   availabilityTimeComplete?: boolean;
   availabilityTimeOffset?: number;
@@ -271,6 +272,7 @@ export interface IRepresentationAttributes {
   profiles? : string;
   qualityRanking? : number;
   segmentProfiles? : string;
+  supplementalCodecs?: string;
   width? : number;
   availabilityTimeComplete?: boolean;
   availabilityTimeOffset?: number;

package/src/parsers/manifest/dash/wasm-parser/rs/events.rs

@@ -280,6 +280,8 @@ pub enum AttributeName {
 
     // SegmentTemplate
     EndNumber = 76, // f64
+
+    SupplementalCodecs = 77 // string
 }
 
 impl TagName {