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