@amazon/vinyl 1.0.0

package/dist/types/current/track/dash/timeline/DashRepresentationSegmentProvider.js

@@ -0,0 +1,333 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin, getSidxSampleTimes, parseSidxBox, ValidationError, } from '@amazon/vinyl-util';
+import { calculatePeriodTimeRange, getSegmentBase, getSegmentList, getSegmentTemplate, sampleToMpdTime, } from '../../../track/dash/util/mpd';
+import { resolveDashUri, segmentTemplateUrl, } from '../../../track/dash/util/uriResolution';
+import { createSegmentDataProvider, } from '../../../track/createSegmentDataProvider';
+import { getSegmentAtTime } from '../../../streaming/util/segment';
+/**
+ * Creates a representation timeline for the given representation.
+ */
+export function createDashRepresentationSegmentProvider(deps, baseUrl, representation) {
+    const quality = deps.mediaQualityMetadataResolver(representation);
+    const options = {
+        baseUrl,
+        periodTimeRange: calculatePeriodTimeRange(representation.parent.parent),
+        representation,
+    };
+    // 5.3.9.1 General
+    // The elements SegmentBase, SegmentTemplate and SegmentList may be present in the
+    // Representation element itself. In addition, to express default values, they may be present in the
+    // Period and AdaptationSet element. At each level at most one of the three, SegmentBase,
+    // SegmentTemplate and SegmentList, shall be present. Further, if SegmentTemplate or SegmentList is present on
+    // one level of the hierarchy, then the other one shall not be present on any lower hierarchy level.
+    const segmentTemplate = getSegmentTemplate(representation);
+    const segmentList = getSegmentList(representation);
+    const segmentBase = getSegmentBase(representation);
+    let segmentsPromise = null;
+    let initUri;
+    let initRange;
+    if (segmentTemplate?.initialization) {
+        initUri = segmentTemplateUrl(segmentTemplate.initialization, {
+            representation,
+        });
+    }
+    const commonSegmentBase = segmentTemplate ?? segmentList ?? segmentBase;
+    if (!commonSegmentBase)
+        throw new ValidationError('Manifest must have one of SegmentList, SegmentTemplate, or SegmentBase', ErrorOrigin.MEDIA);
+    if (commonSegmentBase.Initialization) {
+        initUri = commonSegmentBase.Initialization.sourceURL;
+        initRange = commonSegmentBase.Initialization.range;
+    }
+    if (!initUri && !initRange)
+        throw new ValidationError('Missing initialization range', ErrorOrigin.MEDIA);
+    const { url: initUrl, serviceLocation: initServiceLocation } = resolveDashUri(deps, { baseUrl, representation, uri: initUri });
+    const initData = createSegmentDataProvider(deps, {
+        url: initUrl,
+        mediaRange: initRange,
+        serviceId: initServiceLocation,
+        reportDownlinkMetrics: false,
+    });
+    let getSegmentReferences;
+    // If an index range is present, use that to calculate segment data.
+    // The index location may be defined in several locations:
+    // SegmentBase.indexRange, SegmentBase.RepresentationIndex, or SegmentTemplate.index
+    // One of segmentList, segmentTemplate, or segmentBase is guaranteed to be set.
+    if (segmentList) {
+        getSegmentReferences = () => createSegmentsFromSegmentList(deps, {
+            ...options,
+            segmentList,
+        });
+    }
+    else if (segmentTemplate) {
+        getSegmentReferences = () => createSegmentsFromSegmentTemplate(deps, {
+            ...options,
+            segmentTemplate,
+        });
+    }
+    else if (segmentBase) {
+        getSegmentReferences = () => createSegmentsFromSegmentBase(deps, {
+            ...options,
+            segmentBase,
+        });
+    }
+    return {
+        async getSegment(time, affordance = 0) {
+            if (!segmentsPromise)
+                segmentsPromise = getSegmentReferences();
+            const segments = await Promise.resolve(segmentsPromise).catch((error) => {
+                // When the segments list fails (for example the sidx range request fails),
+                // retry on the next request.
+                segmentsPromise = null;
+                throw error;
+            });
+            const segment = getSegmentAtTime(time, segments, affordance);
+            if (!segment)
+                return null;
+            return {
+                quality,
+                ...segment,
+                initData,
+            };
+        },
+    };
+}
+/**
+ * Creates a segment list when the representation has a SegmentList.
+ */
+function createSegmentsFromSegmentList(deps, options) {
+    const { baseUrl, periodTimeRange, representation, segmentList } = options;
+    const segmentUrls = segmentList.SegmentURL;
+    if (segmentUrls) {
+        // Fabricate a segment timeline from the segment duration.
+        const timescale = getTimescale(segmentList);
+        const sampleTimes = calculateSegmentSampleTimes({
+            multipleSegmentBase: segmentList,
+            periodTimeRange,
+            numSegments: segmentUrls.length,
+        });
+        const presentationTimeOffset = segmentList.presentationTimeOffset ?? 0;
+        return createTimeline({
+            sampleTimes,
+            presentationTimeOffset,
+            periodTimeRange,
+            timescale,
+        }, (i) => {
+            const segmentUrl = segmentUrls[i];
+            const { url, serviceLocation } = resolveDashUri(deps, {
+                baseUrl,
+                uri: segmentUrl.media,
+                representation,
+            });
+            return createSegmentDataProvider(deps, {
+                url,
+                mediaRange: segmentUrl.mediaRange,
+                serviceId: serviceLocation,
+                reportDownlinkMetrics: true,
+            });
+        });
+    }
+    else {
+        if (segmentList.href) {
+            throw new ValidationError('SegmentList.href currently unsupported', ErrorOrigin.MEDIA);
+        }
+        else {
+            throw new ValidationError('could not determine segments from SegmentList', ErrorOrigin.MEDIA);
+        }
+    }
+}
+/**
+ * SegmentTemplate contains URIs with template tokens, as defined in 5.3.9.4.4.
+ *
+ * @see segmentTemplateUrl
+ */
+function createSegmentsFromSegmentTemplate(deps, options) {
+    const { baseUrl, periodTimeRange, representation, segmentTemplate } = options;
+    if (!segmentTemplate.media) {
+        throw new ValidationError('SegmentTemplate.media required', ErrorOrigin.MEDIA);
+    }
+    const media = segmentTemplate.media;
+    const presentationTimeOffset = segmentTemplate.presentationTimeOffset ?? 0;
+    const sampleTimes = calculateSegmentSampleTimes({
+        multipleSegmentBase: segmentTemplate,
+        periodTimeRange,
+    });
+    const timescale = getTimescale(segmentTemplate);
+    let segmentNumber = segmentTemplate.startNumber ?? 1;
+    return createTimeline({
+        timescale,
+        presentationTimeOffset,
+        periodTimeRange,
+        sampleTimes,
+    }, (_, sampleTime) => {
+        const uri = segmentTemplateUrl(media, {
+            representation,
+            sampleTime,
+            segmentNumber: segmentNumber++,
+        });
+        const { url, serviceLocation } = resolveDashUri(deps, {
+            baseUrl,
+            uri,
+            representation,
+        });
+        return createSegmentDataProvider(deps, {
+            url,
+            serviceId: serviceLocation,
+            reportDownlinkMetrics: true,
+        });
+    });
+}
+/**
+ * When SegmentBase is provided, get the timeline from the index range.
+ */
+async function createSegmentsFromSegmentBase(deps, options) {
+    const { baseUrl, periodTimeRange, representation, segmentBase } = options;
+    if (segmentBase.indexRange) {
+        // Load the sidx box from the mp4.
+        const indexRange = segmentBase.indexRange;
+        const { url: indexUrl, serviceLocation: indexServiceLocation } = resolveDashUri(deps, { baseUrl, representation });
+        const sidx = parseSidxBox(await createSegmentDataProvider(deps, {
+            url: indexUrl,
+            mediaRange: indexRange,
+            serviceId: indexServiceLocation,
+            reportDownlinkMetrics: false,
+        })());
+        const sampleTimes = getSidxSampleTimes(sidx);
+        let rangeStart = Number(sidx.firstOffset) + indexRange[1] + 1;
+        return createTimeline({
+            sampleTimes,
+            periodTimeRange,
+            presentationTimeOffset: segmentBase.presentationTimeOffset ?? 0,
+            timescale: sidx.timescale,
+        }, (i) => {
+            const segmentReference = sidx.references[i];
+            const size = segmentReference.referencedSize;
+            const provider = createSegmentDataProvider(deps, {
+                url: indexUrl,
+                mediaRange: [rangeStart, rangeStart + size - 1],
+                serviceId: indexServiceLocation,
+                reportDownlinkMetrics: true,
+            });
+            rangeStart += size;
+            return provider;
+        });
+    }
+    else {
+        throw new ValidationError('Manifest missing segments');
+    }
+}
+/**
+ * Returns an array of start times, in timescale units for the segments in the given multiple segment base.
+ * The last time in the list will be the end time, in timescale units.
+ */
+function calculateSegmentSampleTimes(options) {
+    const { multipleSegmentBase, periodTimeRange } = options;
+    const timescale = getTimescale(multipleSegmentBase);
+    let startTimes;
+    if (multipleSegmentBase.SegmentTimeline) {
+        startTimes = calculateSampleTimesFromSegmentTimeline(multipleSegmentBase.SegmentTimeline);
+    }
+    else {
+        // Fabricate a segment timeline from the segment duration.
+        const sampleDuration = getSampleDuration(multipleSegmentBase); // The unscaled duration
+        startTimes = calculateFixedSegmentSampleTimes({
+            timescale,
+            periodTimeRange,
+            sampleDuration,
+            numSegments: options.numSegments,
+        });
+    }
+    return startTimes;
+}
+/**
+ * Given a SegmentTimeline element, calculates the sample start times of each segment, in timescale units.
+ * The last time in the list will be the end time, in timescale units.
+ */
+function calculateSampleTimesFromSegmentTimeline(segmentTimeline) {
+    const out = new Array((segmentTimeline.S?.length ?? 0) + 1);
+    let startTime = 0;
+    let c = 0;
+    segmentTimeline.S?.forEach((s) => {
+        // If the start time 't' is defined, use it, otherwise use the calculated current time
+        startTime = s.t != null ? s.t : startTime;
+        // Calculate segment details for the number of repeats
+        for (let i = 0; i <= s.r; i++) {
+            out[c++] = startTime;
+            startTime += s.d;
+        }
+    });
+    out[c++] = startTime;
+    return out;
+}
+/**
+ * Creates media segment sample start times, in timescale units, with a given duration.
+ * The last time in the list will be the duration, in timescale units.
+ *
+ * @param options
+ */
+function calculateFixedSegmentSampleTimes(options) {
+    const { sampleDuration, timescale } = options;
+    const [periodStart, periodEnd] = options.periodTimeRange;
+    if (periodEnd == null)
+        throw new ValidationError('MPD.mediaPresentationDuration or Period.duration required', ErrorOrigin.MEDIA);
+    const numSegments = options.numSegments ??
+        Math.ceil((periodEnd - periodStart) / (sampleDuration / timescale));
+    const out = new Array(numSegments + 1);
+    let startTime = 0;
+    for (let i = 0; i < numSegments; i++) {
+        out[i] = startTime;
+        startTime += sampleDuration;
+    }
+    out[numSegments] = periodEnd * timescale;
+    return out;
+}
+/**
+ * Creates a timeline of DataSegmentRef objects from a sample timeline list and a data provider factory.
+ *
+ * @param sampleTimes The list of sample times, in timescale units, to convert into MPD presentation times.
+ * @param periodTimeRange The time range of the period, in seconds.
+ * @param presentationTimeOffset The presentation time offset, in samples per second.
+ * @param timescale The timescale units, in samples per second.
+ * @param dataProviderFactory Creates the data provider for the segment at the given index and sample start time.
+ */
+function createTimeline({ sampleTimes, periodTimeRange, presentationTimeOffset, timescale, }, dataProviderFactory) {
+    const [periodStart, periodEnd] = periodTimeRange;
+    const mpdTimes = sampleTimes.map((sampleTime) => {
+        return sampleToMpdTime(sampleTime, periodStart, presentationTimeOffset, timescale);
+    });
+    const n = mpdTimes.length - 1;
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const startTime = mpdTimes[i];
+        const endTime = mpdTimes[i + 1];
+        out[i] = {
+            data: dataProviderFactory(i, sampleTimes[i]),
+            timestampOffset: startTime,
+            startTime: Math.max(periodStart, startTime),
+            endTime: periodEnd == null ? endTime : Math.min(periodEnd, endTime),
+        };
+    }
+    return out;
+}
+/**
+ * Validates that timescale is set, returning it.
+ *
+ * @param multipleSegmentBase
+ */
+function getTimescale(multipleSegmentBase) {
+    if (!multipleSegmentBase.timescale)
+        throw new ValidationError('invalid timescale', ErrorOrigin.MEDIA);
+    return multipleSegmentBase.timescale;
+}
+/**
+ * Validates that duration is set, returning it.
+ *
+ * @param multipleSegmentBase
+ */
+function getSampleDuration(multipleSegmentBase) {
+    if (!multipleSegmentBase.duration)
+        throw new ValidationError('invalid duration', ErrorOrigin.MEDIA);
+    return multipleSegmentBase.duration;
+}

