Source: lib/dash/segment_template.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.dash.SegmentTemplate');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.dash.MpdUtils');
  11. goog.require('shaka.dash.SegmentBase');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.InitSegmentReference');
  14. goog.require('shaka.media.SegmentIndex');
  15. goog.require('shaka.media.SegmentReference');
  16. goog.require('shaka.util.Error');
  17. goog.require('shaka.util.ManifestParserUtils');
  18. goog.require('shaka.util.ObjectUtils');
  19. goog.requireType('shaka.dash.DashParser');
  22. /**
  23.  * @summary A set of functions for parsing SegmentTemplate elements.
  24.  */
  25. shaka.dash.SegmentTemplate = class {
  26.   /**
  27.    * Creates a new StreamInfo object.
  28.    * Updates the existing SegmentIndex, if any.
  29.    *
  30.    * @param {shaka.dash.DashParser.Context} context
  31.    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
  32.    *   requestInitSegment
  33.    * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
  34.    * @param {boolean} isUpdate True if the manifest is being updated.
  35.    * @param {number} segmentLimit The maximum number of segments to generate for
  36.    *   a SegmentTemplate with fixed duration.
  37.    * @param {!Object.<string, number>} periodDurationMap
  38.    * @return {shaka.dash.DashParser.StreamInfo}
  39.    */
  40.   static createStreamInfo(
  41.       context, requestInitSegment, segmentIndexMap, isUpdate,
  42.       segmentLimit, periodDurationMap) {
  43.     goog.asserts.assert(context.representation.segmentTemplate,
  44.         'Should only be called with SegmentTemplate');
  45.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  47.     const initSegmentReference = SegmentTemplate.createInitSegment_(context);
  48.     const info = SegmentTemplate.parseSegmentTemplateInfo_(context);
  50.     SegmentTemplate.checkSegmentTemplateInfo_(context, info);
  52.     // Direct fields of context will be reassigned by the parser before
  53.     // generateSegmentIndex is called.  So we must make a shallow copy first,
  54.     // and use that in the generateSegmentIndex callbacks.
  55.     const shallowCopyOfContext =
  56.         shaka.util.ObjectUtils.shallowCloneObject(context);
  58.     if (info.indexTemplate) {
  59.       shaka.dash.SegmentBase.checkSegmentIndexSupport(
  60.           context, initSegmentReference);
  62.       return {
  63.         generateSegmentIndex: () => {
  64.           return SegmentTemplate.generateSegmentIndexFromIndexTemplate_(
  65.               shallowCopyOfContext, requestInitSegment, initSegmentReference,
  66.               info);
  67.         },
  68.       };
  69.     } else if (info.segmentDuration) {
  70.       if (!isUpdate && context.adaptationSet.contentType !== 'image') {
  71.         context.presentationTimeline.notifyMaxSegmentDuration(
  72.             info.segmentDuration);
  73.         context.presentationTimeline.notifyMinSegmentStartTime(
  74.             context.periodInfo.start);
  75.       }
  77.       return {
  78.         generateSegmentIndex: () => {
  79.           return SegmentTemplate.generateSegmentIndexFromDuration_(
  80.               shallowCopyOfContext, info, segmentLimit, initSegmentReference,
  81.               periodDurationMap);
  82.         },
  83.       };
  84.     } else {
  85.       /** @type {shaka.media.SegmentIndex} */
  86.       let segmentIndex = null;
  87.       let id = null;
  88.       if (context.period.id && context.representation.id) {
  89.         // Only check/store the index if period and representation IDs are set.
  90.         id = context.period.id + ',' + context.representation.id;
  91.         segmentIndex = segmentIndexMap[id];
  92.       }
  94.       const references = SegmentTemplate.createFromTimeline_(
  95.           shallowCopyOfContext, info, initSegmentReference);
  97.       const periodStart = context.periodInfo.start;
  98.       const periodEnd = context.periodInfo.duration ?
  99.           context.periodInfo.start + context.periodInfo.duration : Infinity;
  101.       /* When to fit segments.  All refactors should honor/update this table:
  102.        *
  103.        * | dynamic | infinite | last   | should | notes                     |
  104.        * |         | period   | period | fit    |                           |
  105.        * | ------- | -------- | ------ | ------ | ------------------------- |
  106.        * |     F   |     F    |    X   |    T   | typical VOD               |
  107.        * |     F   |     T    |    X   |    X   | impossible: infinite VOD  |
  108.        * |     T   |     F    |    F   |    T   | typical live, old period  |
  109.        * |     T   |     F    |    T   |    F   | typical IPR               |
  110.        * |     T   |     T    |    F   |    X   | impossible: old, infinite |
  111.        * |     T   |     T    |    T   |    F   | typical live, new period  |
  112.        */
  114.       // We never fit the final period of dynamic content, which could be
  115.       // infinite live (with no limit to fit to) or IPR (which would expand the
  116.       // most recent segment to the end of the presentation).
  117.       const shouldFit = !(context.dynamic && context.periodInfo.isLastPeriod);
  119.       if (segmentIndex) {
  120.         if (shouldFit) {
  121.           // Fit the new references before merging them, so that the merge
  122.           // algorithm has a more accurate view of their start and end times.
  123.           const wrapper = new shaka.media.SegmentIndex(references);
  124.           wrapper.fit(periodStart, periodEnd, /* isNew= */ true);
  125.         }
  127.         segmentIndex.mergeAndEvict(references,
  128.             context.presentationTimeline.getSegmentAvailabilityStart());
  129.       } else {
  130.         segmentIndex = new shaka.media.SegmentIndex(references);
  131.         if (id && context.dynamic) {
  132.           segmentIndexMap[id] = segmentIndex;
  133.         }
  134.       }
  135.       context.presentationTimeline.notifySegments(references);
  137.       if (shouldFit) {
  138.         segmentIndex.fit(periodStart, periodEnd);
  139.       }
  141.       return {
  142.         generateSegmentIndex: () => Promise.resolve(segmentIndex),
  143.       };
  144.     }
  145.   }
  147.   /**
  148.    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  149.    * @return {Element}
  150.    * @private
  151.    */
  152.   static fromInheritance_(frame) {
  153.     return frame.segmentTemplate;
  154.   }
  156.   /**
  157.    * Parses a SegmentTemplate element into an info object.
  158.    *
  159.    * @param {shaka.dash.DashParser.Context} context
  160.    * @return {shaka.dash.SegmentTemplate.SegmentTemplateInfo}
  161.    * @private
  162.    */
  163.   static parseSegmentTemplateInfo_(context) {
  164.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  165.     const MpdUtils = shaka.dash.MpdUtils;
  166.     const segmentInfo =
  167.         MpdUtils.parseSegmentInfo(context, SegmentTemplate.fromInheritance_);
  169.     const media = MpdUtils.inheritAttribute(
  170.         context, SegmentTemplate.fromInheritance_, 'media');
  171.     const index = MpdUtils.inheritAttribute(
  172.         context, SegmentTemplate.fromInheritance_, 'index');
  174.     return {
  175.       segmentDuration: segmentInfo.segmentDuration,
  176.       timescale: segmentInfo.timescale,
  177.       startNumber: segmentInfo.startNumber,
  178.       scaledPresentationTimeOffset: segmentInfo.scaledPresentationTimeOffset,
  179.       unscaledPresentationTimeOffset:
  180.           segmentInfo.unscaledPresentationTimeOffset,
  181.       timeline: segmentInfo.timeline,
  182.       mediaTemplate: media,
  183.       indexTemplate: index,
  184.     };
  185.   }
  187.   /**
  188.    * Verifies a SegmentTemplate info object.
  189.    *
  190.    * @param {shaka.dash.DashParser.Context} context
  191.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  192.    * @private
  193.    */
  194.   static checkSegmentTemplateInfo_(context, info) {
  195.     let n = 0;
  196.     n += info.indexTemplate ? 1 : 0;
  197.     n += info.timeline ? 1 : 0;
  198.     n += info.segmentDuration ? 1 : 0;
  200.     if (n == 0) {
  201.       shaka.log.error(
  202.           'SegmentTemplate does not contain any segment information:',
  203.           'the SegmentTemplate must contain either an index URL template',
  204.           'a SegmentTimeline, or a segment duration.',
  205.           context.representation);
  206.       throw new shaka.util.Error(
  207.           shaka.util.Error.Severity.CRITICAL,
  208.           shaka.util.Error.Category.MANIFEST,
  209.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  210.     } else if (n != 1) {
  211.       shaka.log.warning(
  212.           'SegmentTemplate containes multiple segment information sources:',
  213.           'the SegmentTemplate should only contain an index URL template,',
  214.           'a SegmentTimeline or a segment duration.',
  215.           context.representation);
  216.       if (info.indexTemplate) {
  217.         shaka.log.info('Using the index URL template by default.');
  218.         info.timeline = null;
  219.         info.segmentDuration = null;
  220.       } else {
  221.         goog.asserts.assert(info.timeline, 'There should be a timeline');
  222.         shaka.log.info('Using the SegmentTimeline by default.');
  223.         info.segmentDuration = null;
  224.       }
  225.     }
  227.     if (!info.indexTemplate && !info.mediaTemplate) {
  228.       shaka.log.error(
  229.           'SegmentTemplate does not contain sufficient segment information:',
  230.           'the SegmentTemplate\'s media URL template is missing.',
  231.           context.representation);
  232.       throw new shaka.util.Error(
  233.           shaka.util.Error.Severity.CRITICAL,
  234.           shaka.util.Error.Category.MANIFEST,
  235.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  236.     }
  237.   }
  239.   /**
  240.    * Generates a SegmentIndex from an index URL template.
  241.    *
  242.    * @param {shaka.dash.DashParser.Context} context
  243.    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
  244.    *     requestInitSegment
  245.    * @param {shaka.media.InitSegmentReference} init
  246.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  247.    * @return {!Promise.<shaka.media.SegmentIndex>}
  248.    * @private
  249.    */
  250.   static generateSegmentIndexFromIndexTemplate_(
  251.       context, requestInitSegment, init, info) {
  252.     const MpdUtils = shaka.dash.MpdUtils;
  253.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  255.     goog.asserts.assert(info.indexTemplate, 'must be using index template');
  256.     const filledTemplate = MpdUtils.fillUriTemplate(
  257.         info.indexTemplate, context.representation.id,
  258.         null, context.bandwidth || null, null);
  260.     const resolvedUris = ManifestParserUtils.resolveUris(
  261.         context.representation.baseUris, [filledTemplate]);
  263.     return shaka.dash.SegmentBase.generateSegmentIndexFromUris(
  264.         context, requestInitSegment, init, resolvedUris, 0, null,
  265.         info.scaledPresentationTimeOffset);
  266.   }
  268.   /**
  269.    * Generates a SegmentIndex from fixed-duration segments.
  270.    *
  271.    * @param {shaka.dash.DashParser.Context} context
  272.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  273.    * @param {number} segmentLimit The maximum number of segments to generate.
  274.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  275.    * @param {!Object.<string, number>} periodDurationMap
  276.    * @return {!Promise.<shaka.media.SegmentIndex>}
  277.    * @private
  278.    */
  279.   static generateSegmentIndexFromDuration_(
  280.       context, info, segmentLimit, initSegmentReference, periodDurationMap) {
  281.     goog.asserts.assert(info.mediaTemplate,
  282.         'There should be a media template with duration');
  284.     const MpdUtils = shaka.dash.MpdUtils;
  285.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  287.     const presentationTimeline = context.presentationTimeline;
  289.     // Capture values that could change as the parsing context moves on to
  290.     // other parts of the manifest.
  291.     const periodStart = context.periodInfo.start;
  292.     const periodId = context.period.id;
  293.     const initialPeriodDuration = context.periodInfo.duration;
  295.     // For multi-period live streams the period duration may not be known until
  296.     // the following period appears in an updated manifest. periodDurationMap
  297.     // provides the updated period duration.
  298.     const getPeriodEnd = () => {
  299.       const periodDuration =
  300.         (periodId != null && periodDurationMap[periodId]) ||
  301.         initialPeriodDuration;
  302.       const periodEnd = periodDuration ?
  303.         (periodStart + periodDuration) : Infinity;
  304.       return periodEnd;
  305.     };
  307.     const segmentDuration = info.segmentDuration;
  308.     goog.asserts.assert(
  309.         segmentDuration != null, 'Segment duration must not be null!');
  311.     const startNumber = info.startNumber;
  312.     const timescale = info.timescale;
  314.     const template = info.mediaTemplate;
  315.     const bandwidth = context.bandwidth || null;
  316.     const id = context.representation.id;
  317.     const baseUris = context.representation.baseUris;
  319.     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
  321.     // Computes the range of presentation timestamps both within the period and
  322.     // available.  This is an intersection of the period range and the
  323.     // availability window.
  324.     const computeAvailablePeriodRange = () => {
  325.       return [
  326.         Math.max(
  327.             presentationTimeline.getSegmentAvailabilityStart(),
  328.             periodStart),
  330.         Math.min(
  331.             presentationTimeline.getSegmentAvailabilityEnd(),
  332.             getPeriodEnd()),
  333.       ];
  334.     };
  336.     // Computes the range of absolute positions both within the period and
  337.     // available.  The range is inclusive.  These are the positions for which we
  338.     // will generate segment references.
  339.     const computeAvailablePositionRange = () => {
  340.       // In presentation timestamps.
  341.       const availablePresentationTimes = computeAvailablePeriodRange();
  342.       goog.asserts.assert(availablePresentationTimes.every(isFinite),
  343.           'Available presentation times must be finite!');
  344.       goog.asserts.assert(availablePresentationTimes.every((x) => x >= 0),
  345.           'Available presentation times must be positive!');
  346.       goog.asserts.assert(segmentDuration != null,
  347.           'Segment duration must not be null!');
  349.       // In period-relative timestamps.
  350.       const availablePeriodTimes =
  351.           availablePresentationTimes.map((x) => x - periodStart);
  352.       // These may sometimes be reversed ([1] <= [0]) if the period is
  353.       // completely unavailable.  The logic will still work if this happens,
  354.       // because we will simply generate no references.
  356.       // In period-relative positions (0-based).
  357.       const availablePeriodPositions = [
  358.         Math.ceil(availablePeriodTimes[0] / segmentDuration),
  359.         Math.ceil(availablePeriodTimes[1] / segmentDuration) - 1,
  360.       ];
  362.       // In absolute positions.
  363.       const availablePresentationPositions =
  364.           availablePeriodPositions.map((x) => x + startNumber);
  365.       return availablePresentationPositions;
  366.     };
  368.     // For Live, we must limit the initial SegmentIndex in size, to avoid
  369.     // consuming too much CPU or memory for content with gigantic
  370.     // timeShiftBufferDepth (which can have values up to and including
  371.     // Infinity).
  372.     const range = computeAvailablePositionRange();
  373.     const minPosition = context.dynamic ?
  374.         Math.max(range[0], range[1] - segmentLimit + 1) :
  375.         range[0];
  376.     const maxPosition = range[1];
  378.     const references = [];
  379.     const createReference = (position) => {
  380.       // These inner variables are all scoped to the inner loop, and can be used
  381.       // safely in the callback below.
  383.       goog.asserts.assert(segmentDuration != null,
  384.           'Segment duration must not be null!');
  386.       // Relative to the period start.
  387.       const positionWithinPeriod = position - startNumber;
  388.       const segmentPeriodTime = positionWithinPeriod * segmentDuration;
  390.       // What will appear in the actual segment files.  The media timestamp is
  391.       // what is expected in the $Time$ template.
  392.       const segmentMediaTime = segmentPeriodTime +
  393.           info.scaledPresentationTimeOffset;
  395.       const getUris = () => {
  396.         const mediaUri = MpdUtils.fillUriTemplate(
  397.             template, id, position, bandwidth,
  398.             segmentMediaTime * timescale);
  399.         return ManifestParserUtils.resolveUris(baseUris, [mediaUri]);
  400.       };
  402.       // Relative to the presentation.
  403.       const segmentStart = segmentPeriodTime + periodStart;
  404.       const trueSegmentEnd = segmentStart + segmentDuration;
  405.       // Cap the segment end at the period end so that references from the
  406.       // next period will fit neatly after it.
  407.       const segmentEnd = Math.min(trueSegmentEnd, getPeriodEnd());
  409.       // This condition will be true unless the segmentStart was >= periodEnd.
  410.       // If we've done the position calculations correctly, this won't happen.
  411.       goog.asserts.assert(segmentStart < segmentEnd,
  412.           'Generated a segment outside of the period!');
  414.       const ref = new shaka.media.SegmentReference(
  415.           segmentStart,
  416.           segmentEnd,
  417.           getUris,
  418.           /* startByte= */ 0,
  419.           /* endByte= */ null,
  420.           initSegmentReference,
  421.           timestampOffset,
  422.           /* appendWindowStart= */ periodStart,
  423.           /* appendWindowEnd= */ getPeriodEnd());
  424.       // This is necessary information for thumbnail streams:
  425.       ref.trueEndTime = trueSegmentEnd;
  426.       return ref;
  427.     };
  429.     for (let position = minPosition; position <= maxPosition; ++position) {
  430.       const reference = createReference(position);
  431.       references.push(reference);
  432.     }
  434.     /** @type {shaka.media.SegmentIndex} */
  435.     const segmentIndex = new shaka.media.SegmentIndex(references);
  437.     // If the availability timeline currently ends before the period, we will
  438.     // need to add references over time.
  439.     const willNeedToAddReferences =
  440.         presentationTimeline.getSegmentAvailabilityEnd() < getPeriodEnd();
  442.     // When we start a live stream with a period that ends within the
  443.     // availability window we will not need to add more references, but we will
  444.     // need to evict old references.
  445.     const willNeedToEvictReferences = presentationTimeline.isLive();
  447.     if (willNeedToAddReferences || willNeedToEvictReferences) {
  448.       // The period continues to get longer over time, so check for new
  449.       // references once every |segmentDuration| seconds.
  450.       // We clamp to |minPosition| in case the initial range was reversed and no
  451.       // references were generated.  Otherwise, the update would start creating
  452.       // negative positions for segments in periods which begin in the future.
  453.       let nextPosition = Math.max(minPosition, maxPosition + 1);
  454.       segmentIndex.updateEvery(segmentDuration, () => {
  455.         // Evict any references outside the window.
  456.         const availabilityStartTime =
  457.           presentationTimeline.getSegmentAvailabilityStart();
  458.         segmentIndex.evict(availabilityStartTime);
  460.         // Compute any new references that need to be added.
  461.         const [_, maxPosition] = computeAvailablePositionRange();
  462.         const references = [];
  463.         while (nextPosition <= maxPosition) {
  464.           const reference = createReference(nextPosition);
  465.           references.push(reference);
  466.           nextPosition++;
  467.         }
  469.         // The timer must continue firing until the entire period is
  470.         // unavailable, so that all references will be evicted.
  471.         if (availabilityStartTime > getPeriodEnd() && !references.length) {
  472.           // Signal stop.
  473.           return null;
  474.         }
  475.         return references;
  476.       });
  477.     }
  479.     return Promise.resolve(segmentIndex);
  480.   }
  482.   /**
  483.    * Creates segment references from a timeline.
  484.    *
  485.    * @param {shaka.dash.DashParser.Context} context
  486.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  487.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  488.    * @return {!Array.<!shaka.media.SegmentReference>}
  489.    * @private
  490.    */
  491.   static createFromTimeline_(context, info, initSegmentReference) {
  492.     const MpdUtils = shaka.dash.MpdUtils;
  493.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  495.     const periodStart = context.periodInfo.start;
  496.     const periodDuration = context.periodInfo.duration;
  498.     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
  499.     const appendWindowStart = periodStart;
  500.     const appendWindowEnd = periodDuration ?
  501.         periodStart + periodDuration : Infinity;
  503.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  504.     const references = [];
  505.     for (let i = 0; i < info.timeline.length; i++) {
  506.       const {start, unscaledStart, end} = info.timeline[i];
  508.       // Note: i = k - 1, where k indicates the k'th segment listed in the MPD.
  509.       // (See section 5.3.9.5.3 of the DASH spec.)
  510.       const segmentReplacement = i + info.startNumber;
  512.       // Consider the presentation time offset in segment uri computation
  513.       const timeReplacement = unscaledStart +
  514.           info.unscaledPresentationTimeOffset;
  515.       const repId = context.representation.id;
  516.       const bandwidth = context.bandwidth || null;
  517.       const mediaTemplate = info.mediaTemplate;
  518.       const baseUris = context.representation.baseUris;
  520.       // This callback must not capture any non-local
  521.       // variables, such as info, context, etc.  Make
  522.       // sure any values you reference here have
  523.       // been assigned to local variables within the
  524.       // loop, or else we will end up with a leak.
  525.       const createUris =
  526.           () => {
  527.             goog.asserts.assert(
  528.                 mediaTemplate,
  529.                 'There should be a media template with a timeline');
  530.             const mediaUri = MpdUtils.fillUriTemplate(
  531.                 mediaTemplate, repId,
  532.                 segmentReplacement, bandwidth || null, timeReplacement);
  533.             return ManifestParserUtils
  534.                 .resolveUris(baseUris, [mediaUri])
  535.                 .map((g) => {
  536.                   return g.toString();
  537.                 });
  538.           };
  540.       references.push(new shaka.media.SegmentReference(
  541.           periodStart + start,
  542.           periodStart + end,
  543.           createUris,
  544.           /* startByte= */ 0,
  545.           /* endByte= */ null,
  546.           initSegmentReference,
  547.           timestampOffset,
  548.           appendWindowStart,
  549.           appendWindowEnd));
  550.     }
  552.     return references;
  553.   }
  555.   /**
  556.    * Creates an init segment reference from a context object.
  557.    *
  558.    * @param {shaka.dash.DashParser.Context} context
  559.    * @return {shaka.media.InitSegmentReference}
  560.    * @private
  561.    */
  562.   static createInitSegment_(context) {
  563.     const MpdUtils = shaka.dash.MpdUtils;
  564.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  565.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  567.     const initialization = MpdUtils.inheritAttribute(
  568.         context, SegmentTemplate.fromInheritance_, 'initialization');
  569.     if (!initialization) {
  570.       return null;
  571.     }
  573.     const repId = context.representation.id;
  574.     const bandwidth = context.bandwidth || null;
  575.     const baseUris = context.representation.baseUris;
  576.     const getUris = () => {
  577.       goog.asserts.assert(initialization, 'Should have returned earler');
  578.       const filledTemplate = MpdUtils.fillUriTemplate(
  579.           initialization, repId, null, bandwidth, null);
  580.       const resolvedUris = ManifestParserUtils.resolveUris(
  581.           baseUris, [filledTemplate]);
  582.       return resolvedUris;
  583.     };
  585.     return new shaka.media.InitSegmentReference(getUris, 0, null);
  586.   }
  587. };
  589. /**
  590.  * @typedef {{
  591.  *   timescale: number,
  592.  *   segmentDuration: ?number,
  593.  *   startNumber: number,
  594.  *   scaledPresentationTimeOffset: number,
  595.  *   unscaledPresentationTimeOffset: number,
  596.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
  597.  *   mediaTemplate: ?string,
  598.  *   indexTemplate: ?string
  599.  * }}
  600.  * @private
  601.  *
  602.  * @description
  603.  * Contains information about a SegmentTemplate.
  604.  *
  605.  * @property {number} timescale
  606.  *   The time-scale of the representation.
  607.  * @property {?number} segmentDuration
  608.  *   The duration of the segments in seconds, if given.
  609.  * @property {number} startNumber
  610.  *   The start number of the segments; 1 or greater.
  611.  * @property {number} scaledPresentationTimeOffset
  612.  *   The presentation time offset of the representation, in seconds.
  613.  * @property {number} unscaledPresentationTimeOffset
  614.  *   The presentation time offset of the representation, in timescale units.
  615.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  616.  *   The timeline of the representation, if given.  Times in seconds.
  617.  * @property {?string} mediaTemplate
  618.  *   The media URI template, if given.
  619.  * @property {?string} indexTemplate
  620.  *   The index URI template, if given.
  621.  */
  622. shaka.dash.SegmentTemplate.SegmentTemplateInfo;