shaka-player 3.2.1 → 3.3.1

package/lib/hls/hls_parser.js

@@ -25,6 +25,7 @@ goog.require('shaka.net.DataUriPlugin');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.DataViewReader');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
@@ -332,7 +333,8 @@ shaka.hls.HlsParser = class {
     const segments = await this.createSegments_(
         streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
         stream.mimeType, streamInfo.mediaSequenceToStartTime, mediaVariables,
-        streamInfo.discontinuityToMediaSequence);
+        streamInfo.discontinuityToMediaSequence, stream.codecs,
+        stream.bandwidth);
 
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
@@ -418,18 +420,16 @@ shaka.hls.HlsParser = class {
       const uri = tag.getAttributeValue('URI');
       const language = tag.getAttributeValue('LANGUAGE');
       const value = tag.getAttributeValue('VALUE');
-      const data = {
-        'id': id,
-      };
+      const data = (new Map()).set('id', id);
       if (uri) {
-        data.uri =
-            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri);
+        data.set('uri',
+            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri));
       }
       if (language) {
-        data.language = language;
+        data.set('language', language);
       }
       if (value) {
-        data.value = value;
+        data.set('value', value);
       }
       const event = new shaka.util.FakeEvent('sessiondata', data);
       if (this.playerInterface_) {
@@ -534,6 +534,30 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    // Now that the content has been fit, notify segments.
+    this.segmentsToNotifyByStream_ = [];
+    const streamsToNotify = [];
+    for (const variant of variants) {
+      for (const stream of [variant.video, variant.audio]) {
+        if (stream) {
+          streamsToNotify.push(stream);
+        }
+      }
+    }
+    await Promise.all(streamsToNotify.map(async (stream) => {
+      await stream.createSegmentIndex();
+    }));
+    for (const stream of streamsToNotify) {
+      this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
+    }
+    this.notifySegments_();
+
+    // This asserts that the live edge is being calculated from segment times.
+    // For VOD and event streams, this check should still pass.
+    goog.asserts.assert(
+        !this.presentationTimeline_.usingPresentationStartTime(),
+        'We should not be using the presentation start time in HLS!');
+
     this.manifest_ = {
       presentationTimeline: this.presentationTimeline_,
       variants,
@@ -741,7 +765,7 @@ shaka.hls.HlsParser = class {
       const videoRange = tag.getAttributeValue('VIDEO-RANGE');
 
       const streamInfos = await this.createStreamInfosForVariantTag_(tag,
-          resolution, frameRate);
+          resolution, frameRate, bandwidth);
 
       if (streamInfos) {
         goog.asserts.assert(streamInfos.audio.length ||
@@ -775,10 +799,11 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {?string} resolution
    * @param {?string} frameRate
+   * @param {number} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfos>}
    * @private
    */
-  async createStreamInfosForVariantTag_(tag, resolution, frameRate) {
+  async createStreamInfosForVariantTag_(tag, resolution, frameRate, bandwidth) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     /** @type {!Array.<string>} */
     let allCodecs = this.getCodecsForVariantTag_(tag);
@@ -848,7 +873,8 @@ shaka.hls.HlsParser = class {
     let streamInfo;
     if (!ignoreStream) {
       streamInfo =
-          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
+          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type,
+              bandwidth);
     }
     if (streamInfo) {
       res[streamInfo.stream.type] = [streamInfo];
@@ -871,15 +897,12 @@ shaka.hls.HlsParser = class {
    */
   getCodecsForVariantTag_(tag) {
     // These are the default codecs to assume if none are specified.
-    // The video codec is H.264, with baseline profile and level 3.0.
-    // http://blog.pearce.org.nz/2013/11/what-does-h264avc1-codecs-parameters.html
-    // The audio codec is "low-complexity" AAC.
     const defaultCodecsArray = [];
     if (!this.config_.disableVideo) {
-      defaultCodecsArray.push('avc1.42E01E');
+      defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
     }
     if (!this.config_.disableAudio) {
-      defaultCodecsArray.push('mp4a.40.2');
+      defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
     }
     const defaultCodecs = defaultCodecsArray.join(',');
 
@@ -1184,7 +1207,7 @@ shaka.hls.HlsParser = class {
     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
     // only be selected explicitly by the user, and we don't have a way to
     // represent that in our model.
-    const defaultAttrValue = tag.getAttribute('DEFAULT');
+    const defaultAttrValue = tag.getAttributeValue('DEFAULT');
     const primary = defaultAttrValue == 'YES';
 
     const channelsCount = type == 'audio' ? this.getChannelsCount_(tag) : null;
@@ -1258,6 +1281,30 @@ shaka.hls.HlsParser = class {
     if (this.uriToStreamInfosMap_.has(verbatimImagePlaylistUri)) {
       return this.uriToStreamInfosMap_.get(verbatimImagePlaylistUri);
     }
+
+    // Parse misc attributes.
+    const resolution = tag.getAttributeValue('RESOLUTION');
+    if (resolution) {
+      // The RESOLUTION tag represents the resolution of a single thumbnail, not
+      // of the entire sheet at once (like we expect in the output).
+      // So multiply by the layout size.
+
+      const reference = streamInfo.stream.segmentIndex.get(0);
+      const layout = reference.getTilesLayout();
+      if (layout) {
+        streamInfo.stream.width =
+            Number(resolution.split('x')[0]) * Number(layout.split('x')[0]);
+        streamInfo.stream.height =
+            Number(resolution.split('x')[1]) * Number(layout.split('x')[1]);
+        // TODO: What happens if there are multiple grids, with different
+        // layout sizes, inside this image stream?
+      }
+    }
+    const bandwidth = tag.getAttributeValue('BANDWIDTH');
+    if (bandwidth) {
+      streamInfo.stream.bandwidth = Number(bandwidth);
+    }
+
     this.uriToStreamInfosMap_.set(verbatimImagePlaylistUri, streamInfo);
     return streamInfo;
   }
@@ -1268,10 +1315,11 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {!Array.<string>} allCodecs
    * @param {string} type
+   * @param {number} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
-  async createStreamInfoFromVariantTag_(tag, allCodecs, type) {
+  async createStreamInfoFromVariantTag_(tag, allCodecs, type, bandwidth) {
     goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
         'Should only be called on variant tags!');
     const verbatimMediaPlaylistUri = this.variableSubstitution_(
@@ -1287,7 +1335,7 @@ shaka.hls.HlsParser = class {
         codecs, type, /* language= */ 'und', /* primary= */ false,
         /* name= */ null, /* channelcount= */ null, closedCaptions,
         /* characteristics= */ null, /* forced= */ false,
-        /* spatialAudio= */ false);
+        /* spatialAudio= */ false, bandwidth);
     if (streamInfo == null) {
       return null;
     }
@@ -1314,12 +1362,13 @@ shaka.hls.HlsParser = class {
    * @param {?string} characteristics
    * @param {boolean} forced
    * @param {boolean} spatialAudio
+   * @param {(number|undefined)} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
       primary, name, channelsCount, closedCaptions, characteristics, forced,
-      spatialAudio) {
+      spatialAudio, bandwidth = undefined) {
     // TODO: Refactor, too many parameters
     let absoluteMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
         this.masterPlaylistUri_, verbatimMediaPlaylistUri);
@@ -1437,7 +1486,7 @@ shaka.hls.HlsParser = class {
     try {
       segments = await this.createSegments_(verbatimMediaPlaylistUri,
           playlist, type, mimeType, mediaSequenceToStartTime, mediaVariables,
-          discontinuityToMediaSequence);
+          discontinuityToMediaSequence, codecs, bandwidth);
     } catch (error) {
       if (error.code == shaka.util.Error.Code.HLS_INTERNAL_SKIP_STREAM) {
         shaka.log.alwaysWarn('Skipping unsupported HLS stream',
@@ -1617,12 +1666,6 @@ shaka.hls.HlsParser = class {
     }
 
     this.notifySegments_();
-
-    // This asserts that the live edge is being calculated from segment times.
-    // For VOD and event streams, this check should still pass.
-    goog.asserts.assert(
-        !this.presentationTimeline_.usingPresentationStartTime(),
-        'We should not be using the presentation start time in HLS!');
   }
 
   /**
@@ -1795,6 +1838,7 @@ shaka.hls.HlsParser = class {
     }
 
     let tilesLayout = '';
+    let tileDuration = null;
     if (type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
       // By default in HLS the tilesLayout is 1x1
       tilesLayout = '1x1';
@@ -1802,6 +1846,10 @@ shaka.hls.HlsParser = class {
           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-TILES');
       if (tilesTag) {
         tilesLayout = tilesTag.getRequiredAttrValue('LAYOUT');
+        const duration = tilesTag.getAttributeValue('DURATION');
+        if (duration) {
+          tileDuration = Number(duration);
+        }
       }
     }
 
@@ -1817,6 +1865,7 @@ shaka.hls.HlsParser = class {
         /* appendWindowEnd= */ Infinity,
         partialSegmentRefs,
         tilesLayout,
+        tileDuration,
     );
   }
 
@@ -1871,11 +1920,14 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
    * @param {!Map.<number, number>} discontinuityToMediaSequence
+   * @param {string} codecs
+   * @param {(number|undefined)} bandwidth
    * @return {!Promise<!Array.<!shaka.media.SegmentReference>>}
    * @private
    */
   async createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
-      mediaSequenceToStartTime, variables, discontinuityToMediaSequence) {
+      mediaSequenceToStartTime, variables, discontinuityToMediaSequence,
+      codecs, bandwidth) {
     /** @type {Array.<!shaka.hls.Segment>} */
     const hlsSegments = playlist.segments;
     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
@@ -1918,7 +1970,7 @@ shaka.hls.HlsParser = class {
         this.playlistStartTime_ = await this.getStartTime_(
             verbatimMediaPlaylistUri, initSegmentRef, mimeType,
             position, /* isDiscontinuity= */ false,
-            hlsSegments[0], variables, type);
+            hlsSegments[0], variables, type, codecs, bandwidth);
       }
       firstStartTime = this.playlistStartTime_;
     }
@@ -1971,7 +2023,8 @@ shaka.hls.HlsParser = class {
         // eslint-disable-next-line no-await-in-loop
         timestampOffset = await this.getTimestampOffset_(
             discontintuitySequenceNum, verbatimMediaPlaylistUri, initSegmentRef,
-            mimeType, position, item, variables, startTime, type);
+            mimeType, position, item, variables, startTime, type, codecs,
+            bandwidth);
       }
 
       // If the stream is low latency and the user has not configured the
@@ -2009,9 +2062,6 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    this.segmentsToNotifyByStream_.push(references);
-    this.notifySegments_();
-
     return references;
   }
 
@@ -2028,13 +2078,16 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {number} startTime
    * @param {string} type
+   * @param {string} codecs
+   * @param {number|undefined} bandwidth
    * @return {!Promise.<number>}
    * @throws {shaka.util.Error}
    * @private
    */
   async getTimestampOffset_(discontintuitySequenceNum,
       verbatimMediaPlaylistUri, initSegmentRef,
-      mimeType, mediaSequenceNumber, segment, variables, startTime, type) {
+      mimeType, mediaSequenceNumber, segment, variables, startTime, type,
+      codecs, bandwidth) {
     let timestampOffset = 0;
     if (this.discontinuityToTso_.has(discontintuitySequenceNum)) {
       timestampOffset =
@@ -2043,7 +2096,7 @@ shaka.hls.HlsParser = class {
       const mediaStartTime = await this.getStartTime_(
           verbatimMediaPlaylistUri, initSegmentRef, mimeType,
           mediaSequenceNumber, /* isDiscontinuity= */ true, segment,
-          variables, type);
+          variables, type, codecs, bandwidth);
       timestampOffset = startTime - mediaStartTime;
       shaka.log.v1('Segment timestampOffset =', timestampOffset);
       this.discontinuityToTso_.set(
@@ -2057,10 +2110,14 @@ shaka.hls.HlsParser = class {
    * segment if we have to.
    *
    * @param {!shaka.media.AnySegmentReference} reference
+   * @param {string} type
+   * @param {string} mimeType
+   * @param {string} codecs
+   * @param {number|undefined} bandwidth
    * @return {!Promise.<shaka.extern.Response>}
    * @private
    */
-  async fetchStartOfSegment_(reference) {
+  async fetchStartOfSegment_(reference, type, mimeType, codecs, bandwidth) {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
     // Create two requests:
@@ -2074,6 +2131,20 @@ shaka.hls.HlsParser = class {
         reference.endByte,
         this.config_.retryParameters);
 
+    // We can only add partial CMCD data here because the stream
+    // and manifest objects are still being created
+    this.playerInterface_.modifySegmentRequest(
+        fullRequest,
+        {
+          type: type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: mimeType,
+          codecs: codecs,
+          bandwidth: bandwidth,
+        },
+    );
+
     if (this.config_.hls.useFullSegmentsForStartTime) {
       return this.makeNetworkRequest_(fullRequest, requestType);
     }
@@ -2084,6 +2155,18 @@ shaka.hls.HlsParser = class {
         reference.startByte + shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_ - 1,
         this.config_.retryParameters);
 
+    this.playerInterface_.modifySegmentRequest(
+        partialRequest,
+        {
+          type: type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: mimeType,
+          codecs: codecs,
+          bandwidth: bandwidth,
+        },
+    );
+
     // TODO(vaage): The need to do fall back requests is not likely to be unique
     //    to here. It would be nice if the fallback(s) could be included into
     //    the same abortable operation as the original request.
@@ -2131,12 +2214,14 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Segment} segment
    * @param {!Map.<string, string>} variables
    * @param {string} type
+   * @param {string} codecs
+   * @param {number|undefined} bandwidth
    * @return {!Promise.<number>}
    * @private
    */
   async getStartTime_(
       verbatimMediaPlaylistUri, initSegmentRef, mimeType, mediaSequenceNumber,
-      isDiscontinuity, segment, variables, type) {
+      isDiscontinuity, segment, variables, type, codecs, bandwidth) {
     const segmentRef = this.createSegmentReference_(
         initSegmentRef,
         /* previousReference= */ null,
@@ -2204,10 +2289,22 @@ shaka.hls.HlsParser = class {
     if (mimeType == 'video/mp4' || mimeType == 'audio/mp4') {
       // We also need the init segment to get the correct timescale. But if the
       // stream is self-initializing, use the same response for both.
-      const fetches = [this.fetchStartOfSegment_(segmentRef)];
+      const fetches = [this.fetchStartOfSegment_(
+          segmentRef,
+          type,
+          mimeType,
+          codecs,
+          bandwidth,
+      )];
 
       if (initSegmentRef) {
-        fetches.push(this.fetchStartOfSegment_(initSegmentRef));
+        fetches.push(this.fetchStartOfSegment_(
+            initSegmentRef,
+            type,
+            mimeType,
+            codecs,
+            bandwidth,
+        ));
       }
 
       const responses = await Promise.all(fetches);
@@ -2223,7 +2320,13 @@ shaka.hls.HlsParser = class {
     }
 
     if (mimeType == 'video/mp2t') {
-      const response = await this.fetchStartOfSegment_(segmentRef);
+      const response = await this.fetchStartOfSegment_(
+          segmentRef,
+          type,
+          mimeType,
+          codecs,
+          bandwidth,
+      );
       goog.asserts.assert(response.data, 'Should have a response body!');
       return this.getStartTimeFromTsSegment_(
           verbatimMediaPlaylistUri, response.uri, response.data);
@@ -2601,6 +2704,9 @@ shaka.hls.HlsParser = class {
     const request = shaka.net.NetworkingEngine.makeRequest(
         [absoluteUri], this.config_.retryParameters);
 
+    const format = shaka.util.CmcdManager.StreamingFormat.HLS;
+    this.playerInterface_.modifyManifestRequest(request, {format: format});
+
     return this.makeNetworkRequest_(request, requestType);
   }
 

package/lib/media/drm_engine.js

@@ -1825,9 +1825,16 @@ shaka.media.DrmEngine = class {
         // audio adaptations, so we shouldn't have to worry about checking
         // robustness.
         if (drm1.keySystem == drm2.keySystem) {
+          /** @type {Array<shaka.extern.InitDataOverride>} */
           let initData = [];
           initData = initData.concat(drm1.initData || []);
           initData = initData.concat(drm2.initData || []);
+          initData = initData.filter((d, i) => {
+            return d.keyId === undefined || i === initData.findIndex((d2) => {
+              return d2.keyId === d.keyId;
+            });
+          });
+
           const keyIds = drm1.keyIds && drm2.keyIds ?
               new Set([...drm1.keyIds, ...drm2.keyIds]) :
               drm1.keyIds || drm2.keyIds;

package/lib/media/gap_jumping_controller.js

@@ -217,8 +217,10 @@ shaka.media.GapJumpingController = class {
       this.didFireLargeGap_ = true;
 
       // Event firing is synchronous.
-      const event = new shaka.util.FakeEvent(
-          'largegap', {'currentTime': currentTime, 'gapSize': jumpSize});
+      const data = new Map()
+          .set('currentTime', currentTime)
+          .set('gapSize', jumpSize);
+      const event = new shaka.util.FakeEvent('largegap', data);
       event.cancelable = true;
       this.onEvent_(event);
 

package/lib/media/media_source_engine.js

@@ -48,8 +48,7 @@ shaka.media.MediaSourceEngine = class {
    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
    *    onMetadata
    */
-  constructor(video, closedCaptionParser, textDisplayer,
-      onMetadata) {
+  constructor(video, closedCaptionParser, textDisplayer, onMetadata) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;