package/dist/types/current/track/dash/urlDashManifestProvider.d.ts

@@ -0,0 +1,17 @@
+import type { Maybe } from '@amazon/vinyl-util';
+import type { RequestInitOptions } from '@amazon/vinyl-util';
+import type { RequestInterceptor } from '@amazon/vinyl-util';
+import type { DashManifestProvider } from '../../track/dash/DashManifestProvider';
+/**
+ * Creates a DashManifestProvider which performs a request to retrieve a dash manifest.
+ * Can be a relative path.
+ *
+ * Usage example:
+ *
+ * ```createRequesterDashManifestProvider('https://example.com/manifest.mpd')```
+ * @param input The resource location of the dash manifest.
+ * @param init Optional request options such as headers.
+ * @param requestInterceptor An optional transformer to mutate request parameters before the request is made.
+ */
+export declare function urlDashManifestProvider(input: string, init?: Maybe<RequestInitOptions>, requestInterceptor?: RequestInterceptor): DashManifestProvider;
+//# sourceMappingURL=urlDashManifestProvider.d.ts.map

package/dist/types/current/track/dash/urlDashManifestProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlDashManifestProvider.d.ts","sourceRoot":"","sources":["../../../../../src/track/dash/urlDashManifestProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,KAAK,EAER,kBAAkB,EACrB,MAAM,oBAAoB,CAAA;AAK3B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AAE7E;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACnC,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,EAChC,kBAAkB,GAAE,kBAAyB,GAC9C,oBAAoB,CAkBtB"}

