shaka-player 4.3.9 → 4.4.0

package/lib/dash/segment_template.js

@@ -14,9 +14,11 @@ goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.Error');
+goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.ObjectUtils');
 goog.requireType('shaka.dash.DashParser');
+goog.requireType('shaka.media.PresentationTimeline');
 
 
 /**
@@ -28,8 +30,7 @@ shaka.dash.SegmentTemplate = class {
    * Updates the existing SegmentIndex, if any.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
-   *   requestInitSegment
+   * @param {shaka.dash.DashParser.RequestSegmentCallback} requestSegment
    * @param {!Object.<string, !shaka.extern.Stream>} streamMap
    * @param {boolean} isUpdate True if the manifest is being updated.
    * @param {number} segmentLimit The maximum number of segments to generate for
@@ -38,13 +39,16 @@ shaka.dash.SegmentTemplate = class {
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
-      context, requestInitSegment, streamMap, isUpdate, segmentLimit,
+      context, requestSegment, streamMap, isUpdate, segmentLimit,
       periodDurationMap) {
     goog.asserts.assert(context.representation.segmentTemplate,
         'Should only be called with SegmentTemplate');
     const SegmentTemplate = shaka.dash.SegmentTemplate;
+    const TimelineSegmentIndex = shaka.dash.TimelineSegmentIndex;
 
     const initSegmentReference = SegmentTemplate.createInitSegment_(context);
+
+    /** @type {shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
     const info = SegmentTemplate.parseSegmentTemplateInfo_(context);
 
     SegmentTemplate.checkSegmentTemplateInfo_(context, info);
@@ -62,7 +66,7 @@ shaka.dash.SegmentTemplate = class {
       return {
         generateSegmentIndex: () => {
           return SegmentTemplate.generateSegmentIndexFromIndexTemplate_(
-              shallowCopyOfContext, requestInitSegment, initSegmentReference,
+              shallowCopyOfContext, requestSegment, initSegmentReference,
               info);
         },
       };
@@ -95,12 +99,11 @@ shaka.dash.SegmentTemplate = class {
         }
       }
 
-      const references = SegmentTemplate.createFromTimeline_(
-          shallowCopyOfContext, info, initSegmentReference);
-
       const periodStart = context.periodInfo.start;
-      const periodEnd = context.periodInfo.duration ?
-          context.periodInfo.start + context.periodInfo.duration : Infinity;
+      const periodEnd = context.periodInfo.duration ? periodStart +
+        context.periodInfo.duration : Infinity;
+
+      shaka.log.debug(`New manifest ${periodStart} - ${periodEnd}`);
 
       /* When to fit segments.  All refactors should honor/update this table:
        *
@@ -120,23 +123,32 @@ shaka.dash.SegmentTemplate = class {
       // most recent segment to the end of the presentation).
       const shouldFit = !(context.dynamic && context.periodInfo.isLastPeriod);
 
-      if (segmentIndex) {
-        if (shouldFit) {
-          // Fit the new references before merging them, so that the merge
-          // algorithm has a more accurate view of their start and end times.
-          const wrapper = new shaka.media.SegmentIndex(references);
-          wrapper.fit(periodStart, periodEnd, /* isNew= */ true);
-        }
-
-        segmentIndex.mergeAndEvict(references,
-            context.presentationTimeline.getSegmentAvailabilityStart());
+      if (!segmentIndex) {
+        shaka.log.debug(`Creating TSI with end ${periodEnd}`);
+        segmentIndex = new TimelineSegmentIndex(
+            info,
+            context.representation.id,
+            context.bandwidth,
+            context.representation.baseUris,
+            periodStart,
+            periodEnd,
+            initSegmentReference,
+            shouldFit,
+        );
       } else {
-        segmentIndex = new shaka.media.SegmentIndex(references);
+        const tsi = /** @type {!TimelineSegmentIndex} */(segmentIndex);
+        tsi.appendTemplateInfo(info, periodStart, periodEnd, shouldFit);
+
+        const availabilityStart =
+          context.presentationTimeline.getSegmentAvailabilityStart();
+        tsi.evict(availabilityStart);
       }
