shaka-player 4.4.3 → 4.6.0

package/lib/dash/segment_template.js

@@ -36,17 +36,19 @@ shaka.dash.SegmentTemplate = class {
    * @param {number} segmentLimit The maximum number of segments to generate for
    *   a SegmentTemplate with fixed duration.
    * @param {!Object.<string, number>} periodDurationMap
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
       context, requestSegment, streamMap, isUpdate, segmentLimit,
-      periodDurationMap) {
+      periodDurationMap, aes128Key) {
     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);
+    const initSegmentReference =
+        SegmentTemplate.createInitSegment_(context, aes128Key);
 
     /** @type {shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
     const info = SegmentTemplate.parseSegmentTemplateInfo_(context);
@@ -82,7 +84,7 @@ shaka.dash.SegmentTemplate = class {
         generateSegmentIndex: () => {
           return SegmentTemplate.generateSegmentIndexFromDuration_(
               shallowCopyOfContext, info, segmentLimit, initSegmentReference,
-              periodDurationMap);
+              periodDurationMap, aes128Key);
         },
       };
     } else {
@@ -129,11 +131,13 @@ shaka.dash.SegmentTemplate = class {
             info,
             context.representation.id,
             context.bandwidth,
-            context.representation.baseUris,
+            context.representation.getBaseUris,
             periodStart,
             periodEnd,
             initSegmentReference,
             shouldFit,
+            aes128Key,
+            context.representation.segmentSequenceCadence,
         );
       } else {
         const tsi = /** @type {!TimelineSegmentIndex} */(segmentIndex);