package/dist/types/current/track/dash/urlDashManifestProvider.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { noop } from '@amazon/vinyl-util';
+import { clone, getLocation, resolveUrl } from '@amazon/vinyl-util';
+import { requestWithRetry } from '@amazon/vinyl-util';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
+/**
+ * Creates a DashManifestProvider which performs a request to retrieve a dash manifest.
+ * Can be a relative path.
+ *
+ * Usage example:
+ *
+ * ```createRequesterDashManifestProvider('https://example.com/manifest.mpd')```
+ * @param input The resource location of the dash manifest.
+ * @param init Optional request options such as headers.
+ * @param requestInterceptor An optional transformer to mutate request parameters before the request is made.
+ */
+export function urlDashManifestProvider(input, init, requestInterceptor = noop) {
+    return async (abort) => {
+        const params = {
+            input: resolveUrl(input, getLocation().href),
+            init: clone(init) ?? {},
+        };
+        requestInterceptor(params);
+        const response = await requestWithRetry(params.input, params.init, {
+            abort,
+        });
+        const xml = await response.text();
+        const manifest = parseDashManifest(xml);
+        const baseInput = response.url || params.input;
+        return {
+            manifest,
+            baseUrl: resolveUrl('./', baseInput),
+        };
+    };
+}

package/dist/types/current/track/dash/util/mimeType.d.ts

