diff --git a/README.md b/README.md
index 05279cac..41282649 100644
--- a/README.md
+++ b/README.md
@@ -41,12 +41,19 @@ const manifestUri = 'https://example.com/dash.xml';
const res = await fetch(manifestUri);
const manifest = await res.text();
-var parsedManifest = mpdParser.parse(manifest, { manifestUri });
+const { manifest: parsedManifest } = mpdParser.parse(manifest, { manifestUri });
+```
+
+If dealing with a live stream, then on subsequent calls to parse, the last parsed manifest
+object should be provided as an option to `parse` using the `lastMpd` option:
+
+```js
+const parsedManifest = mpdParser.parse(manifest, { manifestUri, lastMpd });
```
### Parsed Output
-The parser ouputs a plain javascript object with the following structure:
+The parser ouputs a parsed manifest as a plain javascript object with the following structure:
```js
Manifest {
@@ -61,6 +68,8 @@ Manifest {
Manifest
}
],
+ playlistToExclude: [],
+ mediaGroupPlaylistsToExclude: []
mediaGroups: {
AUDIO: {
'GROUP-ID': {
@@ -113,6 +122,12 @@ Manifest {
}
```
+For live DASH playlists where a `lastMpd` object was provided, the returned manifest object
+may contain `playlistsToExclude` and `mediaGroupPlaylistsToExclude`. These are arrays
+containing playlists that were found in the `lastMpd` (if provided) but could not be
+matched in the latest MPD. To continue playback uninterrupted, they should be excluded by
+the playback engine.
+
## Including the Parser
To include mpd-parser on your website or web application, use any of the following methods.
@@ -124,8 +139,8 @@ This is the simplest case. Get the script in whatever way you prefer and include
```html
```
@@ -134,16 +149,15 @@ This is the simplest case. Get the script in whatever way you prefer and include
When using with Browserify, install mpd-parser via npm and `require` the parser as you would any other module.
```js
-var mpdParser = require('mpd-parser');
-
-var parsedManifest = mpdParser.parse(manifest, manifestUrl);
+const mpdParser = require('mpd-parser');
+const parsedManifest = mpdParser.parse(manifest, { manifestUri });
```
With ES6:
```js
import { parse } from 'mpd-parser';
-const parsedManifest = parse(manifest, manifestUrl);
+const parsedManifest = parse(manifest, { manifestUri });
```
### RequireJS/AMD
@@ -152,7 +166,7 @@ When using with RequireJS (or another AMD library), get the script in whatever w
```js
require(['mpd-parser'], function(mpdParser) {
- var parsedManifest = mpdParser.parse(manifest, manifestUrl);
+ const parsedManifest = mpdParser.parse(manifest, { manifestUri });
});
```
diff --git a/src/index.js b/src/index.js
index 31924d86..b4cdff8c 100644
--- a/src/index.js
+++ b/src/index.js
@@ -4,15 +4,33 @@ import { toPlaylists } from './toPlaylists';
import { inheritAttributes } from './inheritAttributes';
import { stringToMpdXml } from './stringToMpdXml';
import { parseUTCTimingScheme } from './parseUTCTimingScheme';
-import {addSidxSegmentsToPlaylist} from './segment/segmentBase.js';
+import { addSidxSegmentsToPlaylist } from './segment/segmentBase.js';
const VERSION = version;
+/*
+ * Given a DASH manifest string and options, parses the DASH manifest into a manifest
+ * object.
+ *
+ * For live DASH manifests, if `lastMpd` is provided in options, then the newly parsed
+ * DASH manifest will have its media and discontinuity sequence values updated to reflect
+ * its position relative to the prior manifest.
+ *
+ * @param {string} manifestString - the DASH manifest as a string
+ * @param {options} [options] - any options
+ *
+ * @return {Object} the manifest object
+ */
const parse = (manifestString, options = {}) => {
const parsedManifestInfo = inheritAttributes(stringToMpdXml(manifestString), options);
const playlists = toPlaylists(parsedManifestInfo.representationInfo);
- return toM3u8(playlists, parsedManifestInfo.locations, options.sidxMapping);
+ return toM3u8({
+ dashPlaylists: playlists,
+ locations: parsedManifestInfo.locations,
+ sidxMapping: options.sidxMapping,
+ lastMpd: options.lastMpd
+ });
};
/**
diff --git a/src/inheritAttributes.js b/src/inheritAttributes.js
index 067fb8dc..ad645f18 100644
--- a/src/inheritAttributes.js
+++ b/src/inheritAttributes.js
@@ -1,4 +1,3 @@
-import window from 'global/window';
import { flatten } from './utils/list';
import { merge } from './utils/object';
import { findChildren, getContent } from './utils/xml';
@@ -386,9 +385,20 @@ export const toRepresentations =
*/
export const toAdaptationSets = (mpdAttributes, mpdBaseUrls) => (period, index) => {
const periodBaseUrls = buildBaseUrls(mpdBaseUrls, findChildren(period.node, 'BaseURL'));
- const parsedPeriodId = parseInt(period.attributes.id, 10);
- // fallback to mapping index if Period@id is not a number
- const periodIndex = window.isNaN(parsedPeriodId) ? index : parsedPeriodId;
+ // periodIndex used to always use Period@id, and was used as the period's timeline (the
+ // discontinuity sequence for the manifest). This helped address dynamic playlists, as
+ // Period@id was often a number, and it often increased. However, the DASH specification
+ // states that Period@id is a string, and says nothing about increasing values. This led
+ // to problems with dynamic playlists where the Period@id would not be a number and
+ // would not increase for each added period. In addition, when it was a number, it
+ // potentially increased dramatically, making the manifest object harder to understand.
+ //
+ // Now, the index of the period is used, and for overlapping values on refreshes, the
+ // playlist merging logic should handle any increase. This should handle all the
+ // necessary cases we used to support, but may be problematic when it comes time to
+ // handle multiperiod live playlists with SIDX segments (using SegmentBase), as the
+ // merging logic can't yet handle that case. This should be a TODO for the future.
+ const periodIndex = index;
const periodAttributes = merge(mpdAttributes, {
periodIndex,
periodStart: period.attributes.start
diff --git a/src/playlist-merge.js b/src/playlist-merge.js
new file mode 100644
index 00000000..33c3650a
--- /dev/null
+++ b/src/playlist-merge.js
@@ -0,0 +1,586 @@
+import { forEachMediaGroup } from '@videojs/vhs-utils/es/media-groups';
+import {
+ findIndex,
+ findIndexes,
+ includes
+} from './utils/list';
+
+const SUPPORTED_MEDIA_TYPES = ['AUDIO', 'SUBTITLES'];
+
+/**
+ * Finds the playlist with the matching NAME attribute.
+ *
+ * @param {Array} playlists playlists to search through
+ * @param {string} name the NAME attribute to search for
+ *
+ * @return {Object|null} the matching playlist object, or null
+ */
+export const findPlaylistWithName = (playlists, name) => {
+ for (let i = 0; i < playlists.length; i++) {
+ if (playlists[i].attributes.NAME === name) {
+ return playlists[i];
+ }
+ }
+
+ return null;
+};
+
+/**
+ * Finds the media group playlist with the matching NAME attribute.
+ *
+ * @param {Object} config options object
+ * @param {string} config.playlistName the playlist NAME attribute to search for
+ * @param {string} config.type the media group type
+ * @param {string} config.group the media group...group
+ * @param {string} config.label the media group label
+ * @param {Object} config.manifest the main manifest object
+ *
+ * @return {Object|null} the matching media group playlist object, or null
+ */
+export const findMediaGroupPlaylistWithName = ({
+ playlistName,
+ type,
+ group,
+ label,
+ manifest
+}) => {
+ const typeObject = manifest.mediaGroups[type];
+ const properties = typeObject && typeObject[group] && typeObject[group][label];
+
+ if (!properties) {
+ return null;
+ }
+
+ return properties.playlists.length &&
+ findPlaylistWithName(properties.playlists, playlistName);
+};
+
+/**
+ * Returns any old playlists that are no longer available in the new playlists.
+ *
+ * @param {Object} config options object
+ * @param {Array} config.oldPlaylists the old playlists to search within
+ * @param {Array} config.newPlaylists the new playlists to check for
+ *
+ * @return {Array} any playlists not available in new playlists array
+ */
+export const getRemovedPlaylists = ({ oldPlaylists, newPlaylists }) => {
+ // Playlists NAMEs come from DASH Representation IDs, which are mandatory
+ // (see ISO_23009-1-2012 5.3.5.2)
+ const oldNameToPlaylistMap = oldPlaylists.reduce((acc, playlist) => {
+ acc[playlist.attributes.NAME] = playlist;
+ return acc;
+ }, {});
+ const newNameToPlaylistMap = newPlaylists.reduce((acc, playlist) => {
+ acc[playlist.attributes.NAME] = playlist;
+ return acc;
+ }, {});
+
+ return Object.keys(oldNameToPlaylistMap).reduce((acc, oldPlaylistName) => {
+ const oldPlaylist = oldNameToPlaylistMap[oldPlaylistName];
+ const matchingNewPlaylist = newNameToPlaylistMap[oldPlaylistName];
+
+ if (!matchingNewPlaylist) {
+ acc.push(oldPlaylist);
+ }
+
+ return acc;
+ }, []);
+};
+
+/**
+ * Returns any old media group playlists that are no longer available in the new media
+ * group playlists.
+ *
+ * @param {Object} config options object
+ * @param {Object} config.oldManifest the old main manifest object
+ * @param {Object} config.newManifest the new main manifest object
+ *
+ * @return {Array} removed media group playlist objects
+ */
+export const getRemovedMediaGroupPlaylists = ({ oldManifest, newManifest }) => {
+ const removedMediaGroupPlaylists = [];
+
+ forEachMediaGroup(oldManifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
+ const oldPlaylists = properties.playlists || [];
+
+ oldPlaylists.forEach((oldPlaylist) => {
+ const newPlaylist = findMediaGroupPlaylistWithName({
+ // Playlists NAMEs come from DASH Representation IDs, which are mandatory
+ // (see ISO_23009-1-2012 5.3.5.2)
+ playlistName: oldPlaylist.attributes.NAME,
+ type,
+ group,
+ label,
+ manifest: newManifest
+ });
+
+ if (!newPlaylist) {
+ removedMediaGroupPlaylists.push({
+ type,
+ group,
+ label,
+ playlist: oldPlaylist
+ });
+ }
+ });
+ });
+
+ return removedMediaGroupPlaylists;
+};
+
+/**
+ * Returns any new playlists that do not account for all timelines (where all timelines is
+ * the max number of timelines seen across all of the passed in playlists).
+ *
+ * @param {Array} playlists the playlists to look through
+ *
+ * @return {Array} any playlists that do not account for all timelines
+ */
+export const getIncompletePlaylists = (playlists) => {
+ const timelines = {};
+ const playlistToTimelines = {};
+
+ playlists.forEach((playlist) => {
+ if (!playlist.segments) {
+ return;
+ }
+
+ const playlistTimelines = playlist.segments.reduce((acc, segment) => {
+ acc[segment.timeline] = true;
+ timelines[segment.timeline] = true;
+
+ return acc;
+ }, {});
+
+ // All playlists should have a unique ID sourced from the required attribute
+ // Representation@id from the MPD.
+ playlistToTimelines[playlist.attributes.NAME] = playlistTimelines;
+ }, {});
+
+ const numNewTimelines = Object.keys(timelines).length;
+
+ if (numNewTimelines === 0) {
+ return [];
+ }
+
+ return playlists.filter((playlist) =>
+ Object.keys(playlistToTimelines[playlist.attributes.NAME]).length < numNewTimelines);
+};
+
+/**
+ * Gets a flattened array of media group playlists.
+ *
+ * @param {Object} manifest the main manifest object
+ *
+ * @return {Array} the media group playlists
+ */
+export const getMediaGroupPlaylists = (manifest) => {
+ let mediaGroupPlaylists = [];
+
+ forEachMediaGroup(manifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
+ mediaGroupPlaylists = mediaGroupPlaylists.concat(properties.playlists || []);
+ });
+
+ return mediaGroupPlaylists;
+};
+
+/**
+ * @typedef {Object} MediaGroupPlaylistIdentificationObject
+ * @property {string} type - the media group type
+ * @property {string} group - the media group...group
+ * @property {string} label - the media group label
+ * @property {Object} playlist - the playlist within the group
+ */
+
+/**
+ * Given a list of playlists and a manifest object, returns an array of objects with all
+ * of the necessary media group properties to identify it within a manifest.
+ *
+ * @param {Object} config options object
+ * @param {Array} config.playlists the playlist objects
+ * @param {Object} config.manifest the main manifest object
+ *
+ * @return {MediaGroupPlaylistIdentificationObject[]}
+ * media group playlist identification objects
+ */
+export const getMediaGroupPlaylistIdentificationObjects = ({ playlists, manifest }) => {
+ if (!playlists.length) {
+ return [];
+ }
+
+ const idObjects = [];
+
+ forEachMediaGroup(manifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
+ properties.playlists.forEach((playlist) => {
+ if (includes(playlists, playlist)) {
+ idObjects.push({
+ type,
+ group,
+ label,
+ playlist
+ });
+ }
+ });
+ });
+
+ return idObjects;
+};
+
+/**
+ * Goes through the provided segments and updates the appropriate sequence and timeline
+ * related attributes.
+ *
+ * @param {Object} config options object
+ * @param {Array} config.segments the segments to update
+ * @param {number} config.mediaSequenceStart the mediaSequence number to start with
+ * @param {string} config.timelineStart the timeline number to start with
+ */
+export const repositionSegmentsOnTimeline = ({
+ segments,
+ mediaSequenceStart,
+ timelineStart
+}) => {
+ let currentMediaSequence = mediaSequenceStart;
+ let currentTimeline = timelineStart;
+
+ for (let i = 0; i < segments.length; i++) {
+ const segment = segments[i];
+
+ // timelineStart should already account for the first discontinuity
+ if (i > 0 && segment.discontinuity) {
+ currentTimeline++;
+ }
+ segment.number = currentMediaSequence;
+ segment.timeline = currentTimeline;
+ currentMediaSequence++;
+ }
+};
+
+/**
+ * Given a new playlist and an old matching playlist from a prior refresh, updates the new
+ * playlist's sequence and timing values (including segments) to ensure that the new
+ * playlist reflects its relative position to the old one.
+ *
+ * @param {Object} oldPlaylist the old playlist to base the updates on
+ * @param {Object} newPlaylist the new playlist to update
+ */
+export const positionPlaylistOnTimeline = (oldPlaylist, newPlaylist) => {
+ const oldSegments = oldPlaylist.segments || [];
+ const newSegments = newPlaylist.segments || [];
+ // At the time of writing, mpd-parser did not add discontinuitySequence. This code
+ // allows for it to exist or to not exist, and should handle both appropriately.
+ const oldDiscontinuitySequence = oldPlaylist.discontinuitySequence || 0;
+
+ // If the prior playlist had no segments, it's likely either the start of the stream or
+ // a break in the stream. Either way, the best approach is to consider the new segments
+ // a discontinuous region of the media and to continue as if the new playlist is a
+ // continuation of the prior stream.
+ if (oldSegments.length === 0) {
+ newPlaylist.mediaSequence = oldPlaylist.mediaSequence;
+ // The discontinuity sequence should remain the same. Accounting for removed
+ // discontinuities occurs on playlist updates where segments are removed.
+ newPlaylist.discontinuitySequence = oldDiscontinuitySequence;
+ // The timeline should remain the same until a new segment is added.
+ newPlaylist.timeline = oldPlaylist.timeline + (newPlaylist.segments.length ? 1 : 0);
+
+ if (newSegments.length > 0) {
+ newSegments[0].discontinuity = true;
+ }
+
+ repositionSegmentsOnTimeline({
+ segments: newSegments,
+ mediaSequenceStart: newPlaylist.mediaSequence,
+ timelineStart: newPlaylist.timeline
+ });
+
+ newPlaylist.discontinuityStarts = findIndexes(newSegments, 'discontinuity');
+ return;
+ }
+
+ // If there are no new segments then the stream is either reaching an end or a gap.
+ // The media sequence should be updated accordingly, but the timeline should remain the
+ // same, as it will be updated once segments are added.
+ if (newSegments.length === 0) {
+ newPlaylist.mediaSequence = oldPlaylist.mediaSequence + oldSegments.length;
+ newPlaylist.discontinuitySequence =
+ oldDiscontinuitySequence + findIndexes(oldSegments, 'discontinuity').length;
+ newPlaylist.timeline = oldSegments.length ?
+ oldSegments[oldSegments.length - 1].timeline : oldPlaylist.timeline;
+ newPlaylist.discontinuityStarts = [];
+ return;
+ }
+
+ // From here on both old and new playlist have segments.
+ //
+ // To update the new playlist, we must position the old and the new together. The
+ // simplest approach is to try to match an exact segment and adjust timing values from
+ // there. However, this will not always work. It's possible that different periods will
+ // reuse the same segment, and it's also possible that refreshes may change certain
+ // segment properties (e.g., the URI).
+ //
+ // Because of these limitations, the best approach for matching segments is by finding
+ // a segment with a matching presentation time. These values should not change on
+ // refreshes.
+ const firstNewSegment = newSegments[0];
+ const oldMatchingSegmentIndex = findIndex(oldSegments, (oldSegment) =>
+ // allow one 60fps frame as leniency (arbitrarily chosen)
+ Math.abs(oldSegment.presentationTime - firstNewSegment.presentationTime) < (1 / 60));
+ const lastOldSegment = oldSegments[oldSegments.length - 1];
+
+ // No matching segment from the old playlist means the entire playlist was refreshed. In
+ // this case the media sequence should account for this update, and the new segments
+ // should be marked as discontinuous from the prior content, since the last prior period
+ // was removed.
+ if (oldMatchingSegmentIndex < 0) {
+ // It's possible that segments were missed on refresh. However, since we don't have any
+ // access to these prior segments, continue as if the newest segment is the next media
+ // sequence in the stream. At the time of writing, this shouldn't have further
+ // ramifications for playback, as it will be marked as discontinuous with the prior
+ // segments and should offset based on the last buffered values rather than based on
+ // exact DASH manifest values.
+ newPlaylist.mediaSequence = oldPlaylist.mediaSequence + oldSegments.length;
+ newPlaylist.timeline = lastOldSegment.timeline + 1;
+ newPlaylist.discontinuitySequence =
+ oldDiscontinuitySequence + findIndexes(oldSegments, 'discontinuity').length;
+ firstNewSegment.discontinuity = true;
+
+ repositionSegmentsOnTimeline({
+ segments: newSegments,
+ mediaSequenceStart: newPlaylist.mediaSequence,
+ timelineStart: newPlaylist.timeline
+ });
+
+ newPlaylist.discontinuityStarts = findIndexes(newSegments, 'discontinuity');
+ return;
+ }
+
+ // There's a matching segment. Use it to update new playlist segment sequence values.
+ // Note that the matching segment in the new playlist should always be index 0.
+ let oldSegmentIndex = oldMatchingSegmentIndex;
+ let newSegmentIndex = 0;
+
+ // Check if new manifest is start of a period
+ if (oldSegments[oldSegmentIndex].discontinuity) {
+ firstNewSegment.discontinuity = true;
+ }
+
+ while (oldSegmentIndex < oldSegments.length) {
+ const oldSegment = oldSegments[oldSegmentIndex];
+ const newSegment = newSegments[newSegmentIndex];
+
+ // It's possible that segments were removed from the end of the manifest. This may or
+ // may not be legal, as per the spec, but it is seen in practice. It's possible a
+ // situation like this could happen if there are multiple servers providing the
+ // manifest and they aren't perfectly in-sync. If the case is encountered, just break
+ // from this loop.
+ if (!newSegment) {
+ break;
+ }
+
+ newSegment.number = oldSegment.number;
+ newSegment.timeline = oldSegment.timeline;
+
+ oldSegmentIndex++;
+ newSegmentIndex++;
+ }
+
+ newPlaylist.mediaSequence = firstNewSegment.number;
+ newPlaylist.discontinuitySequence = oldDiscontinuitySequence +
+ // since only some of the discontinuities were removed from the playlist, only account
+ // for those
+ findIndexes(oldSegments.slice(0, oldMatchingSegmentIndex), 'discontinuity').length;
+ newPlaylist.timeline = firstNewSegment.timeline;
+ newPlaylist.discontinuityStarts = findIndexes(newSegments, 'discontinuity');
+
+ if (newSegments.length === 1) {
+ return;
+ }
+
+ while (newSegmentIndex > 0 && newSegmentIndex < newSegments.length) {
+ const priorSegment = newSegments[newSegmentIndex - 1];
+ const segment = newSegments[newSegmentIndex];
+
+ segment.number = priorSegment.number + 1;
+ segment.timeline = priorSegment.timeline + (segment.discontinuity ? 1 : 0);
+
+ newSegmentIndex++;
+ }
+};
+
+/**
+ * Given new playlists and old playlists from a prior refresh, updates the new playlists's
+ * sequence and timing values (including segments) to ensure that the new playlists
+ * reflect their relative positions to the old ones.
+ *
+ * Note that this function assumes that the old matching playlists (based on playlist
+ * NAME) exist.
+ *
+ * @param {Array} oldPlaylists the old playlists to base the updates on
+ * @param {Array} newPlaylists the new playlists to update
+ */
+export const positionPlaylistsOnTimeline = ({ oldPlaylists, newPlaylists }) => {
+ newPlaylists.forEach((newPlaylist) => {
+ const playlistName = newPlaylist.attributes.NAME;
+ const oldPlaylist = findPlaylistWithName(oldPlaylists, playlistName);
+
+ if (!oldPlaylist) {
+ return;
+ }
+
+ positionPlaylistOnTimeline(oldPlaylist, newPlaylist);
+ });
+};
+
+/**
+ * Given a new manifest and an old manifest from a prior refresh, updates the new media
+ * group playlists' sequence and timing values (including segments) to ensure that the new
+ * media group playlists reflect their relative positions to the old ones.
+ *
+ * Note that this function assumes that the old matching media group playlists (based on
+ * playlist NAME) exist.
+ *
+ * @param {Object} oldManifest the old main manifest object
+ * @param {Object} newManifest the new main manifest object
+ */
+export const positionMediaGroupPlaylistsOnTimeline = ({ oldManifest, newManifest }) => {
+ forEachMediaGroup(newManifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
+ const newPlaylists = properties.playlists || [];
+
+ newPlaylists.forEach((newPlaylist) => {
+ const oldPlaylist = findMediaGroupPlaylistWithName({
+ // Playlists NAMEs come from DASH Representation IDs, which are mandatory
+ // (see ISO_23009-1-2012 5.3.5.2)
+ playlistName: newPlaylist.attributes.NAME,
+ type,
+ group,
+ label,
+ manifest: oldManifest
+ });
+
+ if (!oldPlaylist) {
+ return;
+ }
+
+ positionPlaylistOnTimeline(oldPlaylist, newPlaylist);
+ });
+ });
+};
+
+/**
+ * Removes matching media group playlists from the manifest. This function will also
+ * remove any labels and groups made empty after removal.
+ *
+ * @param {Object} manifest - the manifest object
+ * @param {Object[]} playlists - the media group playlists to remove
+ */
+export const removeMediaGroupPlaylists = ({ manifest, playlists }) => {
+ getMediaGroupPlaylistIdentificationObjects({ playlists, manifest }).forEach((idObject) => {
+ const mediaGroup = manifest.mediaGroups[idObject.type][idObject.group][idObject.label];
+
+ mediaGroup.playlists =
+ mediaGroup.playlists.filter((playlist) => playlist !== idObject.playlist);
+
+ if (mediaGroup.playlists.length === 0) {
+ delete manifest.mediaGroups[idObject.type][idObject.group][idObject.label];
+ }
+
+ if (Object.keys(manifest.mediaGroups[idObject.type][idObject.group]).length === 0) {
+ delete manifest.mediaGroups[idObject.type][idObject.group];
+ }
+ });
+};
+
+/**
+ * Given an old parsed manifest object and a new parsed manifest object, updates the
+ * sequence and timing values within the new manifest to ensure that it lines up with the
+ * old.
+ *
+ * @param {Array} oldManifest the old main manifest object
+ * @param {Array} newManifest the new main manifest object
+ *
+ * @return {Object} the manifest object
+ */
+export const positionManifestOnTimeline = ({ oldManifest, newManifest }) => {
+ const oldPlaylists = oldManifest.playlists;
+ const newPlaylists = newManifest.playlists;
+
+ const incompletePlaylists = getIncompletePlaylists(newPlaylists);
+ const removedPlaylists = getRemovedPlaylists({ oldPlaylists, newPlaylists });
+ // to get added, reverse the sources
+ const addedPlaylists = getRemovedPlaylists({
+ oldPlaylists: newPlaylists,
+ newPlaylists: oldPlaylists
+ });
+
+ const newMediaGroupPlaylists = getMediaGroupPlaylists(newManifest);
+ const incompleteMediaGroupPlaylists = getIncompletePlaylists(newMediaGroupPlaylists);
+ const incompleteMediaGroupPlaylistIdObjects =
+ getMediaGroupPlaylistIdentificationObjects({
+ playlists: incompleteMediaGroupPlaylists,
+ manifest: newManifest
+ });
+ const removedMediaGroupPlaylists = getRemovedMediaGroupPlaylists({
+ oldManifest,
+ newManifest
+ });
+ // to get added, reverse the sources
+ const addedMediaGroupPlaylists = getRemovedMediaGroupPlaylists({
+ oldManifest: newManifest,
+ newManifest: oldManifest
+ });
+
+ // TODO: handle (instead of remove) playlists that only exist for specific timelines
+ // (i.e., incomplete)
+ //
+ // Playlists can be removed from the manifest on period boundaries. For now, we don't
+ // have a good way of handling playlists that exist for only part of a stream. Due to
+ // that, the best course of action is to not include them. In the future, we may want
+ // to have a better way of handling playlists that only represent specific timelines in
+ // the stream.
+ //
+ // If the incomplete playlists are newly added playlists, and on a future refresh will
+ // be complete (for instance, if old periods/timelines are removed on future refreshes
+ // and the new playlist exists for periods/timelines after a certain point) then it will
+ // be available once it is no longer incomplete.
+ newManifest.playlists =
+ newManifest.playlists.filter((playlist) => !includes(incompletePlaylists, playlist));
+ removeMediaGroupPlaylists({
+ manifest: newManifest,
+ playlists: incompleteMediaGroupPlaylists
+ });
+
+ const oldMediaGroupPlaylists = getMediaGroupPlaylists(oldManifest);
+
+ // Only remove newly added playlists if a playlist existed before. This allows for
+ // streams to start empty of playlists and add a first one. However, the behavior may
+ // break if a stream ever removes all playlists and then starts up again adding new
+ // playlists.
+ if (oldMediaGroupPlaylists.length > 0 || oldPlaylists.length > 0) {
+ // TODO: handle (instead of remove) playlists that are added
+ //
+ // Right now, if a playlist is added, it is simply removed from the returned manifest
+ // object. This keeps the merging logic simple, as if there isn't an old playlist to
+ // compare with, then it is harder to position it. However, this can be resolved with
+ // matching presentation times in another playlist (or matching presentation time
+ // ranges within timelines) and sequencing from there.
+ newManifest.playlists =
+ newManifest.playlists.filter((playlist) => !includes(addedPlaylists, playlist));
+ removeMediaGroupPlaylists({
+ manifest: newManifest,
+ playlists: addedMediaGroupPlaylists.map((idObject) => idObject.playlist)
+ });
+ }
+
+ positionPlaylistsOnTimeline({
+ oldPlaylists: oldManifest.playlists,
+ newPlaylists: newManifest.playlists
+ });
+ positionMediaGroupPlaylistsOnTimeline({ oldManifest, newManifest });
+
+ newManifest.playlistsToExclude = removedPlaylists.concat(incompletePlaylists);
+ newManifest.mediaGroupPlaylistsToExclude =
+ removedMediaGroupPlaylists.concat(incompleteMediaGroupPlaylistIdObjects);
+
+ return newManifest;
+};
diff --git a/src/segment/segmentBase.js b/src/segment/segmentBase.js
index eb7397e0..f6aa3f3d 100644
--- a/src/segment/segmentBase.js
+++ b/src/segment/segmentBase.js
@@ -18,7 +18,8 @@ export const segmentsFromBase = (attributes) => {
initialization = {},
sourceDuration,
indexRange = '',
- duration
+ duration,
+ periodStart
} = attributes;
// base url is required for SegmentBase to work, per spec (Section 5.3.9.2.1)
@@ -50,7 +51,9 @@ export const segmentsFromBase = (attributes) => {
segment.timeline = 0;
}
- // This is used for mediaSequence
+ // Since there's only one segment in the period, the segment's presentation time is
+ // the same as the period start.
+ segment.presentationTime = periodStart;
segment.number = 0;
return [segment];
@@ -82,6 +85,10 @@ export const addSidxSegmentsToPlaylist = (playlist, sidx, baseUrl) => {
const mediaReferences = sidx.references.filter(r => r.referenceType !== 1);
const segments = [];
const type = playlist.endList ? 'static' : 'dynamic';
+ // Right now we don't support multiperiod sidx, so we can assume the presentation time
+ // starts at 0. In the future, when multiperiod sidx is handled, the presentation time
+ // will need to account for each period start.
+ let presentationTime = 0;
// firstOffset is the offset from the end of the sidx box
let startIndex = sidxEnd + sidx.firstOffset;
@@ -103,6 +110,10 @@ export const addSidxSegmentsToPlaylist = (playlist, sidx, baseUrl) => {
timeline,
// this is used in parseByDuration
periodIndex: timeline,
+ // Technically the presentationTime isn't the period start, but is instead the
+ // current presentation time for each segment that is added. The segmentsFromBase
+ // function expects period start, so it's renamed to match.
+ periodStart: presentationTime,
duration,
sourceDuration,
indexRange,
@@ -117,6 +128,7 @@ export const addSidxSegmentsToPlaylist = (playlist, sidx, baseUrl) => {
segments.push(segment);
startIndex += size;
+ presentationTime += duration / timescale;
}
playlist.segments = segments;
diff --git a/src/toM3u8.js b/src/toM3u8.js
index e3e1e62a..63d68614 100644
--- a/src/toM3u8.js
+++ b/src/toM3u8.js
@@ -2,6 +2,7 @@ import { values } from './utils/object';
import { findIndexes } from './utils/list';
import { addSidxSegmentsToPlaylist as addSidxSegmentsToPlaylist_ } from './segment/segmentBase';
import { byteRangeToString } from './segment/urlType';
+import { positionManifestOnTimeline } from './playlist-merge';
export const generateSidxKey = (sidx) => sidx &&
sidx.uri + '-' + byteRangeToString(sidx.byterange);
@@ -66,7 +67,13 @@ export const addSidxSegmentsToPlaylists = (playlists, sidxMapping = {}) => {
return playlists;
};
-export const formatAudioPlaylist = ({ attributes, segments, sidx }, isAudioOnly) => {
+export const formatAudioPlaylist = ({
+ attributes,
+ segments,
+ sidx,
+ mediaSequence,
+ discontinuitySequence
+}, isAudioOnly) => {
const playlist = {
attributes: {
NAME: attributes.id,
@@ -79,8 +86,9 @@ export const formatAudioPlaylist = ({ attributes, segments, sidx }, isAudioOnly)
timeline: attributes.periodIndex,
resolvedUri: '',
targetDuration: attributes.duration,
- segments,
- mediaSequence: segments.length ? segments[0].number : 1
+ discontinuitySequence,
+ mediaSequence,
+ segments
};
if (attributes.contentProtection) {
@@ -99,7 +107,12 @@ export const formatAudioPlaylist = ({ attributes, segments, sidx }, isAudioOnly)
return playlist;
};
-export const formatVttPlaylist = ({ attributes, segments }) => {
+export const formatVttPlaylist = ({
+ attributes,
+ segments,
+ mediaSequence,
+ discontinuitySequence
+}) => {
if (typeof segments === 'undefined') {
// vtt tracks may use single file in BaseURL
segments = [{
@@ -107,6 +120,18 @@ export const formatVttPlaylist = ({ attributes, segments }) => {
timeline: attributes.periodIndex,
resolvedUri: attributes.baseUrl || '',
duration: attributes.sourceDuration,
+ // From DASH IOP v4.3 section 6.4.5:
+ //
+ // Only one file for the full period is permitted, practically limiting this use
+ // case to non-live content.
+ //
+ // Such external files are assumed to have a timeline aligned with the Period,
+ // so that TTML time 00:00:00.000 corresponds to the start of the Period. The
+ // presentation time offset is expected to be not presented, and if present,
+ // expected to be ignored by the DASH client.
+ //
+ // The same applies to side-loaded WebVTT files.
+ presentationTime: attributes.periodStart,
number: 0
}];
// targetDuration should be the same duration as the only segment
@@ -129,8 +154,9 @@ export const formatVttPlaylist = ({ attributes, segments }) => {
timeline: attributes.periodIndex,
resolvedUri: attributes.baseUrl || '',
targetDuration: attributes.duration,
- segments,
- mediaSequence: segments.length ? segments[0].number : 1
+ discontinuitySequence,
+ mediaSequence,
+ segments
};
};
@@ -253,8 +279,7 @@ export const formatVideoPlaylist = ({ attributes, segments, sidx }) => {
timeline: attributes.periodIndex,
resolvedUri: '',
targetDuration: attributes.duration,
- segments,
- mediaSequence: segments.length ? segments[0].number : 1
+ segments
};
if (attributes.contentProtection) {
@@ -275,7 +300,41 @@ const audioOnly = ({ attributes }) =>
const vttOnly = ({ attributes }) =>
attributes.mimeType === 'text/vtt' || attributes.contentType === 'text';
-export const toM3u8 = (dashPlaylists, locations, sidxMapping = {}) => {
+/**
+ * Adds appropriate media and discontinuity sequence values to the segments and playlists.
+ *
+ * Throughout mpd-parser, the `number` attribute is used in relation to `startNumber`, a
+ * DASH specific attribute used in constructing segment URI's from templates. However, from
+ * an HLS perspective, the `number` attribute on a segment would be its `mediaSequence`
+ * value, which should start at the original media sequence value (or 0) and increment by 1
+ * for each segment thereafter. Since DASH's `startNumber` values are independent per
+ * period, it doesn't make sense to use it for `number`. Instead, assume everything starts
+ * from a 0 mediaSequence value and increment from there.
+ *
+ * Note that VHS currently doesn't use the `number` property, but it can be helpful for
+ * debugging and making sense of the manifest.
+ *
+ * For live playlists, to account for values increasing in manifests when periods are
+ * removed on refreshes, merging logic should be used to update the numbers to their
+ * appropriate values (to ensure they're sequential and increasing).
+ */
+export const addMediaSequenceValues = (playlists) => {
+ // increment all segments sequentially
+ playlists.forEach((playlist) => {
+ playlist.mediaSequence = 0;
+ playlist.discontinuitySequence = 0;
+
+ if (!playlist.segments) {
+ return;
+ }
+
+ for (let i = 0; i < playlist.segments.length; i++) {
+ playlist.segments[i].number = i;
+ }
+ });
+};
+
+export const toM3u8 = ({ dashPlaylists, locations, sidxMapping = {}, lastMpd }) => {
if (!dashPlaylists.length) {
return {};
}
@@ -293,6 +352,8 @@ export const toM3u8 = (dashPlaylists, locations, sidxMapping = {}) => {
const vttPlaylists = dashPlaylists.filter(vttOnly);
const captions = dashPlaylists.map((playlist) => playlist.attributes.captionServices).filter(Boolean);
+ [videoPlaylists, audioPlaylists, vttPlaylists].forEach(addMediaSequenceValues);
+
const manifest = {
allowCache: true,
discontinuityStarts: [],
@@ -336,5 +397,12 @@ export const toM3u8 = (dashPlaylists, locations, sidxMapping = {}) => {
manifest.mediaGroups['CLOSED-CAPTIONS'].cc = organizeCaptionServices(captions);
}
+ if (lastMpd) {
+ return positionManifestOnTimeline({
+ oldManifest: lastMpd,
+ newManifest: manifest
+ });
+ }
+
return manifest;
};
diff --git a/src/toPlaylists.js b/src/toPlaylists.js
index e12732b7..57679fe5 100644
--- a/src/toPlaylists.js
+++ b/src/toPlaylists.js
@@ -10,6 +10,12 @@ export const generateSegments = ({ attributes, segmentInfo }) => {
if (segmentInfo.template) {
segmentsFn = segmentsFromTemplate;
segmentAttributes = merge(attributes, segmentInfo.template);
+ // TODO: Decide if SegmentList be chosen ahead of SegmentBase.
+ //
+ // Judging by the specification (see the 2012 specification, section 5.3.9.2),
+ // SegmentBase seems to only be used as the strategy if there's no SegmentTemplate or
+ // SegmentList. However, the historical ordering here will use SegmentBase as the
+ // strategy before SegmentList. This ordering should be reconsidered.
} else if (segmentInfo.base) {
segmentsFn = segmentsFromBase;
segmentAttributes = merge(attributes, segmentInfo.base);
diff --git a/src/utils/list.js b/src/utils/list.js
index d3c7d370..f236df9d 100644
--- a/src/utils/list.js
+++ b/src/utils/list.js
@@ -31,3 +31,37 @@ export const findIndexes = (l, key) => l.reduce((a, e, i) => {
return a;
}, []);
+
+/**
+ * Returns the first index that satisfies the matching function, or -1 if not found.
+ *
+ * Only necessary because of IE11 support.
+ *
+ * @param {Array} list the list to search through
+ * @param {Function} matchingFunction the matching function
+ *
+ * @return {number} the matching index or -1 if not found
+ */
+export const findIndex = (list, matchingFunction) => {
+ for (let i = 0; i < list.length; i++) {
+ if (matchingFunction(list[i])) {
+ return i;
+ }
+ }
+
+ return -1;
+};
+
+/**
+ * Returns whether the list contains the search element.
+ *
+ * Only necessary because of IE11 support.
+ *
+ * @param {Array} list the list to search through
+ * @param {*} searchElement the element to look for
+ *
+ * @return {boolean} whether the list includes the search element or not
+ */
+export const includes = (list, searchElement) => {
+ return list.some((element) => element === searchElement);
+};
diff --git a/test/index.test.js b/test/index.test.js
index f3dabd1a..17aa72bc 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -18,6 +18,9 @@ import multiperiodSegmentTemplate from './manifests/multiperiod-segment-template
import multiperiodSegmentList from './manifests/multiperiod-segment-list.mpd';
import multiperiodDynamic from './manifests/multiperiod-dynamic.mpd';
import audioOnly from './manifests/audio-only.mpd';
+import multiperiodStartnumber from './manifests/multiperiod-startnumber.mpd';
+import multiperiodStartnumberRemovedPeriods from
+ './manifests/multiperiod-startnumber-removed-periods.mpd';
import {
parsedManifest as maatVttSegmentTemplateManifest
} from './manifests/maat_vtt_segmentTemplate.js';
@@ -54,6 +57,12 @@ import {
import {
parsedManifest as locationsManifest
} from './manifests/locations.js';
+import {
+ parsedManifest as multiperiodStartnumberManifest
+} from './manifests/multiperiod-startnumber.js';
+import {
+ parsedManifest as multiperiodStartnumberRemovedPeriodsManifest
+} from './manifests/multiperiod-startnumber-removed-periods.js';
import {
parsedManifest as vttCodecsManifest
@@ -129,6 +138,10 @@ QUnit.test('has parse', function(assert) {
name: 'audio-only',
input: audioOnly,
expected: audioOnlyManifest
+}, {
+ name: 'multiperiod_startnumber',
+ input: multiperiodStartnumber,
+ expected: multiperiodStartnumberManifest
}].forEach(({ name, input, expected }) => {
QUnit.test(`${name} test manifest`, function(assert) {
const actual = parse(input);
@@ -136,3 +149,16 @@ QUnit.test('has parse', function(assert) {
assert.deepEqual(actual, expected);
});
});
+
+// this test is handled separately as a `lastMpd` needs to be parsed and provided
+QUnit.test('multiperiod_startnumber_removed_periods test manifest', function(assert) {
+ const lastMpd = parse(multiperiodStartnumber);
+ const actual = parse(multiperiodStartnumberRemovedPeriods, { lastMpd });
+
+ // Since these properties are only added if `lastMpd` is provided in the call to parse,
+ // they should be added here, rather than in the parsed manifest file.
+ multiperiodStartnumberRemovedPeriodsManifest.playlistsToExclude = [];
+ multiperiodStartnumberRemovedPeriodsManifest.mediaGroupPlaylistsToExclude = [];
+
+ assert.deepEqual(actual, multiperiodStartnumberRemovedPeriodsManifest);
+});
diff --git a/test/manifests/608-captions.js b/test/manifests/608-captions.js
index 10061783..e225cfe3 100644
--- a/test/manifests/608-captions.js
+++ b/test/manifests/608-captions.js
@@ -48,11 +48,13 @@ export const parsedManifest = {
resolvedUri: '',
targetDuration: 6,
mediaSequence: 0,
+ discontinuitySequence: 0,
segments: [
{
duration: 6,
timeline: 0,
number: 0,
+ presentationTime: 0,
map: {
uri: '',
resolvedUri: 'https://www.example.com/1080p.ts'
diff --git a/test/manifests/708-captions.js b/test/manifests/708-captions.js
index eae5dfd0..693340af 100644
--- a/test/manifests/708-captions.js
+++ b/test/manifests/708-captions.js
@@ -49,11 +49,13 @@ export const parsedManifest = {
resolvedUri: '',
targetDuration: 6,
mediaSequence: 0,
+ discontinuitySequence: 0,
segments: [
{
duration: 6,
timeline: 0,
number: 0,
+ presentationTime: 0,
map: {
uri: '',
resolvedUri: 'https://www.example.com/1080p.ts'
diff --git a/test/manifests/audio-only.js b/test/manifests/audio-only.js
index 74ecc873..c6d80963 100644
--- a/test/manifests/audio-only.js
+++ b/test/manifests/audio-only.js
@@ -26,7 +26,8 @@ export const parsedManifest = {
resolvedUri: '',
targetDuration: 60,
segments: [],
- mediaSequence: 1,
+ mediaSequence: 0,
+ discontinuitySequence: 0,
sidx: {
uri: 'http://example.com/audio_en_2c_128k_aac.mp4',
resolvedUri: 'http://example.com/audio_en_2c_128k_aac.mp4',
@@ -44,6 +45,7 @@ export const parsedManifest = {
},
duration: 60,
timeline: 0,
+ presentationTime: 0,
number: 0
}
}
@@ -70,7 +72,8 @@ export const parsedManifest = {
resolvedUri: '',
targetDuration: 60,
segments: [],
- mediaSequence: 1,
+ mediaSequence: 0,
+ discontinuitySequence: 0,
sidx: {
uri: 'http://example.com/audio_es_2c_128k_aac.mp4',
resolvedUri: 'http://example.com/audio_es_2c_128k_aac.mp4',
@@ -88,6 +91,7 @@ export const parsedManifest = {
},
duration: 60,
timeline: 0,
+ presentationTime: 0,
number: 0
}
}
diff --git a/test/manifests/location.js b/test/manifests/location.js
index 5108de7e..6fb13529 100644
--- a/test/manifests/location.js
+++ b/test/manifests/location.js
@@ -30,11 +30,13 @@ export const parsedManifest = {
resolvedUri: '',
targetDuration: 6,
mediaSequence: 0,
+ discontinuitySequence: 0,
segments: [
{
duration: 6,
timeline: 0,
number: 0,
+ presentationTime: 0,
map: {
uri: '',
resolvedUri: 'https://www.example.com/1080p.ts'
diff --git a/test/manifests/locations.js b/test/manifests/locations.js
index d3e40760..df741de8 100644
--- a/test/manifests/locations.js
+++ b/test/manifests/locations.js
@@ -31,11 +31,13 @@ export const parsedManifest = {
resolvedUri: '',
targetDuration: 6,
mediaSequence: 0,
+ discontinuitySequence: 0,
segments: [
{
duration: 6,
timeline: 0,
number: 0,
+ presentationTime: 0,
map: {
uri: '',
resolvedUri: 'https://www.example.com/1080p.ts'
diff --git a/test/manifests/maat_vtt_segmentTemplate.js b/test/manifests/maat_vtt_segmentTemplate.js
index ec06727d..3c7a38ff 100644
--- a/test/manifests/maat_vtt_segmentTemplate.js
+++ b/test/manifests/maat_vtt_segmentTemplate.js
@@ -74,6 +74,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -146,6 +147,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -226,6 +228,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -298,6 +301,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -338,10 +342,12 @@ export const parsedManifest = {
timeline: 0,
resolvedUri: 'https://example.com/en.vtt',
duration: 6,
+ presentationTime: 0,
number: 0
}
],
- mediaSequence: 0
+ mediaSequence: 0,
+ discontinuitySequence: 0
}
],
uri: ''
@@ -368,10 +374,12 @@ export const parsedManifest = {
timeline: 0,
resolvedUri: 'https://example.com/es.vtt',
duration: 6,
+ presentationTime: 0,
number: 0
}
],
- mediaSequence: 0
+ mediaSequence: 0,
+ discontinuitySequence: 0
}
],
uri: ''
@@ -451,6 +459,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -529,6 +538,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
diff --git a/test/manifests/multiperiod-dynamic.js b/test/manifests/multiperiod-dynamic.js
index 9cab1fda..df926b5f 100644
--- a/test/manifests/multiperiod-dynamic.js
+++ b/test/manifests/multiperiod-dynamic.js
@@ -270,6 +270,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -538,6 +539,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -824,6 +826,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -1098,6 +1101,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
@@ -1372,6 +1376,7 @@ export const parsedManifest = {
}
],
mediaSequence: 0,
+ discontinuitySequence: 0,
contentProtection: {
'com.widevine.alpha': {
attributes: {
diff --git a/test/manifests/multiperiod-segment-list.js b/test/manifests/multiperiod-segment-list.js
index f60dddde..01484f5b 100644
--- a/test/manifests/multiperiod-segment-list.js
+++ b/test/manifests/multiperiod-segment-list.js
@@ -24,7 +24,8 @@ export const parsedManifest = {
'SUBTITLES': 'subs'
},
endList: true,
- mediaSequence: 1,
+ mediaSequence: 0,
+ discontinuitySequence: 0,
targetDuration: 3,
resolvedUri: '',
segments: [
@@ -38,7 +39,7 @@ export const parsedManifest = {
timeline: 0,
presentationTime: 0,
uri: 'low/segment-1.ts',
- number: 1
+ number: 0
},
{
duration: 3,
@@ -50,7 +51,7 @@ export const parsedManifest = {
timeline: 0,
presentationTime: 3,
uri: 'low/segment-2.ts',
- number: 2
+ number: 1
},
{
discontinuity: true,
@@ -63,7 +64,7 @@ export const parsedManifest = {
timeline: 1,
presentationTime: 6,
uri: 'low/segment-1.ts',
- number: 1
+ number: 2
},
{
duration: 3,
@@ -75,7 +76,7 @@ export const parsedManifest = {
timeline: 1,
presentationTime: 9,
uri: 'low/segment-2.ts',
- number: 2
+ number: 3
}
],
timeline: 0,
diff --git a/test/manifests/multiperiod-segment-template.js b/test/manifests/multiperiod-segment-template.js
index f5dece29..7f847022 100644
--- a/test/manifests/multiperiod-segment-template.js
+++ b/test/manifests/multiperiod-segment-template.js
@@ -22,13 +22,13 @@ export const parsedManifest = {
},
uri: '',
endList: true,
- timeline: 1,
+ timeline: 0,
resolvedUri: '',
targetDuration: 5,
segments: [
{
uri: 'audio/segment_0.m4f',
- timeline: 1,
+ timeline: 0,
duration: 5,
resolvedUri: 'https://www.example.com/audio/segment_0.m4f',
map: {
@@ -40,7 +40,7 @@ export const parsedManifest = {
},
{
uri: 'audio/segment_1.m4f',
- timeline: 1,
+ timeline: 0,
duration: 5,
resolvedUri: 'https://www.example.com/audio/segment_1.m4f',
map: {
@@ -52,7 +52,7 @@ export const parsedManifest = {
},
{
uri: 'audio/segment_2.m4f',
- timeline: 1,
+ timeline: 0,
duration: 5,
resolvedUri: 'https://www.example.com/audio/segment_2.m4f',
map: {
@@ -65,42 +65,43 @@ export const parsedManifest = {
{
discontinuity: true,
uri: 'audio/segment_0.m4f',
- timeline: 2,
+ timeline: 1,
duration: 5,
resolvedUri: 'https://www.example.com/audio/segment_0.m4f',
map: {
uri: 'audio/init.m4f',
resolvedUri: 'https://www.example.com/audio/init.m4f'
},
- number: 0,
+ number: 3,
presentationTime: 15
},
{
uri: 'audio/segment_1.m4f',
- timeline: 2,
+ timeline: 1,
duration: 5,
resolvedUri: 'https://www.example.com/audio/segment_1.m4f',
map: {
uri: 'audio/init.m4f',
resolvedUri: 'https://www.example.com/audio/init.m4f'
},
- number: 1,
+ number: 4,
presentationTime: 20
},
{
uri: 'audio/segment_2.m4f',
- timeline: 2,
+ timeline: 1,
duration: 5,
resolvedUri: 'https://www.example.com/audio/segment_2.m4f',
map: {
uri: 'audio/init.m4f',
resolvedUri: 'https://www.example.com/audio/init.m4f'
},
- number: 2,
+ number: 5,
presentationTime: 25
}
],
- mediaSequence: 0
+ mediaSequence: 0,
+ discontinuitySequence: 0
}
],
uri: ''
@@ -127,13 +128,13 @@ export const parsedManifest = {
},
uri: '',
endList: true,
- timeline: 1,
+ timeline: 0,
resolvedUri: '',
targetDuration: 5,
segments: [
{
uri: 'video/segment_0.m4f',
- timeline: 1,
+ timeline: 0,
duration: 5,
resolvedUri: 'https://www.example.com/video/segment_0.m4f',
map: {
@@ -145,7 +146,7 @@ export const parsedManifest = {
},
{
uri: 'video/segment_1.m4f',
- timeline: 1,
+ timeline: 0,
duration: 5,
resolvedUri: 'https://www.example.com/video/segment_1.m4f',
map: {
@@ -157,7 +158,7 @@ export const parsedManifest = {
},
{
uri: 'video/segment_2.m4f',
- timeline: 1,
+ timeline: 0,
duration: 5,
resolvedUri: 'https://www.example.com/video/segment_2.m4f',
map: {
@@ -170,42 +171,43 @@ export const parsedManifest = {
{
discontinuity: true,
uri: 'video/segment_0.m4f',
- timeline: 2,
+ timeline: 1,
duration: 5,
resolvedUri: 'https://www.example.com/video/segment_0.m4f',
map: {
uri: 'video/init.m4f',
resolvedUri: 'https://www.example.com/video/init.m4f'
},
- number: 0,
+ number: 3,
presentationTime: 15
},
{
uri: 'video/segment_1.m4f',
- timeline: 2,
+ timeline: 1,
duration: 5,
resolvedUri: 'https://www.example.com/video/segment_1.m4f',
map: {
uri: 'video/init.m4f',
resolvedUri: 'https://www.example.com/video/init.m4f'
},
- number: 1,
+ number: 4,
presentationTime: 20
},
{
uri: 'video/segment_2.m4f',
- timeline: 2,
+ timeline: 1,
duration: 5,
resolvedUri: 'https://www.example.com/video/segment_2.m4f',
map: {
uri: 'video/init.m4f',
resolvedUri: 'https://www.example.com/video/init.m4f'
},
- number: 2,
+ number: 5,
presentationTime: 25
}
],
- mediaSequence: 0
+ mediaSequence: 0,
+ discontinuitySequence: 0
}
]
};
diff --git a/test/manifests/multiperiod-startnumber-removed-periods.js b/test/manifests/multiperiod-startnumber-removed-periods.js
new file mode 100644
index 00000000..afd11fed
--- /dev/null
+++ b/test/manifests/multiperiod-startnumber-removed-periods.js
@@ -0,0 +1,450 @@
+export const parsedManifest = {
+ allowCache: true,
+ discontinuityStarts: [],
+ duration: 0,
+ endList: true,
+ mediaGroups: {
+ 'AUDIO': {
+ audio: {
+ 'en (main)': {
+ autoselect: true,
+ default: true,
+ language: 'en',
+ playlists: [
+ {
+ attributes: {
+ 'BANDWIDTH': 129262,
+ 'CODECS': 'mp4a.40.5',
+ 'NAME': 'v0',
+ 'PROGRAM-ID': 1
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/audio/v0/init.mp4',
+ uri: 'init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/audio/v0/862.m4f',
+ timeline: 3,
+ uri: '862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/audio/v0/init.mp4',
+ uri: 'init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/audio/v0/863.m4f',
+ timeline: 3,
+ uri: '863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/audio/v0/init.mp4',
+ uri: 'init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/audio/v0/864.m4f',
+ timeline: 3,
+ uri: '864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ }
+ ],
+ uri: ''
+ }
+ }
+ },
+ 'CLOSED-CAPTIONS': {},
+ 'SUBTITLES': {},
+ 'VIDEO': {}
+ },
+ minimumUpdatePeriod: 2000,
+ playlists: [
+ {
+ attributes: {
+ 'AUDIO': 'audio',
+ 'BANDWIDTH': 2942295,
+ 'CODECS': 'avc1.4d001f',
+ 'NAME': 'D',
+ 'PROGRAM-ID': 1,
+ 'RESOLUTION': {
+ height: 720,
+ width: 1280
+ },
+ 'SUBTITLES': 'subs'
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/D/D_init.mp4',
+ uri: 'D_init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/video/D/D862.m4f',
+ timeline: 3,
+ uri: 'D862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/D/D_init.mp4',
+ uri: 'D_init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/video/D/D863.m4f',
+ timeline: 3,
+ uri: 'D863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/D/D_init.mp4',
+ uri: 'D_init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/video/D/D864.m4f',
+ timeline: 3,
+ uri: 'D864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ },
+ {
+ attributes: {
+ 'AUDIO': 'audio',
+ 'BANDWIDTH': 4267536,
+ 'CODECS': 'avc1.640020',
+ 'NAME': 'E',
+ 'PROGRAM-ID': 1,
+ 'RESOLUTION': {
+ height: 720,
+ width: 1280
+ },
+ 'SUBTITLES': 'subs'
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/E/E_init.mp4',
+ uri: 'E_init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/video/E/E862.m4f',
+ timeline: 3,
+ uri: 'E862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/E/E_init.mp4',
+ uri: 'E_init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/video/E/E863.m4f',
+ timeline: 3,
+ uri: 'E863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/E/E_init.mp4',
+ uri: 'E_init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/video/E/E864.m4f',
+ timeline: 3,
+ uri: 'E864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ },
+ {
+ attributes: {
+ 'AUDIO': 'audio',
+ 'BANDWIDTH': 5256859,
+ 'CODECS': 'avc1.640020',
+ 'NAME': 'F',
+ 'PROGRAM-ID': 1,
+ 'RESOLUTION': {
+ height: 720,
+ width: 1280
+ },
+ 'SUBTITLES': 'subs'
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/F/F_init.mp4',
+ uri: 'F_init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/video/F/F862.m4f',
+ timeline: 3,
+ uri: 'F862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/F/F_init.mp4',
+ uri: 'F_init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/video/F/F863.m4f',
+ timeline: 3,
+ uri: 'F863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/F/F_init.mp4',
+ uri: 'F_init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/video/F/F864.m4f',
+ timeline: 3,
+ uri: 'F864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ },
+ {
+ attributes: {
+ 'AUDIO': 'audio',
+ 'BANDWIDTH': 240781,
+ 'CODECS': 'avc1.4d000d',
+ 'NAME': 'A',
+ 'PROGRAM-ID': 1,
+ 'RESOLUTION': {
+ height: 234,
+ width: 416
+ },
+ 'SUBTITLES': 'subs'
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/A/A_init.mp4',
+ uri: 'A_init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/video/A/A862.m4f',
+ timeline: 3,
+ uri: 'A862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/A/A_init.mp4',
+ uri: 'A_init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/video/A/A863.m4f',
+ timeline: 3,
+ uri: 'A863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/A/A_init.mp4',
+ uri: 'A_init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/video/A/A864.m4f',
+ timeline: 3,
+ uri: 'A864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ },
+ {
+ attributes: {
+ 'AUDIO': 'audio',
+ 'BANDWIDTH': 494354,
+ 'CODECS': 'avc1.4d001e',
+ 'NAME': 'B',
+ 'PROGRAM-ID': 1,
+ 'RESOLUTION': {
+ height: 360,
+ width: 640
+ },
+ 'SUBTITLES': 'subs'
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/B/B_init.mp4',
+ uri: 'B_init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/video/B/B862.m4f',
+ timeline: 3,
+ uri: 'B862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/B/B_init.mp4',
+ uri: 'B_init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/video/B/B863.m4f',
+ timeline: 3,
+ uri: 'B863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/B/B_init.mp4',
+ uri: 'B_init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/video/B/B864.m4f',
+ timeline: 3,
+ uri: 'B864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ },
+ {
+ attributes: {
+ 'AUDIO': 'audio',
+ 'BANDWIDTH': 1277155,
+ 'CODECS': 'avc1.4d001f',
+ 'NAME': 'C',
+ 'PROGRAM-ID': 1,
+ 'RESOLUTION': {
+ height: 540,
+ width: 960
+ },
+ 'SUBTITLES': 'subs'
+ },
+ endList: false,
+ mediaSequence: 7,
+ discontinuitySequence: 2,
+ discontinuityStarts: [0],
+ resolvedUri: '',
+ segments: [
+ {
+ discontinuity: true,
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/C/C_init.mp4',
+ uri: 'C_init.mp4'
+ },
+ presentationTime: 111,
+ number: 7,
+ resolvedUri: 'http://example.com/video/C/C862.m4f',
+ timeline: 3,
+ uri: 'C862.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/C/C_init.mp4',
+ uri: 'C_init.mp4'
+ },
+ presentationTime: 112,
+ number: 8,
+ resolvedUri: 'http://example.com/video/C/C863.m4f',
+ timeline: 3,
+ uri: 'C863.m4f'
+ },
+ {
+ duration: 1,
+ map: {
+ resolvedUri: 'http://example.com/video/C/C_init.mp4',
+ uri: 'C_init.mp4'
+ },
+ presentationTime: 113,
+ number: 9,
+ resolvedUri: 'http://example.com/video/C/C864.m4f',
+ timeline: 3,
+ uri: 'C864.m4f'
+ }
+ ],
+ targetDuration: 1,
+ timeline: 3,
+ uri: ''
+ }
+ ],
+ segments: [],
+ suggestedPresentationDelay: 6,
+ uri: ''
+};
diff --git a/test/manifests/multiperiod-startnumber-removed-periods.mpd b/test/manifests/multiperiod-startnumber-removed-periods.mpd
new file mode 100644
index 00000000..df12a207
--- /dev/null
+++ b/test/manifests/multiperiod-startnumber-removed-periods.mpd
@@ -0,0 +1,185 @@
+
+
+
+
+
+
+
+ http://example.com/audio/v0/
+
+
+