Parse <SegmentList> and <SegmentBase>

src/inheritAttributes.js

@@ -51,24 +51,41 @@ export const buildBaseUrls = (referenceUrls, baseUrlElements) => {
 export const getSegmentInformation = (adaptationSet) => {
   const segmentTemplate = findChildren(adaptationSet, 'SegmentTemplate')[0];
   const segmentList = findChildren(adaptationSet, 'SegmentList')[0];
-  const segmentUrls = segmentList && findChildren(segmentList, 'SegmentURL');
+  const segmentUrls = segmentList && findChildren(segmentList, 'SegmentURL')
+    .map(s => shallowMerge({ tag: 'SegmentURL' }, getAttributes(s)));
   const segmentBase = findChildren(adaptationSet, 'SegmentBase')[0];
-  const segmentTimelineNode = segmentList ? segmentList : segmentTemplate;
+  const segmentTimelineNode = segmentList || segmentTemplate;
   const segmentTimeline =
     segmentTimelineNode && findChildren(segmentTimelineNode, 'SegmentTimeline')[0];
+  const segmentInitializationNode = segmentList || segmentBase || segmentTemplate;
+  const segmentInitialization = segmentInitializationNode &&
+    findChildren(segmentInitializationNode, '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 = getAttributes(segmentInitialization);
+  }
 
   return {
-    template: segmentTemplate && getAttributes(segmentTemplate),
+    template,
     timeline: segmentTimeline &&
-                     findChildren(segmentTimeline, 'S').map(s => getAttributes(s)),
-    list: segmentList &&
-            shallowMerge(getAttributes(segmentList),
-              {
-                segmentUrls: segmentUrls &&
-                  segmentUrls.map(s =>
-                    shallowMerge({ tag: 'SegmentURL' }, getAttributes(s)))
-              }),
-    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

@@ -1,5 +1,5 @@
-import resolveUrl from '../utils/resolveUrl';
 import errors from '../errors';
+import urlTypeConverter from './urlType';
 import { parseByDuration } from './timeParser';
 
 /**
@@ -15,11 +15,12 @@ import { parseByDuration } from './timeParser';
 export const segmentsFromBase = (attributes) => {
   const {
     baseUrl,
-    initialization = '',
+    initialization = {},
     sourceDuration,
     timescale = 1,
     startNumber = 1,
     periodIndex = 0,
+    indexRange = '',
     duration
   } = attributes;
 
@@ -28,14 +29,15 @@ export const segmentsFromBase = (attributes) => {
     throw new Error(errors.NO_BASE_URL);
   }
 
-  const segment = {
-    map: {
-      uri: initialization,
-      resolvedUri: resolveUrl(attributes.baseUrl || '', initialization)
-    },
-    resolvedUri: resolveUrl(attributes.baseUrl || '', ''),
-    uri: attributes.baseUrl
-  };
+  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

src/segment/segmentList.js

@@ -1,5 +1,5 @@
-import resolveUrl from '../utils/resolveUrl';
 import { parseByDuration, parseByTimeline } from './timeParser';
+import urlTypeConverter from './urlType';
 import errors from '../errors';
 
 /**
@@ -14,29 +14,21 @@ import errors from '../errors';
  * @return {Object} translated segment object
  */
 const SegmentURLToSegmentObject = (attributes, segmentUrl) => {
-  const initUri = attributes.initialization || '';
+  const { baseUrl, initialization = {} } = attributes;
 
-  const segment = {
-    map: {
-      uri: initUri,
-      resolvedUri: resolveUrl(attributes.baseUrl || '', initUri)
-    },
-    resolvedUri: resolveUrl(attributes.baseUrl || '', segmentUrl.media),
-    uri: segmentUrl.media
-  };
+  const initSegment = urlTypeConverter({
+    baseUrl,
+    source: initialization.sourceURL,
+    range: initialization.range
+  });
 
-  // Follows byte-range-spec per RFC2616
-  // @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
-  if (segmentUrl.mediaRange) {
-    const ranges = segmentUrl.mediaRange.split('-');
-    const startRange = parseInt(ranges[0], 10);
-    const endRange = parseInt(ranges[1], 10);
+  const segment = urlTypeConverter({
+    baseUrl,
+    source: segmentUrl.media,
+    range: segmentUrl.mediaRange
+  });
 
-    segment.byterange = {
-      length: endRange - startRange,
-      offset: startRange
-    };
-  }
+  segment.map = initSegment;
 
   return segment;
 };

src/segment/segmentTemplate.js

@@ -1,4 +1,5 @@
 import resolveUrl from '../utils/resolveUrl';
+import urlTypeToSegment from './urlType';
 import { parseByDuration, parseByTimeline } from './timeParser';
 
 const identifierPattern = /\$([A-z]*)(?:(%0)([0-9]+)d)?\$/g;
@@ -151,7 +152,26 @@ export const segmentsFromTemplate = (attributes, segmentTimeline) => {
     RepresentationID: attributes.id,
     Bandwidth: parseInt(attributes.bandwidth || 0, 10)
   };
-  const mapUri = constructTemplateUrl(attributes.initialization || '', templateValues);
+
+  let mapSegment = { uri: '', resolvedUri: resolveUrl(attributes.baseUrl || '', '') };
+
+  if (attributes.initialization && typeof attributes.initialization === 'string') {
+    const mapUri = constructTemplateUrl(attributes.initialization || '', templateValues);
+
+    mapSegment = {
+      uri: mapUri,
+      resolvedUri: resolveUrl(attributes.baseUrl || '', mapUri)
+    };
+  }
+
+  if (attributes.initialization && typeof attributes.initialization === 'object') {
+    mapSegment = urlTypeToSegment({
+      baseUrl: attributes.baseUrl,
+      source: attributes.initialization.sourceURL,
+      range: attributes.initialization.range
+    });
+  }
+
   const segments = parseTemplateInfo(attributes, segmentTimeline);
 
   return segments.map(segment => {
@@ -165,10 +185,7 @@ export const segmentsFromTemplate = (attributes, segmentTimeline) => {
       timeline: segment.timeline,
       duration: segment.duration,
       resolvedUri: resolveUrl(attributes.baseUrl || '', uri),
-      map: {
-        uri: mapUri,
-        resolvedUri: resolveUrl(attributes.baseUrl || '', mapUri)
-      }
+      map: mapSegment
     };
   });
 };

src/segment/urlType.js

@@ -0,0 +1,47 @@
+import resolveUrl from '../utils/resolveUrl';
+
+/**
+ * @typedef {Object} SingleUri
+ * @property {string} uri - relative location of segment
+ * @property {string} resolvedUri - resolved location of segment
+ * @property {Object} byterange - Object containing information on how to make byte range
+ *   requests following byte-range-spec per RFC2616.
+ * @property {String} byterange.length - length of range request
+ * @property {String} byterange.offset - byte offset of range request
+ *
+ * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
+ */
+
+/**
+ * Converts a URLType node (5.3.9.2.3 Table 13) to a segment object
+ * that conforms to how m3u8-parser is structured
+ *
+ * @see https://github.com/videojs/m3u8-parser
+ *
+ * @param {string} baseUrl - baseUrl provided by <BaseUrl> nodes
+ * @param {string} source - source url for segment
+ * @param {string} range - optional range used for range calls, follows
+ * @return {SingleUri} full segment information transformed into a format similar
+ *   to m3u8-parser
+ */
+export const urlTypeToSegment = ({ baseUrl = '', source = '', range = '' }) => {
+  const init = {
+    uri: source,
+    resolvedUri: resolveUrl(baseUrl || '', source)
+  };
+
+  if (source && range) {
+    const ranges = range.split('-');
+    const startRange = parseInt(ranges[0], 10);
+    const endRange = parseInt(ranges[1], 10);
+
+    init.byterange = {
+      length: endRange - startRange,
+      offset: startRange
+    };
+  }
+
+  return init;
+};
+
+export default urlTypeToSegment;

test/inheritAttributes.test.js

@@ -115,7 +115,8 @@ QUnit.test('gets SegmentList attributes', function(assert) {
     timeline: void 0,
     list: {
       duration: '10',
-      segmentUrls: []
+      segmentUrls: [],
+      initialization: {}
     },
     base: void 0
   };
@@ -128,14 +129,15 @@ QUnit.test('gets SegmentBase attributes', function(assert) {
   const adaptationSet = {
     childNodes: [{
       tagName: 'SegmentBase',
-      attributes: [{ name: 'duration', value: '10' }]
+      attributes: [{ name: 'duration', value: '10' }],
+      childNodes: []
     }]
   };
   const expected = {
     template: void 0,
     timeline: void 0,
     list: void 0,
-    base: { duration: '10' }
+    base: { duration: '10', initialization: {} }
   };
 
   assert.deepEqual(getSegmentInformation(adaptationSet), expected,

test/segment/segmentBase.test.js

@@ -9,7 +9,7 @@ QUnit.module('segmentBase - segmentsFromBase');
 QUnit.test('sets segment to baseUrl', function(assert) {
   const inputAttributes = {
     baseUrl: 'http://www.example.com/i.fmp4',
-    initialization: 'http://www.example.com/init.fmp4'
+    initialization: { sourceURL: 'http://www.example.com/init.fmp4' }
   };
 
   assert.deepEqual(segmentsFromBase(inputAttributes), [{
@@ -25,7 +25,7 @@ QUnit.test('sets segment to baseUrl', function(assert) {
 QUnit.test('sets duration based on sourceDuration', function(assert) {
   const inputAttributes = {
     baseUrl: 'http://www.example.com/i.fmp4',
-    initialization: 'http://www.example.com/init.fmp4',
+    initialization: { sourceURL: 'http://www.example.com/init.fmp4' },
     sourceDuration: 10
   };
 
@@ -44,7 +44,7 @@ QUnit.test('sets duration based on sourceDuration', function(assert) {
 QUnit.test('sets duration based on sourceDuration and @timescale', function(assert) {
   const inputAttributes = {
     baseUrl: 'http://www.example.com/i.fmp4',
-    initialization: 'http://www.example.com/init.fmp4',
+    initialization: { sourceURL: 'http://www.example.com/init.fmp4' },
     sourceDuration: 10,
     timescale: 2
   };
@@ -66,7 +66,7 @@ QUnit.test('sets duration based on @duration', function(assert) {
     duration: 10,
     sourceDuration: 20,
     baseUrl: 'http://www.example.com/i.fmp4',
-    initialization: 'http://www.example.com/init.fmp4'
+    initialization: { sourceURL: 'http://www.example.com/init.fmp4' }
   };
 
   assert.deepEqual(segmentsFromBase(inputAttributes), [{
@@ -87,7 +87,7 @@ QUnit.test('sets duration based on @duration and @timescale', function(assert) {
     sourceDuration: 20,
     timescale: 5,
     baseUrl: 'http://www.example.com/i.fmp4',
-    initialization: 'http://www.example.com/init.fmp4'
+    initialization: { sourceURL: 'http://www.example.com/init.fmp4' }
   };
 
   assert.deepEqual(segmentsFromBase(inputAttributes), [{
@@ -102,6 +102,34 @@ QUnit.test('sets duration based on @duration and @timescale', function(assert) {
   }]);
 });
 
+QUnit.test('translates ranges in <Initialization> node', function(assert) {
+  const inputAttributes = {
+    duration: 10,
+    sourceDuration: 20,
+    timescale: 5,
+    baseUrl: 'http://www.example.com/i.fmp4',
+    initialization: {
+      sourceURL: 'http://www.example.com/init.fmp4',
+      range: '121-125'
+    }
+  };
+
+  assert.deepEqual(segmentsFromBase(inputAttributes), [{
+    duration: 2,
+    timeline: 0,
+    map: {
+      resolvedUri: 'http://www.example.com/init.fmp4',
+      uri: 'http://www.example.com/init.fmp4',
+      byterange: {
+        length: 4,
+        offset: 121
+      }
+    },
+    resolvedUri: 'http://www.example.com/i.fmp4',
+    uri: 'http://www.example.com/i.fmp4'
+  }]);
+});
+
 QUnit.test('errors if no baseUrl exists', function(assert) {
   assert.throws(() => segmentsFromBase({}), new Error(errors.NO_BASE_URL));
 });