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.extern.Stream>} streamMap
  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, streamMap, isUpdate, segmentLimit,
  42.       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) {
  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.       let stream = null;
  89.       if (context.period.id && context.representation.id) {
  90.         // Only check/store the index if period and representation IDs are set.
  91.         id = context.period.id + ',' + context.representation.id;
  92.         stream = streamMap[id];
  93.         if (stream) {
  94.           segmentIndex = stream.segmentIndex;
  95.         }
  96.       }
  98.       const references = SegmentTemplate.createFromTimeline_(
  99.           shallowCopyOfContext, info, initSegmentReference);
  101.       const periodStart = context.periodInfo.start;
  102.       const periodEnd = context.periodInfo.duration ?
  103.           context.periodInfo.start + context.periodInfo.duration : Infinity;
  105.       // Don't fit live content, since it might receive more segments.
  106.       // Unless that live content is multi-period; it's safe to fit every period
  107.       // but the last one, since only the last period might receive new
  108.       // segments.
  109.       const shouldFit = periodEnd != Infinity;
  111.       if (segmentIndex) {
  112.         if (shouldFit) {
  113.           // Fit the new references before merging them, so that the merge
  114.           // algorithm has a more accurate view of their start and end times.
  115.           const wrapper = new shaka.media.SegmentIndex(references);
  116.           wrapper.fit(periodStart, periodEnd, /* isNew= */ true);
  117.         }
  119.         segmentIndex.mergeAndEvict(references,
  120.             context.presentationTimeline.getSegmentAvailabilityStart());
  121.       } else {
  122.         segmentIndex = new shaka.media.SegmentIndex(references);
  123.       }
  124.       context.presentationTimeline.notifySegments(references);
  126.       if (shouldFit) {
  127.         segmentIndex.fit(periodStart, periodEnd);
  128.       }
  130.       if (stream && context.dynamic) {
  131.         stream.segmentIndex = segmentIndex;
  132.       }
  134.       return {
  135.         generateSegmentIndex: () => {
  136.           // If segmentIndex is deleted, or segmentIndex's references are
  137.           // released by closeSegmentIndex(), we should set the value of
  138.           // segmentIndex again.
  139.           if (!segmentIndex || segmentIndex.isEmpty()) {
  140.             segmentIndex.merge(references);
  141.           }
  142.           return Promise.resolve(segmentIndex);
  143.         },
  144.       };
  145.     }
  146.   }
  148.   /**
  149.    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  150.    * @return {Element}
  151.    * @private
  152.    */
  153.   static fromInheritance_(frame) {
  154.     return frame.segmentTemplate;
  155.   }
  157.   /**
  158.    * Parses a SegmentTemplate element into an info object.
  159.    *
  160.    * @param {shaka.dash.DashParser.Context} context
  161.    * @return {shaka.dash.SegmentTemplate.SegmentTemplateInfo}
  162.    * @private
  163.    */
  164.   static parseSegmentTemplateInfo_(context) {
  165.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  166.     const MpdUtils = shaka.dash.MpdUtils;
  167.     const segmentInfo =
  168.         MpdUtils.parseSegmentInfo(context, SegmentTemplate.fromInheritance_);
  170.     const media = MpdUtils.inheritAttribute(
  171.         context, SegmentTemplate.fromInheritance_, 'media');
  172.     const index = MpdUtils.inheritAttribute(
  173.         context, SegmentTemplate.fromInheritance_, 'index');
  175.     return {
  176.       segmentDuration: segmentInfo.segmentDuration,
  177.       timescale: segmentInfo.timescale,
  178.       startNumber: segmentInfo.startNumber,
  179.       scaledPresentationTimeOffset: segmentInfo.scaledPresentationTimeOffset,
  180.       unscaledPresentationTimeOffset:
  181.           segmentInfo.unscaledPresentationTimeOffset,
  182.       timeline: segmentInfo.timeline,
  183.       mediaTemplate: media,
  184.       indexTemplate: index,
  185.     };
  186.   }
  188.   /**
  189.    * Verifies a SegmentTemplate info object.
  190.    *
  191.    * @param {shaka.dash.DashParser.Context} context
  192.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  193.    * @private
  194.    */
  195.   static checkSegmentTemplateInfo_(context, info) {
  196.     let n = 0;
  197.     n += info.indexTemplate ? 1 : 0;
  198.     n += info.timeline ? 1 : 0;
  199.     n += info.segmentDuration ? 1 : 0;
  201.     if (n == 0) {
  202.       shaka.log.error(
  203.           'SegmentTemplate does not contain any segment information:',
  204.           'the SegmentTemplate must contain either an index URL template',
  205.           'a SegmentTimeline, or a segment duration.',
  206.           context.representation);
  207.       throw new shaka.util.Error(
  208.           shaka.util.Error.Severity.CRITICAL,
  209.           shaka.util.Error.Category.MANIFEST,
  210.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  211.     } else if (n != 1) {
  212.       shaka.log.warning(
  213.           'SegmentTemplate containes multiple segment information sources:',
  214.           'the SegmentTemplate should only contain an index URL template,',
  215.           'a SegmentTimeline or a segment duration.',
  216.           context.representation);
  217.       if (info.indexTemplate) {
  218.         shaka.log.info('Using the index URL template by default.');
  219.         info.timeline = null;
  220.         info.segmentDuration = null;
  221.       } else {
  222.         goog.asserts.assert(info.timeline, 'There should be a timeline');
  223.         shaka.log.info('Using the SegmentTimeline by default.');
  224.         info.segmentDuration = null;
  225.       }
  226.     }
  228.     if (!info.indexTemplate && !info.mediaTemplate) {
  229.       shaka.log.error(
  230.           'SegmentTemplate does not contain sufficient segment information:',
  231.           'the SegmentTemplate\'s media URL template is missing.',
  232.           context.representation);
  233.       throw new shaka.util.Error(
  234.           shaka.util.Error.Severity.CRITICAL,
  235.           shaka.util.Error.Category.MANIFEST,
  236.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  237.     }
  238.   }
  240.   /**
  241.    * Generates a SegmentIndex from an index URL template.
  242.    *
  243.    * @param {shaka.dash.DashParser.Context} context
  244.    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
  245.    *     requestInitSegment
  246.    * @param {shaka.media.InitSegmentReference} init
  247.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  248.    * @return {!Promise.<shaka.media.SegmentIndex>}
  249.    * @private
  250.    */
  251.   static generateSegmentIndexFromIndexTemplate_(
  252.       context, requestInitSegment, init, info) {
  253.     const MpdUtils = shaka.dash.MpdUtils;
  254.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  256.     goog.asserts.assert(info.indexTemplate, 'must be using index template');
  257.     const filledTemplate = MpdUtils.fillUriTemplate(
  258.         info.indexTemplate, context.representation.id,
  259.         null, context.bandwidth || null, null);
  261.     const resolvedUris = ManifestParserUtils.resolveUris(
  262.         context.representation.baseUris, [filledTemplate]);
  264.     return shaka.dash.SegmentBase.generateSegmentIndexFromUris(
  265.         context, requestInitSegment, init, resolvedUris, 0, null,
  266.         info.scaledPresentationTimeOffset);
  267.   }
  269.   /**
  270.    * Generates a SegmentIndex from fixed-duration segments.
  271.    *
  272.    * @param {shaka.dash.DashParser.Context} context
  273.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  274.    * @param {number} segmentLimit The maximum number of segments to generate.
  275.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  276.    * @param {!Object.<string, number>} periodDurationMap
  277.    * @return {!Promise.<shaka.media.SegmentIndex>}
  278.    * @private
  279.    */
  280.   static generateSegmentIndexFromDuration_(
  281.       context, info, segmentLimit, initSegmentReference, periodDurationMap) {
  282.     goog.asserts.assert(info.mediaTemplate,
  283.         'There should be a media template with duration');
  285.     const MpdUtils = shaka.dash.MpdUtils;
  286.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  288.     const presentationTimeline = context.presentationTimeline;
  290.     // Capture values that could change as the parsing context moves on to
  291.     // other parts of the manifest.
  292.     const periodStart = context.periodInfo.start;
  293.     const periodId = context.period.id;
  294.     const initialPeriodDuration = context.periodInfo.duration;
  296.     // For multi-period live streams the period duration may not be known until
  297.     // the following period appears in an updated manifest. periodDurationMap
  298.     // provides the updated period duration.
  299.     const getPeriodEnd = () => {
  300.       const periodDuration =
  301.         (periodId != null && periodDurationMap[periodId]) ||
  302.         initialPeriodDuration;
  303.       const periodEnd = periodDuration ?
  304.         (periodStart + periodDuration) : Infinity;
  305.       return periodEnd;
  306.     };
  308.     const segmentDuration = info.segmentDuration;
  309.     goog.asserts.assert(
  310.         segmentDuration != null, 'Segment duration must not be null!');
  312.     const startNumber = info.startNumber;
  313.     const timescale = info.timescale;
  315.     const template = info.mediaTemplate;
  316.     const bandwidth = context.bandwidth || null;
  317.     const id = context.representation.id;
  318.     const baseUris = context.representation.baseUris;
  320.     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
  322.     // Computes the range of presentation timestamps both within the period and
  323.     // available.  This is an intersection of the period range and the
  324.     // availability window.
  325.     const computeAvailablePeriodRange = () => {
  326.       return [
  327.         Math.max(
  328.             presentationTimeline.getSegmentAvailabilityStart(),
  329.             periodStart),
  331.         Math.min(
  332.             presentationTimeline.getSegmentAvailabilityEnd(),
  333.             getPeriodEnd()),
  334.       ];
  335.     };
  337.     // Computes the range of absolute positions both within the period and
  338.     // available.  The range is inclusive.  These are the positions for which we
  339.     // will generate segment references.
  340.     const computeAvailablePositionRange = () => {
  341.       // In presentation timestamps.
  342.       const availablePresentationTimes = computeAvailablePeriodRange();
  343.       goog.asserts.assert(availablePresentationTimes.every(isFinite),
  344.           'Available presentation times must be finite!');
  345.       goog.asserts.assert(availablePresentationTimes.every((x) => x >= 0),
  346.           'Available presentation times must be positive!');
  347.       goog.asserts.assert(segmentDuration != null,
  348.           'Segment duration must not be null!');
  350.       // In period-relative timestamps.
  351.       const availablePeriodTimes =
  352.           availablePresentationTimes.map((x) => x - periodStart);
  353.       // These may sometimes be reversed ([1] <= [0]) if the period is
  354.       // completely unavailable.  The logic will still work if this happens,
  355.       // because we will simply generate no references.
  357.       // In period-relative positions (0-based).
  358.       const availablePeriodPositions = [
  359.         Math.ceil(availablePeriodTimes[0] / segmentDuration),
  360.         Math.ceil(availablePeriodTimes[1] / segmentDuration) - 1,
  361.       ];
  363.       // In absolute positions.
  364.       const availablePresentationPositions =
  365.           availablePeriodPositions.map((x) => x + startNumber);
  366.       return availablePresentationPositions;
  367.     };
  369.     // For Live, we must limit the initial SegmentIndex in size, to avoid
  370.     // consuming too much CPU or memory for content with gigantic
  371.     // timeShiftBufferDepth (which can have values up to and including
  372.     // Infinity).
  373.     const range = computeAvailablePositionRange();
  374.     const minPosition = context.dynamic ?
  375.         Math.max(range[0], range[1] - segmentLimit + 1) :
  376.         range[0];
  377.     const maxPosition = range[1];
  379.     const references = [];
  380.     const createReference = (position) => {
  381.       // These inner variables are all scoped to the inner loop, and can be used
  382.       // safely in the callback below.
  384.       goog.asserts.assert(segmentDuration != null,
  385.           'Segment duration must not be null!');
  387.       // Relative to the period start.
  388.       const positionWithinPeriod = position - startNumber;
  389.       const segmentPeriodTime = positionWithinPeriod * segmentDuration;
  391.       // What will appear in the actual segment files.  The media timestamp is
  392.       // what is expected in the $Time$ template.
  393.       const segmentMediaTime = segmentPeriodTime +
  394.           info.scaledPresentationTimeOffset;
  396.       const getUris = () => {
  397.         const mediaUri = MpdUtils.fillUriTemplate(
  398.             template, id, position, bandwidth,
  399.             segmentMediaTime * timescale);
  400.         return ManifestParserUtils.resolveUris(baseUris, [mediaUri]);
  401.       };
  403.       // Relative to the presentation.
  404.       const segmentStart = segmentPeriodTime + periodStart;
  405.       const trueSegmentEnd = segmentStart + segmentDuration;
  406.       // Cap the segment end at the period end so that references from the
  407.       // next period will fit neatly after it.
  408.       const segmentEnd = Math.min(trueSegmentEnd, getPeriodEnd());
  410.       // This condition will be true unless the segmentStart was >= periodEnd.
  411.       // If we've done the position calculations correctly, this won't happen.
  412.       goog.asserts.assert(segmentStart < segmentEnd,
  413.           'Generated a segment outside of the period!');
  415.       const ref = new shaka.media.SegmentReference(
  416.           segmentStart,
  417.           segmentEnd,
  418.           getUris,
  419.           /* startByte= */ 0,
  420.           /* endByte= */ null,
  421.           initSegmentReference,
  422.           timestampOffset,
  423.           /* appendWindowStart= */ periodStart,
  424.           /* appendWindowEnd= */ getPeriodEnd());
  425.       // This is necessary information for thumbnail streams:
  426.       ref.trueEndTime = trueSegmentEnd;
  427.       return ref;
  428.     };
  430.     for (let position = minPosition; position <= maxPosition; ++position) {
  431.       const reference = createReference(position);
  432.       references.push(reference);
  433.     }
  435.     /** @type {shaka.media.SegmentIndex} */
  436.     const segmentIndex = new shaka.media.SegmentIndex(references);
  438.     // If the availability timeline currently ends before the period, we will
  439.     // need to add references over time.
  440.     const willNeedToAddReferences =
  441.         presentationTimeline.getSegmentAvailabilityEnd() < getPeriodEnd();
  443.     // When we start a live stream with a period that ends within the
  444.     // availability window we will not need to add more references, but we will
  445.     // need to evict old references.
  446.     const willNeedToEvictReferences = presentationTimeline.isLive();
  448.     if (willNeedToAddReferences || willNeedToEvictReferences) {
  449.       // The period continues to get longer over time, so check for new
  450.       // references once every |segmentDuration| seconds.
  451.       // We clamp to |minPosition| in case the initial range was reversed and no
  452.       // references were generated.  Otherwise, the update would start creating
  453.       // negative positions for segments in periods which begin in the future.
  454.       let nextPosition = Math.max(minPosition, maxPosition + 1);
  455.       segmentIndex.updateEvery(segmentDuration, () => {
  456.         // Evict any references outside the window.
  457.         const availabilityStartTime =
  458.           presentationTimeline.getSegmentAvailabilityStart();
  459.         segmentIndex.evict(availabilityStartTime);
  461.         // Compute any new references that need to be added.
  462.         const [_, maxPosition] = computeAvailablePositionRange();
  463.         const references = [];
  464.         while (nextPosition <= maxPosition) {
  465.           const reference = createReference(nextPosition);
  466.           references.push(reference);
  467.           nextPosition++;
  468.         }
  470.         // The timer must continue firing until the entire period is
  471.         // unavailable, so that all references will be evicted.
  472.         if (availabilityStartTime > getPeriodEnd() && !references.length) {
  473.           // Signal stop.
  474.           return null;
  475.         }
  476.         return references;
  477.       });
  478.     }
  480.     return Promise.resolve(segmentIndex);
  481.   }
  483.   /**
  484.    * Creates segment references from a timeline.
  485.    *
  486.    * @param {shaka.dash.DashParser.Context} context
  487.    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
  488.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  489.    * @return {!Array.<!shaka.media.SegmentReference>}
  490.    * @private
  491.    */
  492.   static createFromTimeline_(context, info, initSegmentReference) {
  493.     const MpdUtils = shaka.dash.MpdUtils;
  494.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  496.     const periodStart = context.periodInfo.start;
  497.     const periodDuration = context.periodInfo.duration;
  499.     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
  500.     const appendWindowStart = periodStart;
  501.     const appendWindowEnd = periodDuration ?
  502.         periodStart + periodDuration : Infinity;
  504.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  505.     const references = [];
  506.     for (let i = 0; i < info.timeline.length; i++) {
  507.       const {start, unscaledStart, end} = info.timeline[i];
  509.       // Note: i = k - 1, where k indicates the k'th segment listed in the MPD.
  510.       // (See section 5.3.9.5.3 of the DASH spec.)
  511.       const segmentReplacement = i + info.startNumber;
  513.       // Consider the presentation time offset in segment uri computation
  514.       const timeReplacement = unscaledStart +
  515.           info.unscaledPresentationTimeOffset;
  516.       const repId = context.representation.id;
  517.       const bandwidth = context.bandwidth || null;
  518.       const mediaTemplate = info.mediaTemplate;
  519.       const baseUris = context.representation.baseUris;
  521.       // This callback must not capture any non-local
  522.       // variables, such as info, context, etc.  Make
  523.       // sure any values you reference here have
  524.       // been assigned to local variables within the
  525.       // loop, or else we will end up with a leak.
  526.       const createUris =
  527.           () => {
  528.             goog.asserts.assert(
  529.                 mediaTemplate,
  530.                 'There should be a media template with a timeline');
  531.             const mediaUri = MpdUtils.fillUriTemplate(
  532.                 mediaTemplate, repId,
  533.                 segmentReplacement, bandwidth || null, timeReplacement);
  534.             return ManifestParserUtils
  535.                 .resolveUris(baseUris, [mediaUri])
  536.                 .map((g) => {
  537.                   return g.toString();
  538.                 });
  539.           };
  541.       references.push(new shaka.media.SegmentReference(
  542.           periodStart + start,
  543.           periodStart + end,
  544.           createUris,
  545.           /* startByte= */ 0,
  546.           /* endByte= */ null,
  547.           initSegmentReference,
  548.           timestampOffset,
  549.           appendWindowStart,
  550.           appendWindowEnd));
  551.     }
  553.     return references;
  554.   }
  556.   /**
  557.    * Creates an init segment reference from a context object.
  558.    *
  559.    * @param {shaka.dash.DashParser.Context} context
  560.    * @return {shaka.media.InitSegmentReference}
  561.    * @private
  562.    */
  563.   static createInitSegment_(context) {
  564.     const MpdUtils = shaka.dash.MpdUtils;
  565.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  566.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  568.     const initialization = MpdUtils.inheritAttribute(
  569.         context, SegmentTemplate.fromInheritance_, 'initialization');
  570.     if (!initialization) {
  571.       return null;
  572.     }
  574.     const repId = context.representation.id;
  575.     const bandwidth = context.bandwidth || null;
  576.     const baseUris = context.representation.baseUris;
  577.     const getUris = () => {
  578.       goog.asserts.assert(initialization, 'Should have returned earler');
  579.       const filledTemplate = MpdUtils.fillUriTemplate(
  580.           initialization, repId, null, bandwidth, null);
  581.       const resolvedUris = ManifestParserUtils.resolveUris(
  582.           baseUris, [filledTemplate]);
  583.       return resolvedUris;
  584.     };
  585.     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
  586.     return new shaka.media.InitSegmentReference(getUris, 0, null, qualityInfo);
  587.   }
  588. };
  590. /**
  591.  * @typedef {{
  592.  *   timescale: number,
  593.  *   segmentDuration: ?number,
  594.  *   startNumber: number,
  595.  *   scaledPresentationTimeOffset: number,
  596.  *   unscaledPresentationTimeOffset: number,
  597.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
  598.  *   mediaTemplate: ?string,
  599.  *   indexTemplate: ?string
  600.  * }}
  601.  * @private
  602.  *
  603.  * @description
  604.  * Contains information about a SegmentTemplate.
  605.  *
  606.  * @property {number} timescale
  607.  *   The time-scale of the representation.
  608.  * @property {?number} segmentDuration
  609.  *   The duration of the segments in seconds, if given.
  610.  * @property {number} startNumber
  611.  *   The start number of the segments; 1 or greater.
  612.  * @property {number} scaledPresentationTimeOffset
  613.  *   The presentation time offset of the representation, in seconds.
  614.  * @property {number} unscaledPresentationTimeOffset
  615.  *   The presentation time offset of the representation, in timescale units.
  616.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  617.  *   The timeline of the representation, if given.  Times in seconds.
  618.  * @property {?string} mediaTemplate
  619.  *   The media URI template, if given.
  620.  * @property {?string} indexTemplate
  621.  *   The index URI template, if given.
  622.  */
  623. shaka.dash.SegmentTemplate.SegmentTemplateInfo;