Parse <SegmentList> and <SegmentBase> (#18)

src/errors.js

@@ -2,5 +2,7 @@ export default {
  INVALID_NUMBER_OF_PERIOD: 'INVALID_NUMBER_OF_PERIOD',
  DASH_EMPTY_MANIFEST: 'DASH_EMPTY_MANIFEST',
  DASH_INVALID_XML: 'DASH_INVALID_XML',
- UNSUPPORTED_SEGMENTATION_TYPE: 'UNSUPPORTED_SEGMENTATION_TYPE'
+ NO_BASE_URL: 'NO_BASE_URL',
+ MISSING_SEGMENT_INFORMATION: 'MISSING_SEGMENT_INFORMATION',
+ SEGMENT_TIME_UNSPECIFIED: 'SEGMENT_TIME_UNSPECIFIED'
 };

src/inheritAttributes.js

@@ -2,7 +2,7 @@ import { flatten } from './utils/list';
 import { shallowMerge, getAttributes } from './utils/object';
 import { parseDuration } from './utils/time';
 import { findChildren, getContent } from './utils/xml';
-import resolveUrl from './resolveUrl';
+import resolveUrl from './utils/resolveUrl';
 import errors from './errors';
 
 /**
@@ -50,17 +50,48 @@ export const buildBaseUrls = (referenceUrls, baseUrlElements) => {
  */
 export const getSegmentInformation = (adaptationSet) => {
  const segmentTemplate = findChildren(adaptationSet, 'SegmentTemplate')[0];
- const segmentTimeline =
- segmentTemplate && findChildren(segmentTemplate, 'SegmentTimeline')[0];
  const segmentList = findChildren(adaptationSet, 'SegmentList')[0];
+ const segmentUrls = segmentList && findChildren(segmentList, 'SegmentURL')
+ .map(s => shallowMerge({ tag: 'SegmentURL' }, getAttributes(s)));
  const segmentBase = findChildren(adaptationSet, 'SegmentBase')[0];
+ const segmentTimelineParentNode = segmentList || segmentTemplate;
+ const segmentTimeline = segmentTimelineParentNode &&
+ findChildren(segmentTimelineParentNode, 'SegmentTimeline')[0];
+ const segmentInitializationParentNode = segmentList || segmentBase || segmentTemplate;
+ const segmentInitialization = segmentInitializationParentNode &&
+ findChildren(segmentInitializationParentNode, 'Initialization')[0];
+
+ // SegmentTemplate is handled slightly differently, since it can have both
+ // @initialization and an <Initialization> node. @initialization can be templated,
+ // while the node can have a url and range specified. If the <SegmentTemplate> has
+ // both @initialization and an <Initialization> subelement we opt to override with
+ // the node, as this interaction is not defined in the spec.
+ const template = segmentTemplate && getAttributes(segmentTemplate);
+
+ if (template && segmentInitialization) {
+ template.initialization =
+ (segmentInitialization && getAttributes(segmentInitialization));
+ } else if (template && template.initialization) {
+ // If it is @initialization we convert it to an object since this is the format that
+ // later functions will rely on for the initialization segment. This is only valid
+ // for <SegmentTemplate>
+ template.initialization = { sourceURL: template.initialization };
+ }
 
  return {
- template: segmentTemplate && getAttributes(segmentTemplate),
+ template,
  timeline: segmentTimeline &&
- findChildren(segmentTimeline, 'S').map(s => getAttributes(s)),
- list: segmentList && getAttributes(segmentList),
- base: segmentBase && getAttributes(segmentBase)
+ findChildren(segmentTimeline, 'S').map(s => getAttributes(s)),
+ list: segmentList && shallowMerge(
+ getAttributes(segmentList),
+ {
+ segmentUrls,
+ initialization: getAttributes(segmentInitialization)
+ }),
+ base: segmentBase && shallowMerge(
+ getAttributes(segmentBase), {
+ initialization: getAttributes(segmentInitialization)
+ })
  };
 };
 

src/segment/segmentBase.js

@@ -0,0 +1,64 @@
+import errors from '../errors';
+import urlTypeConverter from './urlType';
+import { parseByDuration } from './timeParser';
+
+/**
+ * Translates SegmentBase into a set of segments.
+ * (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes. Each
+ * node should be translated into segment.
+ *
+ * @param {Object} attributes
+ * Object containing all inherited attributes from parent elements with attribute
+ * names as keys
+ * @return {Object.<Array>} list of segments
+ */
+export const segmentsFromBase = (attributes) => {
+ const {
+ baseUrl,
+ initialization = {},
+ sourceDuration,
+ timescale = 1,
+ startNumber = 1,
+ periodIndex = 0,
+ indexRange = '',
+ duration
+ } = attributes;
+
+ // base url is required for SegmentBase to work, per spec (Section 5.3.9.2.1)
+ if (!baseUrl) {
+ throw new Error(errors.NO_BASE_URL);
+ }
+
+ const initSegment = urlTypeConverter({
+ baseUrl,
+ source: initialization.sourceURL,
+ range: initialization.range
+ });
+ const segment = urlTypeConverter({ baseUrl, source: baseUrl, range: indexRange });
+
+ segment.map = initSegment;
+
+ const parsedTimescale = parseInt(timescale, 10);
+
+ // If there is a duration, use it, otherwise use the given duration of the source
+ // (since SegmentBase is only for one total segment)
+ if (duration) {
+ const parsedDuration = parseInt(duration, 10);
+ const start = parseInt(startNumber, 10);
+ const segmentTimeInfo = parseByDuration(start,
+ periodIndex,
+ parsedTimescale,
+ parsedDuration,
+ sourceDuration);
+
+ if (segmentTimeInfo.length >= 1) {
+ segment.duration = segmentTimeInfo[0].duration;
+ segment.timeline = segmentTimeInfo[0].timeline;
+ }
+ } else if (sourceDuration) {
+ segment.duration = (sourceDuration / parsedTimescale);
+ segment.timeline = 0;
+ }
+
+ return [segment];
+};

src/segment/segmentList.js

@@ -0,0 +1,103 @@
+import { parseByDuration, parseByTimeline } from './timeParser';
+import urlTypeConverter from './urlType';
+import errors from '../errors';
+
+/**
+ * Converts a <SegmentUrl> (of type URLType from the DASH spec 5.3.9.2 Table 14)
+ * to an object that matches the output of a segment in videojs/mpd-parser
+ *
+ * @param {Object} attributes
+ * Object containing all inherited attributes from parent elements with attribute
+ * names as keys
+ * @param {Object} segmentUrl
+ * <SegmentURL> node to translate into a segment object
+ * @return {Object} translated segment object
+ */
+const SegmentURLToSegmentObject = (attributes, segmentUrl) => {
+ const { baseUrl, initialization = {} } = attributes;
+
+ const initSegment = urlTypeConverter({
+ baseUrl,
+ source: initialization.sourceURL,
+ range: initialization.range
+ });
+
+ const segment = urlTypeConverter({
+ baseUrl,
+ source: segmentUrl.media,
+ range: segmentUrl.mediaRange
+ });
+
+ segment.map = initSegment;
+
+ return segment;
+};
+
+/**
+ * Generates a list of segments using information provided by the SegmentList element
+ * SegmentList (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes. Each
+ * node should be translated into segment.
+ *
+ * @param {Object} attributes
+ * Object containing all inherited attributes from parent elements with attribute
+ * names as keys
+ * @param {Object[]|undefined} segmentTimeline
+ * List of objects representing the attributes of each S element contained within
+ * the SegmentTimeline element
+ * @return {Object.<Array>} list of segments
+ */
+export const segmentsFromList = (attributes, segmentTimeline) => {
+ const {
+ timescale = 1,
+ duration,
+ segmentUrls = [],
+ periodIndex = 0,
+ startNumber = 1
+ } = attributes;
+
+ // Per spec (5.3.9.2.1) no way to determine segment duration OR
+ // if both SegmentTimeline and @duration are defined, it is outside of spec.
+ if ((!duration && !segmentTimeline) ||
+ (duration && segmentTimeline)) {
+ throw new Error(errors.SEGMENT_TIME_UNSPECIFIED);
+ }
+
+ const parsedTimescale = parseInt(timescale, 10);
+ const start = parseInt(startNumber, 10);
+ const segmentUrlMap = segmentUrls.map(segmentUrlObject =>
+ SegmentURLToSegmentObject(attributes, segmentUrlObject));
+ let segmentTimeInfo;
+
+ if (duration) {
+ const parsedDuration = parseInt(duration, 10);
+
+ segmentTimeInfo = parseByDuration(start,
+ periodIndex,
+ parsedTimescale,
+ parsedDuration,
+ attributes.sourceDuration);
+ }
+
+ if (segmentTimeline) {
+ segmentTimeInfo = parseByTimeline(start,
+ periodIndex,
+ parsedTimescale,
+ segmentTimeline,
+ attributes.sourceDuration);
+ }
+
+ const segments = segmentTimeInfo.map((segmentTime, index) => {
+ if (segmentUrlMap[index]) {
+ const segment = segmentUrlMap[index];
+
+ segment.timeline = segmentTime.timeline;
+ segment.duration = segmentTime.duration;
+ return segment;
+ }
+ // Since we're mapping we should get rid of any blank segments (in case
+ // the given SegmentTimeline is handling for more elements than we have
+ // SegmentURLs for).
+ }).filter(segment => segment);
+
+ return segments;
+};