-      context.presentationTimeline.notifySegments(references);
 
-      if (shouldFit) {
-        segmentIndex.fit(periodStart, periodEnd);
+      if (info.timeline && context.adaptationSet.contentType !== 'image') {
+        const timeline = info.timeline;
+        context.presentationTimeline.notifyTimeRange(
+            timeline,
+            periodStart);
       }
 
       if (stream && context.dynamic) {
@@ -148,8 +160,10 @@ shaka.dash.SegmentTemplate = class {
           // If segmentIndex is deleted, or segmentIndex's references are
           // released by closeSegmentIndex(), we should set the value of
           // segmentIndex again.
-          if (!segmentIndex || segmentIndex.isEmpty()) {
-            segmentIndex.merge(references);
+          if (segmentIndex instanceof shaka.dash.TimelineSegmentIndex &&
+              segmentIndex.isEmpty()) {
+            segmentIndex.appendTemplateInfo(info, periodStart,
+                periodEnd, shouldFit);
           }
           return Promise.resolve(segmentIndex);
         },
@@ -253,15 +267,14 @@ shaka.dash.SegmentTemplate = class {
    * Generates a SegmentIndex from an index URL template.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
-   *     requestInitSegment
+   * @param {shaka.dash.DashParser.RequestSegmentCallback} requestSegment
    * @param {shaka.media.InitSegmentReference} init
    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
    * @return {!Promise.<shaka.media.SegmentIndex>}
    * @private
    */
   static generateSegmentIndexFromIndexTemplate_(
-      context, requestInitSegment, init, info) {
+      context, requestSegment, init, info) {
     const MpdUtils = shaka.dash.MpdUtils;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
 
@@ -274,7 +287,7 @@ shaka.dash.SegmentTemplate = class {
         context.representation.baseUris, [filledTemplate]);
 
     return shaka.dash.SegmentBase.generateSegmentIndexFromUris(
-        context, requestInitSegment, init, resolvedUris, 0, null,
+        context, requestSegment, init, resolvedUris, 0, null,
         info.scaledPresentationTimeOffset);
   }
 
@@ -599,6 +612,311 @@ shaka.dash.SegmentTemplate = class {
   }
 };
 
+
+/**
+ * A SegmentIndex that returns segments references on demand from
+ * a segment timeline.
+ *
+ * @extends shaka.media.SegmentIndex
+ * @implements {shaka.util.IReleasable}
+ * @implements {Iterable.<!shaka.media.SegmentReference>}
+ *
+ * @private
+ *
+ */
+shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
+  /**
+   *
+   * @param {!shaka.dash.SegmentTemplate.SegmentTemplateInfo} templateInfo
+   * @param {?string} representationId
+   * @param {number} bandwidth
+   * @param {Array.<string>} baseUris
+   * @param {number} periodStart
+   * @param {number} periodEnd
+   * @param {shaka.media.InitSegmentReference} initSegmentReference
+   * @param {boolean} shouldFit
+   *
+  */
+  constructor(templateInfo, representationId, bandwidth, baseUris,
+      periodStart, periodEnd, initSegmentReference, shouldFit) {
+    super([]);
+
+    /** @private {?shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
+    this.templateInfo_ = templateInfo;
+    /** @private {?string} */
+    this.representationId_ = representationId;
+    /** @private {number} */
+    this.bandwidth_ = bandwidth;
+    /** @private {Array.<string>} */
+    this.baseUris_ = baseUris;
+    /** @private {number} */
+    this.periodStart_ = periodStart;
+    /** @private {number} */
+    this.periodEnd_ = periodEnd;
+    /** @private {shaka.media.InitSegmentReference} */
+    this.initSegmentReference_ = initSegmentReference;
+
+
+    if (shouldFit) {
+      this.fitTimeline();
+    }
+  }
+
+  /**
+   * @override
+   */
+  getNumReferences() {
+    if (this.templateInfo_) {
+      return this.templateInfo_.timeline.length;
+    } else {
+      return 0;
+    }
+  }
+
+  /**
+   * @override
+   */
+  release() {
+    super.release();
+    this.templateInfo_ = null;
+    // We cannot release other fields, as segment index can
+    // be recreated using only template info.
+  }
+
+
+  /**
+   * @override
+   */
+  evict(time) {
+    if (!this.templateInfo_) {
+      return;
+    }
+    shaka.log.debug(`${this.representationId_} Evicting at ${time}`);
+    let numToEvict = 0;
+    const timeline = this.templateInfo_.timeline;
+
+    for (let i = 0; i < timeline.length; i += 1) {
+      const range = timeline[i];
+      const end = range.end + this.periodStart_;
+      const start = range.start + this.periodStart_;
+
+      if (end <= time) {
+        shaka.log.debug(`Evicting ${start} - ${end}`);
+        numToEvict += 1;
+      } else {
+        break;
+      }
+    }
+
+    if (numToEvict > 0) {
+      this.templateInfo_.timeline = timeline.slice(numToEvict);
+      if (this.references.length >= numToEvict) {
+        this.references = this.references.slice(numToEvict);
+      }
+
+      this.numEvicted_ += numToEvict;
+
+      if (this.getNumReferences() === 0) {
+        this.release();
+      }
+    }
+  }
+
+  /**
+   * Merge new template info
+   * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
+   * @param {number} periodStart
+   * @param {number} periodEnd
+   * @param {boolean} shouldFit
+   */
+  appendTemplateInfo(info, periodStart, periodEnd, shouldFit) {
+    if (!this.templateInfo_) {
+      this.templateInfo_ = info;
+      this.periodStart_ = periodStart;
+      this.periodEnd_ = periodEnd;
+    } else {
+      const currentTimeline = this.templateInfo_.timeline;
+
+      // Append timeline
+      const lastCurrentEntry = currentTimeline[currentTimeline.length - 1];
+      const newEntries = info.timeline.filter((entry) => {
+        return entry.start >= lastCurrentEntry.end;
+      });
+
+      if (newEntries.length > 0) {
+        shaka.log.debug(`Appending ${newEntries.length} entries`);
+        this.templateInfo_.timeline.push(...newEntries);
+      }
+
+      if (this.periodEnd_ !== periodEnd) {
+        this.periodEnd_ = periodEnd;
+      }
+    }
+
+    if (shouldFit) {
+      this.fitTimeline();
+    }
+  }
+
+  /**
+   *
+   * @param {number} time
+   */
+  isBeforeFirstEntry(time) {
+    const hasTimeline = this.templateInfo_ &&
+      this.templateInfo_.timeline && this.templateInfo_.timeline.length;
+
+    if (hasTimeline) {
+      const timeline = this.templateInfo_.timeline;
+      return time < timeline[0].start + this.periodStart_;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * Fit timeline entries to period boundaries
+   */
+  fitTimeline() {
+    if (this.getIsImmutable()) {
+      return;
+    }
+    const timeline = this.templateInfo_.timeline;
+    while (timeline.length) {
+      const lastTimePeriod = timeline[timeline.length - 1];
+      if (lastTimePeriod.start >= this.periodEnd_) {
+        timeline.pop();
+      } else {
+        break;
+      }
+    }
+
+    this.evict(this.periodStart_);
+
+    if (timeline.length === 0) {
+      return;
+    }
+
+    if (this.periodEnd_ !== Infinity) {
+      // Adjust the last timeline entry to match the period end
+      const lastTimePeriod = timeline[timeline.length - 1];
+      // NOTE: end should be relative to period start
+      lastTimePeriod.end = this.periodEnd_ - this.periodStart_;
+    }
+  }
+
+  /**
+   * @override
+   */
+  find(time) {
+    shaka.log.debug(`Find ${time}`);
+
+    if (this.isBeforeFirstEntry(time)) {
+      return this.numEvicted_;
+    }
+
+    if (!this.templateInfo_) {
+      return null;
+    }
+
+    const timeline = this.templateInfo_.timeline;
+
+    // Early exit if the time isn't within this period
+    if (time < this.periodStart_ || time > this.periodEnd_) {
+      return null;
+    }
+
+    const lastIndex = timeline.length - 1;
+
+    for (let i = 0; i < timeline.length; i++) {
+      const range = timeline[i];
+      const start = range.start + this.periodStart_;
+      // A rounding error can cause /time/ to equal e.endTime or fall in between
+      // the references by a fraction of a second. To account for this, we use
+      // the start of the next segment as /end/, unless this is the last
+      // reference, in which case we use the period end as the /end/
+      let end = range.end + this.periodStart_;
+
+      if (i < lastIndex) {
+        end = timeline[i + 1].start + this.periodStart_;
+      }
+
+      if ((time >= start) && (time < end)) {
+        return i + this.numEvicted_;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * @override
+   */
+  get(position) {
+    const correctedPosition = position - this.numEvicted_;
+    if (correctedPosition < 0 ||
+        correctedPosition >= this.getNumReferences() || !this.templateInfo_) {
+      return null;
+    }
+
+    let ref = this.references[correctedPosition];
+
+    if (!ref) {
+      const range = this.templateInfo_.timeline[correctedPosition];
+      const segmentReplacement = position + this.templateInfo_.startNumber;
+      const timeReplacement = this.templateInfo_
+          .unscaledPresentationTimeOffset + range.unscaledStart;
+
+      const createUrisCb = () => {
+        return shaka.dash.TimelineSegmentIndex
+            .createUris_(
+                this.templateInfo_.mediaTemplate,
+                this.representationId_,
+                segmentReplacement,
+                this.bandwidth_,
+                timeReplacement,
+                this.baseUris_,
+            );
+      };
+
+      const timestampOffset = this.periodStart_ -
+        this.templateInfo_.scaledPresentationTimeOffset;
+
+      ref = new shaka.media.SegmentReference(
+          this.periodStart_ + range.start,
+          this.periodStart_ + range.end,
+          createUrisCb,
+          /* startByte= */ 0,
+          /* endByte= */ null,
+          this.initSegmentReference_,
+          timestampOffset,
+          this.periodStart_,
+          this.periodEnd_);
+      this.references[correctedPosition] = ref;
+    }
+
+    return ref;
+  }
+
+  /**
+   * Fill in a specific template with values to get the segment uris
+   *
+   * @return {!Array.<string>}
+   * @private
+   */
+  static createUris_(mediaTemplate, repId, segmentReplacement,
+      bandwidth, timeReplacement, baseUris) {
+    const mediaUri = shaka.dash.MpdUtils.fillUriTemplate(
+        mediaTemplate, repId,
+        segmentReplacement, bandwidth || null, timeReplacement);
+    return shaka.util.ManifestParserUtils
+        .resolveUris(baseUris, [mediaUri])
+        .map((g) => {
+          return g.toString();
+        });
+  }
+};
+
 /**
  * @typedef {{
  *   timescale: number,
@@ -606,11 +924,10 @@ shaka.dash.SegmentTemplate = class {
  *   startNumber: number,
  *   scaledPresentationTimeOffset: number,
  *   unscaledPresentationTimeOffset: number,
- *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
+ *   timeline: Array.<shaka.media.PresentationTimeline.TimeRange>,
  *   mediaTemplate: ?string,
  *   indexTemplate: ?string
  * }}
- * @private
  *
  * @description
  * Contains information about a SegmentTemplate.
@@ -625,7 +942,7 @@ shaka.dash.SegmentTemplate = class {
  *   The presentation time offset of the representation, in seconds.
  * @property {number} unscaledPresentationTimeOffset
  *   The presentation time offset of the representation, in timescale units.
- * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
+ * @property {Array.<shaka.media.PresentationTimeline.TimeRange>} timeline
  *   The timeline of the representation, if given.  Times in seconds.
  * @property {?string} mediaTemplate
  *   The media URI template, if given.

package/lib/dependencies/all.js

@@ -41,6 +41,12 @@ shaka.dependencies = class {
     return /** @type {?muxjs} */ (shaka.dependencies.dependencies_.get(
         shaka.dependencies.Allowed.muxjs)());
   }
+
+  /** @return {?ISOBoxer} */
+  static isoBoxer() {
+    return /** @type {?ISOBoxer} */ (shaka.dependencies.dependencies_.get(
+        shaka.dependencies.Allowed.ISOBoxer)());
+  }
 };
 
 /**
@@ -49,6 +55,7 @@ shaka.dependencies = class {
  */
 shaka.dependencies.Allowed = {
   muxjs: 'muxjs',
+  ISOBoxer: 'ISOBoxer',
 };
 
 /**
@@ -59,4 +66,5 @@ shaka.dependencies.Allowed = {
  */
 shaka.dependencies.dependencies_ = new Map([
   [shaka.dependencies.Allowed.muxjs, () => window.muxjs],
+  [shaka.dependencies.Allowed.ISOBoxer, () => window.ISOBoxer],
 ]);

package/lib/hls/hls_classes.js

@@ -11,6 +11,7 @@ goog.provide('shaka.hls.Segment');
 goog.provide('shaka.hls.Tag');
 
 goog.require('goog.asserts');
+goog.require('shaka.hls.Utils');
 goog.require('shaka.util.Error');
 
 
@@ -202,24 +203,48 @@ shaka.hls.Segment = class {
   /**
    * Creates an HLS segment object.
    *
-   * @param {string} absoluteUri An absolute URI.
+   * @param {string} absoluteMediaPlaylistUri An absolute Media Playlist URI.
+   * @param {string} verbatimSegmentUri verbatim segment URI.
    * @param {!Array.<shaka.hls.Tag>} tags
    * @param {!Array.<shaka.hls.Tag>=} partialSegments
    */
-  constructor(absoluteUri, tags, partialSegments=[]) {
+  constructor(absoluteMediaPlaylistUri, verbatimSegmentUri, tags,
+      partialSegments=[]) {
     /** @const {!Array.<shaka.hls.Tag>} */
     this.tags = tags;
 
-    /**
-     * An absolute URI.
-     *
-     * @const {string}
-     */
-    this.absoluteUri = absoluteUri;
+    /** @type {?string} */
+    this.absoluteUri_ = null;
+
+    /** @type {?string} */
+    this.absoluteMediaPlaylistUri_ = absoluteMediaPlaylistUri;
+
+    /** @type {?string} */
+    this.verbatimSegmentUri_ = verbatimSegmentUri;
 
     /** @type {!Array.<shaka.hls.Tag>} */
     this.partialSegments = partialSegments;
   }
+
+  /**
+   * Returns an absolute URI.
+   *
+   * @return {string}
+   */
+  get absoluteUri() {
+    if (!this.absoluteUri_ &&
+        this.absoluteMediaPlaylistUri_ && this.verbatimSegmentUri_) {
+      goog.asserts.assert(this.absoluteMediaPlaylistUri_,
+          'An absolute Media Playlist URI should be defined!');
+      goog.asserts.assert(this.verbatimSegmentUri_,
+          'An verbatim segment URI should be defined!');
+      this.absoluteUri_ = shaka.hls.Utils.constructAbsoluteUri(
+          this.absoluteMediaPlaylistUri_, this.verbatimSegmentUri_);
+      this.absoluteMediaPlaylistUri_ = null;
+      this.verbatimSegmentUri_ = null;
+    }
+    return this.absoluteUri_ || '';
+  }
 };