@@ -281,10 +285,10 @@ shaka.dash.SegmentTemplate = class {
     goog.asserts.assert(info.indexTemplate, 'must be using index template');
     const filledTemplate = MpdUtils.fillUriTemplate(
         info.indexTemplate, context.representation.id,
-        null, context.bandwidth || null, null);
+        null, null, context.bandwidth || null, null);
 
     const resolvedUris = ManifestParserUtils.resolveUris(
-        context.representation.baseUris, [filledTemplate]);
+        context.representation.getBaseUris(), [filledTemplate]);
 
     return shaka.dash.SegmentBase.generateSegmentIndexFromUris(
         context, requestSegment, init, resolvedUris, 0, null,
@@ -299,11 +303,13 @@ shaka.dash.SegmentTemplate = class {
    * @param {number} segmentLimit The maximum number of segments to generate.
    * @param {shaka.media.InitSegmentReference} initSegmentReference
    * @param {!Object.<string, number>} periodDurationMap
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {!Promise.<shaka.media.SegmentIndex>}
    * @private
    */
   static generateSegmentIndexFromDuration_(
-      context, info, segmentLimit, initSegmentReference, periodDurationMap) {
+      context, info, segmentLimit, initSegmentReference, periodDurationMap,
+      aes128Key) {
     goog.asserts.assert(info.mediaTemplate,
         'There should be a media template with duration');
 
@@ -340,7 +346,7 @@ shaka.dash.SegmentTemplate = class {
     const template = info.mediaTemplate;
     const bandwidth = context.bandwidth || null;
     const id = context.representation.id;
-    const baseUris = context.representation.baseUris;
+    const getBaseUris = context.representation.getBaseUris;
 
     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
 
@@ -419,10 +425,13 @@ shaka.dash.SegmentTemplate = class {
           info.scaledPresentationTimeOffset;
 
       const getUris = () => {
+        let time = segmentMediaTime * timescale;
+        if ('BigInt' in window && time > Number.MAX_SAFE_INTEGER) {
+          time = BigInt(segmentMediaTime) * BigInt(timescale);
+        }
         const mediaUri = MpdUtils.fillUriTemplate(
-            template, id, position, bandwidth,
-            segmentMediaTime * timescale);
-        return ManifestParserUtils.resolveUris(baseUris, [mediaUri]);
+            template, id, position, /* subNumber= */ null, bandwidth, time);
+        return ManifestParserUtils.resolveUris(getBaseUris(), [mediaUri]);
       };
 
       // Relative to the presentation.
@@ -446,7 +455,13 @@ shaka.dash.SegmentTemplate = class {
           initSegmentReference,
           timestampOffset,
           /* appendWindowStart= */ periodStart,
-          /* appendWindowEnd= */ getPeriodEnd());
+          /* appendWindowEnd= */ getPeriodEnd(),
+          /* partialReferences= */ [],
+          /* tilesLayout= */ '',
+          /* tileDuration= */ null,
+          /* syncTime= */ null,
+          shaka.media.SegmentReference.Status.AVAILABLE,
+          aes128Key);
       // This is necessary information for thumbnail streams:
       ref.trueEndTime = trueSegmentEnd;
       return ref;
@@ -505,87 +520,15 @@ shaka.dash.SegmentTemplate = class {
     return Promise.resolve(segmentIndex);
   }
 
-  /**
-   * Creates segment references from a timeline.
-   *
-   * @param {shaka.dash.DashParser.Context} context
-   * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
-   * @param {shaka.media.InitSegmentReference} initSegmentReference
-   * @return {!Array.<!shaka.media.SegmentReference>}
-   * @private
-   */
-  static createFromTimeline_(context, info, initSegmentReference) {
-    const MpdUtils = shaka.dash.MpdUtils;
-    const ManifestParserUtils = shaka.util.ManifestParserUtils;
-
-    const periodStart = context.periodInfo.start;
-    const periodDuration = context.periodInfo.duration;
-
-    const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
-    const appendWindowStart = periodStart;
-    const appendWindowEnd = periodDuration ?
-        periodStart + periodDuration : Infinity;
-
-    /** @type {!Array.<!shaka.media.SegmentReference>} */
-    const references = [];
-    for (let i = 0; i < info.timeline.length; i++) {
-      const {start, unscaledStart, end} = info.timeline[i];
-
-      // Note: i = k - 1, where k indicates the k'th segment listed in the MPD.
-      // (See section 5.3.9.5.3 of the DASH spec.)
-      const segmentReplacement = i + info.startNumber;
-
-      // Consider the presentation time offset in segment uri computation
-      const timeReplacement = unscaledStart +
-          info.unscaledPresentationTimeOffset;
-      const repId = context.representation.id;
-      const bandwidth = context.bandwidth || null;
-      const mediaTemplate = info.mediaTemplate;
-      const baseUris = context.representation.baseUris;
-
-      // This callback must not capture any non-local
-      // variables, such as info, context, etc.  Make
-      // sure any values you reference here have
-      // been assigned to local variables within the
-      // loop, or else we will end up with a leak.
-      const createUris =
-          () => {
-            goog.asserts.assert(
-                mediaTemplate,
-                'There should be a media template with a timeline');
-            const mediaUri = MpdUtils.fillUriTemplate(
-                mediaTemplate, repId,
-                segmentReplacement, bandwidth || null, timeReplacement);
-            return ManifestParserUtils
-                .resolveUris(baseUris, [mediaUri])
-                .map((g) => {
-                  return g.toString();
-                });
-          };
-
-      references.push(new shaka.media.SegmentReference(
-          periodStart + start,
-          periodStart + end,
-          createUris,
-          /* startByte= */ 0,
-          /* endByte= */ null,
-          initSegmentReference,
-          timestampOffset,
-          appendWindowStart,
-          appendWindowEnd));
-    }
-
-    return references;
-  }
-
   /**
    * Creates an init segment reference from a context object.
    *
    * @param {shaka.dash.DashParser.Context} context
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.media.InitSegmentReference}
    * @private
    */
-  static createInitSegment_(context) {
+  static createInitSegment_(context, aes128Key) {
     const MpdUtils = shaka.dash.MpdUtils;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const SegmentTemplate = shaka.dash.SegmentTemplate;
@@ -598,17 +541,24 @@ shaka.dash.SegmentTemplate = class {
 
     const repId = context.representation.id;
     const bandwidth = context.bandwidth || null;
-    const baseUris = context.representation.baseUris;
+    const getBaseUris = context.representation.getBaseUris;
     const getUris = () => {
       goog.asserts.assert(initialization, 'Should have returned earler');
       const filledTemplate = MpdUtils.fillUriTemplate(
-          initialization, repId, null, bandwidth, null);
+          initialization, repId, null, null, bandwidth, null);
       const resolvedUris = ManifestParserUtils.resolveUris(
-          baseUris, [filledTemplate]);
+          getBaseUris(), [filledTemplate]);
       return resolvedUris;
     };
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
-    return new shaka.media.InitSegmentReference(getUris, 0, null, qualityInfo);
+    return new shaka.media.InitSegmentReference(
+        getUris,
+        /* startByte= */ 0,
+        /* endByte= */ null,
+        qualityInfo,
+        /* timescale= */ null,
+        /* segmentData= */ null,
+        aes128Key);
   }
 };
 
@@ -630,15 +580,17 @@ 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 {function():Array.<string>} getBaseUris
    * @param {number} periodStart
    * @param {number} periodEnd
    * @param {shaka.media.InitSegmentReference} initSegmentReference
    * @param {boolean} shouldFit
-   *
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
+   * @param {number} segmentSequenceCadence
   */
-  constructor(templateInfo, representationId, bandwidth, baseUris,
-      periodStart, periodEnd, initSegmentReference, shouldFit) {
+  constructor(templateInfo, representationId, bandwidth, getBaseUris,
+      periodStart, periodEnd, initSegmentReference, shouldFit,
+      aes128Key, segmentSequenceCadence) {
     super([]);
 
     /** @private {?shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
@@ -647,14 +599,18 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
     this.representationId_ = representationId;
     /** @private {number} */
     this.bandwidth_ = bandwidth;
-    /** @private {Array.<string>} */
-    this.baseUris_ = baseUris;
+    /** @private {function():Array.<string>} */
+    this.getBaseUris_ = getBaseUris;
     /** @private {number} */
     this.periodStart_ = periodStart;
     /** @private {number} */
     this.periodEnd_ = periodEnd;
     /** @private {shaka.media.InitSegmentReference} */
     this.initSegmentReference_ = initSegmentReference;
+    /** @private {shaka.extern.aes128Key|undefined} */
+    this.aes128Key_ = aes128Key;
+    /** @private {number} */
+    this.segmentSequenceCadence_ = segmentSequenceCadence;
 
 
     if (shouldFit) {
@@ -862,29 +818,81 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
     let ref = this.references[correctedPosition];
 
     if (!ref) {
+      const mediaTemplate = this.templateInfo_.mediaTemplate;
       const range = this.templateInfo_.timeline[correctedPosition];
-      const segmentReplacement = position + this.templateInfo_.startNumber;
+      const segmentReplacement = range.segmentPosition;
       const timeReplacement = this.templateInfo_
           .unscaledPresentationTimeOffset + range.unscaledStart;
+      const timestampOffset = this.periodStart_ -
+        this.templateInfo_.scaledPresentationTimeOffset;
+
+      const partialSegmentRefs = [];
+
+      const partialDuration = (range.end - range.start) / range.partialSegments;
+
+      for (let i = 0; i < range.partialSegments; i++) {
+        const start = range.start + partialDuration * i;
+        const end = start + partialDuration;
+        const subNumber = i + 1;
+        let uris = null;
+        const getPartialUris = () => {
+          if (!this.templateInfo_) {
+            return [];
+          }
+          if (uris == null) {
+            uris = shaka.dash.TimelineSegmentIndex.createUris_(
+                this.templateInfo_.mediaTemplate,
+                this.representationId_,
+                segmentReplacement,
+                this.bandwidth_,
+                timeReplacement,
+                subNumber,
+                this.getBaseUris_);
+          }
+          return uris;
+        };
+        const partial = new shaka.media.SegmentReference(
+            this.periodStart_ + start,
+            this.periodStart_ + end,
+            getPartialUris,
+            /* startByte= */ 0,
+            /* endByte= */ null,
+            this.initSegmentReference_,
+            timestampOffset,
+            this.periodStart_,
+            this.periodEnd_,
+            /* partialReferences= */ [],
+            /* tilesLayout= */ '',
+            /* tileDuration= */ null,
+            /* syncTime= */ null,
+            shaka.media.SegmentReference.Status.AVAILABLE,
+            this.aes128Key_);
+        if (this.segmentSequenceCadence_ == 0) {
+          if (i > 0) {
+            partial.markAsNonIndependent();
+          }
+        } else if ((i % this.segmentSequenceCadence_) != 0) {
+          partial.markAsNonIndependent();
+        }
+        partialSegmentRefs.push(partial);
+      }
 
       const createUrisCb = () => {
-        if (!this.templateInfo_) {
+        if (range.partialSegments > 0) {
           return [];
         }
         return shaka.dash.TimelineSegmentIndex
             .createUris_(
-                this.templateInfo_.mediaTemplate,
+                mediaTemplate,
                 this.representationId_,
                 segmentReplacement,
                 this.bandwidth_,
                 timeReplacement,
-                this.baseUris_,
+                /* subNumber= */ null,
+                this.getBaseUris_,
             );
       };
 
-      const timestampOffset = this.periodStart_ -
-        this.templateInfo_.scaledPresentationTimeOffset;
-
       ref = new shaka.media.SegmentReference(
           this.periodStart_ + range.start,
           this.periodStart_ + range.end,
@@ -894,7 +902,14 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
           this.initSegmentReference_,
           timestampOffset,
           this.periodStart_,
-          this.periodEnd_);
+          this.periodEnd_,
+          partialSegmentRefs,
+          /* tilesLayout= */ '',
+          /* tileDuration= */ null,
+          /* syncTime= */ null,
+          shaka.media.SegmentReference.Status.AVAILABLE,
+          this.aes128Key_,
+          /* allPartialSegments= */ range.partialSegments > 0);
       this.references[correctedPosition] = ref;
     }
 
@@ -908,12 +923,12 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
    * @private
    */
   static createUris_(mediaTemplate, repId, segmentReplacement,
-      bandwidth, timeReplacement, baseUris) {
+      bandwidth, timeReplacement, subNumber, getBaseUris) {
     const mediaUri = shaka.dash.MpdUtils.fillUriTemplate(
         mediaTemplate, repId,
-        segmentReplacement, bandwidth || null, timeReplacement);
+        segmentReplacement, subNumber, bandwidth || null, timeReplacement);
     return shaka.util.ManifestParserUtils
-        .resolveUris(baseUris, [mediaUri])
+        .resolveUris(getBaseUris(), [mediaUri])
         .map((g) => {
           return g.toString();
         });

package/lib/dependencies/all.js

@@ -6,6 +6,8 @@
 
 goog.provide('shaka.dependencies');
 
+goog.require('shaka.Deprecate');
+
 /**
  * @export
  */
@@ -22,6 +24,12 @@ shaka.dependencies = class {
     if (!shaka.dependencies.Allowed[key]) {
       throw new Error(`${key} is not supported`);
     }
+    if (key == shaka.dependencies.Allowed.muxjs) {
+      shaka.Deprecate.deprecateFeature(5,
+          'mux.js',
+          'mux.js is no longer used in Shaka Player.');
+      return;
+    }
     shaka.dependencies.dependencies_.set(key, () => dep);
   }
 
@@ -36,12 +44,6 @@ shaka.dependencies = class {
     return shaka.dependencies.dependencies_.has(key);
   }
 
-  /** @return {?muxjs} */
-  static muxjs() {
-    return /** @type {?muxjs} */ (shaka.dependencies.dependencies_.get(
-        shaka.dependencies.Allowed.muxjs)());
-  }
-
   /** @return {?ISOBoxer} */
   static isoBoxer() {
     return /** @type {?ISOBoxer} */ (shaka.dependencies.dependencies_.get(
@@ -65,6 +67,5 @@ shaka.dependencies.Allowed = {
  * @private {!Map.<shaka.dependencies.Allowed, function():?>}
  */
 shaka.dependencies.dependencies_ = new Map([
-  [shaka.dependencies.Allowed.muxjs, () => window.muxjs],
   [shaka.dependencies.Allowed.ISOBoxer, () => window.ISOBoxer],
 ]);

package/lib/hls/hls_classes.js

@@ -11,7 +11,6 @@ goog.provide('shaka.hls.Segment');
 goog.provide('shaka.hls.Tag');
 
 goog.require('goog.asserts');
-goog.require('shaka.hls.Utils');
 goog.require('shaka.util.Error');
 
 
@@ -20,19 +19,11 @@ goog.require('shaka.util.Error');
  */
 shaka.hls.Playlist = class {
   /**
-   * @param {string} absoluteUri An absolute, final URI after redirects.
    * @param {!shaka.hls.PlaylistType} type
    * @param {!Array.<shaka.hls.Tag>} tags
    * @param {!Array.<shaka.hls.Segment>=} segments
    */
-  constructor(absoluteUri, type, tags, segments) {
-    /**
-     * An absolute, final URI after redirects.
-     *
-     * @const {string}
-     */
-    this.absoluteUri = absoluteUri;
-
+  constructor(type, tags, segments) {
     /** @const {shaka.hls.PlaylistType} */
     this.type = type;
 
@@ -87,10 +78,11 @@ shaka.hls.Tag = class {
    * As in some cases (like in tests) the tag never existed in string form, it
    * is far easier to recreate the tag from the parsed form.
    *
+   * @param {?Set.<string>=} attributesToSkip
    * @return {string}
    * @override
    */
-  toString() {
+  toString(attributesToSkip) {
     /**
      * @param {shaka.hls.Attribute} attr
      * @return {string}
@@ -107,7 +99,12 @@ shaka.hls.Tag = class {
     //  4) <NAME>:<VALUE>,<ATTRIBUTE_LIST>
 
     let tagStr = '#' + this.name;
-    const appendages = this.attributes ? this.attributes.map(attrToStr) : [];
+    const appendages = this.attributes ? this.attributes.filter((attr) => {
+      if (!attributesToSkip) {
+        return true;
+      }
+      return !attributesToSkip.has(attr.name);
+    }).map(attrToStr) : [];
 
     if (this.value) {
       appendages.unshift(this.value);
@@ -120,6 +117,22 @@ shaka.hls.Tag = class {
     return tagStr;
   }
 
+  /**
+   * Create the string key of the tag.
+   *
+   * @return {string}
+   */
+  getTagKey() {
+    const attributesToSkip = new Set()
+        .add('AUDIO')
+        .add('VIDEO')
+        .add('SUBTITLES')
+        .add('PATHWAY-ID')
+        .add('GROUP-ID')
+        .add('URI');
+    return this.toString(attributesToSkip);
+  }
+
   /**
    * Adds an attribute to an HLS Tag.
    *
@@ -203,48 +216,20 @@ shaka.hls.Segment = class {
   /**
    * Creates an HLS segment object.
    *
-   * @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(absoluteMediaPlaylistUri, verbatimSegmentUri, tags,
-      partialSegments=[]) {
+  constructor(verbatimSegmentUri, tags, partialSegments=[]) {
     /** @const {!Array.<shaka.hls.Tag>} */
     this.tags = tags;
 
-    /** @type {?string} */
-    this.absoluteUri_ = null;
-
-    /** @type {?string} */
-    this.absoluteMediaPlaylistUri_ = absoluteMediaPlaylistUri;
-
-    /** @type {?string} */
-    this.verbatimSegmentUri_ = verbatimSegmentUri;
+    /** @const {?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_ || '';
-  }
 };