@@ -0,0 +1,12 @@
+import type { RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { ContentType } from '../../../streaming/MediaQualityMetadata';
+export interface RepresentationMimeInfo {
+    readonly mimeType: string | null;
+    readonly contentType: ContentType | null;
+}
+/**
+ * Returns the full mime type with codecs and the inferred content type from the
+ * provided representation.
+ */
+export declare function getRepresentationMimeInfo(representation: RepresentationType): RepresentationMimeInfo;
+//# sourceMappingURL=mimeType.d.ts.map

package/dist/types/current/track/dash/util/mimeType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mimeType.d.ts","sourceRoot":"","sources":["../../../../../../src/track/dash/util/mimeType.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAGnE,MAAM,WAAW,sBAAsB;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;CAC3C;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACrC,cAAc,EAAE,kBAAkB,GACnC,sBAAsB,CAqCxB"}

package/dist/types/current/track/dash/util/mimeType.js

@@ -0,0 +1,45 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { codecToContentType } from '../../../track/mse/codec';
+/**
+ * Returns the full mime type with codecs and the inferred content type from the
+ * provided representation.
+ */
+export function getRepresentationMimeInfo(representation) {
+    const adaptationSet = representation.parent;
+    let mimeType = representation.mimeType ?? adaptationSet.mimeType;
+    const codecs = representation.codecs ?? adaptationSet.codecs;
+    if (!mimeType) {
+        const contentType = adaptationSet.contentType ??
+            (codecs ? codecToContentType(codecs.split(',')[0]) : null);
+        switch (contentType) {
+            case 'audio':
+                mimeType = 'audio/mp4';
+                break;
+            case 'video':
+                mimeType = 'video/mp4';
+                break;
+            default:
+                return { mimeType: null, contentType: null };
+        }
+        const fullMimeType = codecs
+            ? `${mimeType}; codecs="${codecs}"`
+            : mimeType;
+        return { mimeType: fullMimeType, contentType };
+    }
+    const fullMimeType = codecs ? `${mimeType}; codecs="${codecs}"` : mimeType;
+    let contentType = adaptationSet.contentType ?? null;
+    if (!contentType) {
+        if (mimeType.startsWith('audio/'))
+            contentType = 'audio';
+        else if (mimeType.startsWith('video/'))
+            contentType = 'video';
+        else if (mimeType.startsWith('text/') ||
+            mimeType === 'application/json' ||
+            mimeType === 'application/xml')
+            contentType = 'text';
+    }
+    return { mimeType: fullMimeType, contentType };
+}

package/dist/types/current/track/dash/util/mpd.d.ts

@@ -0,0 +1,72 @@
+import { type AdaptationSetType, type DashManifest, type MPDtype, type PeriodType, type RepresentationType, type SegmentBaseType, type SegmentListType, type SegmentTemplateType } from '@amazon/vinyl-mpd-parser';
+/**
+ * Calculates the inherited SegmentList for the given representation. Or returns undefined if no SegmentList is
+ * present in the hierarchy.
+ */
+export declare function getSegmentList(representation: RepresentationType): SegmentListType | undefined;
+/**
+ * Calculates the inherited SegmentTemplate for the given representation. Or returns undefined if no SegmentTemplate is
+ * present in the hierarchy.
+ */
+export declare function getSegmentTemplate(representation: RepresentationType): SegmentTemplateType | undefined;
+/**
+ * Calculates the inherited SegmentBase for the given representation. Or returns undefined if no SegmentBase is
+ * present in the hierarchy.
+ */
+export declare function getSegmentBase(representation: RepresentationType): SegmentBaseType | undefined;
+/**
+ * Returns the representation's ancestry: [MPD, Period, AdaptationSet, Representation]
+ */
+export declare function getRepresentationAncestry(representation: RepresentationType): readonly [MPDtype, PeriodType, AdaptationSetType, RepresentationType];
+export type PeriodRange = readonly [number, number | null];
+/**
+ * Calculates the period start and end time.
+ */
+export declare function calculatePeriodTimeRange(period: PeriodType): PeriodRange;
+/**
+ * Calculates the start time of the given period.
+ *
+ * In a static presentation, the first period SHALL start at the zero point of the MPD timeline (with a
+ * Period@start value of 0 seconds).
+ */
+export declare function calculatePeriodStart(period: PeriodType): number;
+/**
+ * In a static presentation, the last period SHALL have a Period@duration.
+ *
+ * In a dynamic presentation, the first period SHALL start at or after the zero point of the MPD timeline (with a
+ *  Period@start value of 0 seconds or greater).
+ *
+ * In a dynamic presentation, the last period MAY have a Period@duration, in which case it has a fixed duration. If
+ * without Period@duration, the last period in a dynamic presentation has an unlimited duration (that may later be
+ * shortened by an MPD update).
+ */
+export declare function calculatePeriodEnd(period: PeriodType): number | null;
+/**
+ * Converts a sample time to an MPD-relative time.
+ *
+ * The samples within a representation exist on a linear sample timeline defined by the encoder. This function maps
+ * those sample times onto the MPD timeline.
+ *
+ * https://dashif-documents.azurewebsites.net/Guidelines-TimingModel/master/Guidelines-TimingModel.html
+ *
+ * @param sampleTime The sample start time, in timescale units, relative to the media.
+ * @param periodStart The presentation start time of the period, relative to the MPD timeline.
+ * @param presentationTimeOffset Specifies a presentation time offset in the media timeline relative to the start
+ * of the Period, in timescale units, used to adjust the timing of media presentation.
+ * @param timescale The timescale, in units per second.
+ */
+export declare function sampleToMpdTime(sampleTime: number, periodStart: number, presentationTimeOffset: number, timescale: number): number;
+/**
+ * Gets the period spanning the given presentation time.
+ */
+export declare function getPeriodAtTime(manifest: DashManifest, time: number): PeriodType | null;
+/**
+ * Flattens representations across all adaptation sets for the given Period.
+ */
+export declare function flattenRepresentations(period: PeriodType): RepresentationType[];
+/**
+ * Calculates the manifest duration, either from the mediaPresentationDuration or the last period end time.
+ * @param manifest
+ */
+export declare function calculateDuration(manifest: DashManifest): number | null;
+//# sourceMappingURL=mpd.d.ts.map

package/dist/types/current/track/dash/util/mpd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpd.d.ts","sourceRoot":"","sources":["../../../../../../src/track/dash/util/mpd.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAC3B,MAAM,0BAA0B,CAAA;AAIjC;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,cAAc,EAAE,kBAAkB,GACnC,eAAe,GAAG,SAAS,CAM7B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAC9B,cAAc,EAAE,kBAAkB,GACnC,mBAAmB,GAAG,SAAS,CAMjC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,cAAc,EAAE,kBAAkB,GACnC,eAAe,GAAG,SAAS,CAM7B;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACrC,cAAc,EAAE,kBAAkB,GACnC,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,kBAAkB,CAAC,CAKvE;AAYD,MAAM,MAAM,WAAW,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;AAE1D;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CASpE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,sBAAsB,EAAE,MAAM,EAC9B,SAAS,EAAE,MAAM,GAClB,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,GACb,UAAU,GAAG,IAAI,CASnB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAClC,MAAM,EAAE,UAAU,GACnB,kBAAkB,EAAE,CAQtB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,CAKvE"}

package/dist/types/current/track/dash/util/mpd.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { last, merge, sortedInsertionIndex } from '@amazon/vinyl-util';
+// TODO: For dynamic MPDs, availability time offsets should be summed.
+/**
+ * Calculates the inherited SegmentList for the given representation. Or returns undefined if no SegmentList is
+ * present in the hierarchy.
+ */
+export function getSegmentList(representation) {
+    return mergeIfAnyDefined(representation.parent.parent.SegmentList, representation.parent.SegmentList, representation.SegmentList);
+}
+/**
+ * Calculates the inherited SegmentTemplate for the given representation. Or returns undefined if no SegmentTemplate is
+ * present in the hierarchy.
+ */
+export function getSegmentTemplate(representation) {
+    return mergeIfAnyDefined(representation.parent.parent.SegmentTemplate, representation.parent.SegmentTemplate, representation.SegmentTemplate);
+}
+/**
+ * Calculates the inherited SegmentBase for the given representation. Or returns undefined if no SegmentBase is
+ * present in the hierarchy.
+ */
+export function getSegmentBase(representation) {
+    return mergeIfAnyDefined(representation.parent.parent.SegmentBase, representation.parent.SegmentBase, representation.SegmentBase);
+}
+/**
+ * Returns the representation's ancestry: [MPD, Period, AdaptationSet, Representation]
+ */
+export function getRepresentationAncestry(representation) {
+    const adaptationSet = representation.parent;
+    const period = adaptationSet.parent;
+    const mpd = period.parent;
+    return [mpd, period, adaptationSet, representation];
+}
+/**
+ * Merges the properties of all sources into a new object.
+ * Used to calculate inherited properties.
+ * If all sources are undefined, returns undefined.
+ */
+function mergeIfAnyDefined(...sources) {
+    if (!sources.some((source) => source))
+        return undefined;
+    return merge(...sources);
+}
+/**
+ * Calculates the period start and end time.
+ */
+export function calculatePeriodTimeRange(period) {
+    return [calculatePeriodStart(period), calculatePeriodEnd(period)];
+}
+/**
+ * Calculates the start time of the given period.
+ *
+ * In a static presentation, the first period SHALL start at the zero point of the MPD timeline (with a
+ * Period@start value of 0 seconds).
+ */
+export function calculatePeriodStart(period) {
+    return period.start ?? 0;
+}
+/**
+ * In a static presentation, the last period SHALL have a Period@duration.
+ *
+ * In a dynamic presentation, the first period SHALL start at or after the zero point of the MPD timeline (with a
+ *  Period@start value of 0 seconds or greater).
+ *
+ * In a dynamic presentation, the last period MAY have a Period@duration, in which case it has a fixed duration. If
+ * without Period@duration, the last period in a dynamic presentation has an unlimited duration (that may later be
+ * shortened by an MPD update).
+ */
+export function calculatePeriodEnd(period) {
+    if (period.start != null && period.duration != null)
+        return period.start + period.duration;
+    const mpd = period.parent;
+    const periodIndex = mpd.Period.indexOf(period);
+    if (periodIndex < mpd.Period.length - 1)
+        return calculatePeriodStart(mpd.Period[periodIndex + 1]);
+    else
+        return mpd.mediaPresentationDuration ?? null;
+}
+/**
+ * Converts a sample time to an MPD-relative time.
+ *
+ * The samples within a representation exist on a linear sample timeline defined by the encoder. This function maps
+ * those sample times onto the MPD timeline.
+ *
+ * https://dashif-documents.azurewebsites.net/Guidelines-TimingModel/master/Guidelines-TimingModel.html
+ *
+ * @param sampleTime The sample start time, in timescale units, relative to the media.
+ * @param periodStart The presentation start time of the period, relative to the MPD timeline.
+ * @param presentationTimeOffset Specifies a presentation time offset in the media timeline relative to the start
+ * of the Period, in timescale units, used to adjust the timing of media presentation.
+ * @param timescale The timescale, in units per second.
+ */
+export function sampleToMpdTime(sampleTime, periodStart, presentationTimeOffset, timescale) {
+    return periodStart + (sampleTime - presentationTimeOffset) / timescale;
+}
+/**
+ * Gets the period spanning the given presentation time.
+ */
+export function getPeriodAtTime(manifest, time) {
+    const index = sortedInsertionIndex(manifest.MPD.Period, time, (time, period) => {
+        return time - calculatePeriodStart(period);
+    }) - 1;
+    if (index < 0)
+        return null;
+    const period = manifest.MPD.Period[index];
+    const periodEnd = calculatePeriodEnd(period);
+    return periodEnd != null && time >= periodEnd ? null : period;
+}
+/**
+ * Flattens representations across all adaptation sets for the given Period.
+ */
+export function flattenRepresentations(period) {
+    const out = [];
+    period.AdaptationSet?.forEach((adaptationSet) => {
+        adaptationSet.Representation?.forEach((representation) => {
+            out.push(representation);
+        });
+    });
+    return out;
+}
+/**
+ * Calculates the manifest duration, either from the mediaPresentationDuration or the last period end time.
+ * @param manifest
+ */
+export function calculateDuration(manifest) {
+    const mpdDuration = manifest.MPD.mediaPresentationDuration;
+    if (mpdDuration != null)
+        return mpdDuration;
+    // If mediaPresentationDuration is not present, take the end time of the last period.
+    return calculatePeriodEnd(last(manifest.MPD.Period));
+}