shaka-player 4.8.8 → 4.9.0

package/lib/dash/mpd_utils.js

@@ -123,7 +123,7 @@ shaka.dash.MpdUtils = class {
    * Expands a SegmentTimeline into an array-based timeline.  The results are in
    * seconds.
    *
-   * @param {!shaka.extern.xml.Node} segmentTimeline
+   * @param {Array<!shaka.extern.xml.Node>} timePoints
    * @param {number} timescale
    * @param {number} unscaledPresentationTimeOffset
    * @param {number} periodDuration The Period's duration in seconds.
@@ -132,7 +132,7 @@ shaka.dash.MpdUtils = class {
    * @return {!Array.<shaka.media.PresentationTimeline.TimeRange>}
    */
   static createTimeline(
-      segmentTimeline, timescale, unscaledPresentationTimeOffset,
+      timePoints, timescale, unscaledPresentationTimeOffset,
       periodDuration, startNumber) {
     goog.asserts.assert(
         timescale > 0 && timescale < Infinity,
@@ -143,8 +143,6 @@ shaka.dash.MpdUtils = class {
     // Alias.
     const TXml = shaka.util.TXml;
 
-    const timePoints = TXml.findChildren(segmentTimeline, 'S');
-
     /** @type {!Array.<shaka.media.PresentationTimeline.TimeRange>} */
     const timeline = [];
     let lastEndTime = -unscaledPresentationTimeOffset;
@@ -296,13 +294,14 @@ shaka.dash.MpdUtils = class {
       startNumber = 1;
     }
 
-    const timelineNode =
-        MpdUtils.inheritChild(context, callback, 'SegmentTimeline');
     /** @type {Array.<shaka.media.PresentationTimeline.TimeRange>} */
     let timeline = null;
+    const timelineNode =
+        MpdUtils.inheritChild(context, callback, 'SegmentTimeline');
     if (timelineNode) {
+      const timePoints = TXml.findChildren(timelineNode, 'S');
       timeline = MpdUtils.createTimeline(
-          timelineNode, timescale, unscaledPresentationTimeOffset,
+          timePoints, timescale, unscaledPresentationTimeOffset,
           context.periodInfo.duration || Infinity, startNumber);
     }
 
@@ -329,7 +328,7 @@ shaka.dash.MpdUtils = class {
     const Functional = shaka.util.Functional;
     goog.asserts.assert(
         callback(context.representation),
-        'There must be at least one element of the given type',
+        'There must be at least one element of the given type.',
     );
 
     return [

package/lib/dash/segment_template.js

@@ -18,6 +18,7 @@ goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.StringUtils');
+goog.require('shaka.util.TXml');
 goog.requireType('shaka.dash.DashParser');
 goog.requireType('shaka.media.PresentationTimeline');
 
@@ -39,18 +40,27 @@ shaka.dash.SegmentTemplate = class {
    * @param {!Object.<string, number>} periodDurationMap
    * @param {shaka.extern.aesKey|undefined} aesKey
    * @param {?number} lastSegmentNumber
+   * @param {boolean} isPatchUpdate
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
       context, requestSegment, streamMap, isUpdate, segmentLimit,
-      periodDurationMap, aesKey, lastSegmentNumber) {
+      periodDurationMap, aesKey, lastSegmentNumber, isPatchUpdate) {
     goog.asserts.assert(context.representation.segmentTemplate,
-        'Should only be called with SegmentTemplate');
+        'Should only be called with SegmentTemplate ' +
+        'or segment info defined');
+    const MpdUtils = shaka.dash.MpdUtils;
     const SegmentTemplate = shaka.dash.SegmentTemplate;
     const TimelineSegmentIndex = shaka.dash.TimelineSegmentIndex;
 
-    const initSegmentReference =
-        SegmentTemplate.createInitSegment_(context, aesKey);
+    if (!isPatchUpdate && !context.representation.initialization) {
+      context.representation.initialization =
+          MpdUtils.inheritAttribute(
+              context, SegmentTemplate.fromInheritance_, 'initialization');
+    }
+
+    const initSegmentReference = context.representation.initialization ?
+        SegmentTemplate.createInitSegment_(context, aesKey) : null;
 
     /** @type {shaka.dash.SegmentTemplate.SegmentTemplateInfo} */
     const info = SegmentTemplate.parseSegmentTemplateInfo_(context);
@@ -178,6 +188,42 @@ shaka.dash.SegmentTemplate = class {
     }
   }
 
+  /**
+   * Ingests Patch MPD segments into timeline.
+   *
+   * @param {!shaka.dash.DashParser.Context} context
+   * @param {shaka.extern.xml.Node} patchNode
+   */
+  static modifyTimepoints(context, patchNode) {
+    const MpdUtils = shaka.dash.MpdUtils;
+    const SegmentTemplate = shaka.dash.SegmentTemplate;
+    const TXml = shaka.util.TXml;
+
+    const timelineNode = MpdUtils.inheritChild(context,
+        SegmentTemplate.fromInheritance_, 'SegmentTimeline');
+    goog.asserts.assert(timelineNode, 'timeline node not found');
+    const timepoints = TXml.findChildren(timelineNode, 'S');
+
+    goog.asserts.assert(timepoints, 'timepoints should exist');
+    TXml.modifyNodes(timepoints, patchNode);
+    timelineNode.children = timepoints;
+  }
+
+  /**
+   * Removes all segments from timeline.
+   *
+   * @param {!shaka.dash.DashParser.Context} context
+   */
+  static removeTimepoints(context) {
+    const MpdUtils = shaka.dash.MpdUtils;
+    const SegmentTemplate = shaka.dash.SegmentTemplate;
+
+    const timelineNode = MpdUtils.inheritChild(context,
+        SegmentTemplate.fromInheritance_, 'SegmentTimeline');
+    goog.asserts.assert(timelineNode, 'timeline node not found');
+    timelineNode.children = [];
+  }
+
   /**
    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
    * @return {?shaka.extern.xml.Node}
@@ -203,6 +249,7 @@ shaka.dash.SegmentTemplate = class {
 
     const media = MpdUtils.inheritAttribute(
         context, SegmentTemplate.fromInheritance_, 'media');
+
     const index = MpdUtils.inheritAttribute(
         context, SegmentTemplate.fromInheritance_, 'index');
 
@@ -552,8 +599,11 @@ shaka.dash.SegmentTemplate = class {
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const SegmentTemplate = shaka.dash.SegmentTemplate;
 
-    let initialization = MpdUtils.inheritAttribute(
-        context, SegmentTemplate.fromInheritance_, 'initialization');
+    let initialization = context.representation.initialization;
+    if (!initialization) {
+      initialization = MpdUtils.inheritAttribute(
+          context, SegmentTemplate.fromInheritance_, 'initialization');
+    }
     if (!initialization) {
       return null;
     }
@@ -722,10 +772,15 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
       this.templateInfo_.mediaTemplate = info.mediaTemplate;
 
       // Append timeline
-      const lastCurrentEntry = currentTimeline[currentTimeline.length - 1];
-      const newEntries = info.timeline.filter((entry) => {
-        return entry.start >= lastCurrentEntry.end;
-      });
+      let newEntries;
+      if (currentTimeline.length) {
+        const lastCurrentEntry = currentTimeline[currentTimeline.length - 1];
+        newEntries = info.timeline.filter((entry) => {
+          return entry.start >= lastCurrentEntry.end;
+        });
+      } else {
+        newEntries = info.timeline.slice();
+      }
 
       if (newEntries.length > 0) {
         shaka.log.debug(`Appending ${newEntries.length} entries`);

package/lib/hls/hls_parser.js

@@ -244,6 +244,9 @@ shaka.hls.HlsParser = class {
 
     /** @private {?shaka.util.ContentSteeringManager} */
     this.contentSteeringManager_ = null;
+
+    /** @private {boolean} */
+    this.needsClosedCaptionsDetection_ = true;
   }
 
 
@@ -759,10 +762,19 @@ shaka.hls.HlsParser = class {
 
     // Parsing a media playlist results in a single-variant stream.
     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
+      this.needsClosedCaptionsDetection_ = false;
+
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
+          'EXT-X-DEFINE');
+
+      const mediaVariables =
+          this.parseMediaVariables_(variablesTags, this.masterPlaylistUri_);
+
       // Get necessary info for this stream. These are things we would normally
       // find from the master playlist (e.g. from values on EXT-X-MEDIA tags).
-      const basicInfo =
-          await this.getMediaPlaylistBasicInfo_(playlist, getUris);
+      const basicInfo = await this.getMediaPlaylistBasicInfo_(
+          playlist, getUris, mediaVariables);
       const type = basicInfo.type;
       const mimeType = basicInfo.mimeType;
       const codecs = basicInfo.codecs;
@@ -773,6 +785,7 @@ shaka.hls.HlsParser = class {
       const sampleRate = basicInfo.sampleRate;
       const closedCaptions = basicInfo.closedCaptions;
       const videoRange = basicInfo.videoRange;
+      const colorGamut = basicInfo.colorGamut;
 
       // Some values we cannot figure out, and aren't important enough to ask
       // the user to provide through config values. A lot of these are only
@@ -786,14 +799,15 @@ shaka.hls.HlsParser = class {
 
       // Make the stream info, with those values.
       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
-          this.globalId_++, playlist, getUris, uri, codecs, type,
-          languageValue, primary, name, channelsCount, closedCaptions,
+          this.globalId_++, mediaVariables, playlist, getUris, uri, codecs,
+          type, languageValue, primary, name, channelsCount, closedCaptions,
           characteristics, forced, sampleRate, spatialAudio, mimeType);
       this.uriToStreamInfosMap_.set(uri, streamInfo);
 
       if (type == 'video') {
         this.addVideoAttributes_(streamInfo.stream, width, height,
-            /* frameRate= */ null, videoRange, /* videoLayout= */ null);
+            /* frameRate= */ null, videoRange, /* videoLayout= */ null,
+            colorGamut);
       }
 
       // Wrap the stream from that stream info with a variant.
@@ -880,6 +894,7 @@ shaka.hls.HlsParser = class {
         this.config_.hls.ignoreManifestTimestampsInSegmentsMode,
       type: shaka.media.ManifestParser.HLS,
       serviceDescription: null,
+      nextUrl: null,
     };
 
     // If there is no 'CODECS' attribute in the manifest and codec guessing is
@@ -918,10 +933,11 @@ shaka.hls.HlsParser = class {
   /**
    * @param {shaka.hls.Playlist} playlist
    * @param {function():!Array.<string>} getUris
+   * @param {?Map.<string, string>=} variables
    * @return {!Promise.<shaka.media.SegmentUtils.BasicInfo>}
    * @private
    */
-  async getMediaPlaylistBasicInfo_(playlist, getUris) {
+  async getMediaPlaylistBasicInfo_(playlist, getUris, variables) {
     const HlsParser = shaka.hls.HlsParser;
     const defaultBasicInfo = shaka.media.SegmentUtils.getBasicInfoFromMimeType(
         this.config_.hls.mediaPlaylistFullMimeType);
@@ -931,7 +947,8 @@ shaka.hls.HlsParser = class {
     const firstSegment = playlist.segments[0];
     const firstSegmentUris = shaka.hls.Utils.constructSegmentUris(
         getUris(),
-        firstSegment.verbatimSegmentUri);
+        firstSegment.verbatimSegmentUri,
+        variables);
     const firstSegmentUri = firstSegmentUris[0];
     const parsedUri = new goog.Uri(firstSegmentUri);
     const extension = parsedUri.getPath().split('.').pop();
@@ -945,7 +962,7 @@ shaka.hls.HlsParser = class {
 
     let initData = null;
     const initSegmentRef = this.getInitSegmentReference_(
-        playlist, firstSegment.tags, getUris);
+        playlist, firstSegment.tags, getUris, variables);
     this.mapTagToInitSegmentRefMap_.clear();
     if (initSegmentRef) {
       const initSegmentRequest = shaka.util.Networking.createSegmentRequest(
@@ -1388,7 +1405,19 @@ shaka.hls.HlsParser = class {
         const keyFormat =
             drmTag.getAttributeValue('KEYFORMAT') || 'identity';
         let drmInfo = null;
-        if (method == 'NONE' || this.isAesMethod_(method)) {
+        if (method == 'NONE') {
+          continue;
+        } else if (this.isAesMethod_(method)) {
+          const keyUris = shaka.hls.Utils.constructSegmentUris(
+              getUris(), drmTag.getRequiredAttrValue('URI'), variables);
+          const keyMapKey = keyUris.sort().join('');
+          if (!this.aesKeyMap_.has(keyMapKey)) {
+            const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
+            const request = shaka.net.NetworkingEngine.makeRequest(
+                keyUris, this.config_.retryParameters);
+            const keyResponse = this.makeNetworkRequest_(request, requestType);
+            this.aesKeyMap_.set(keyMapKey, keyResponse);
+          }
           continue;
         } else if (keyFormat == 'identity') {
           // eslint-disable-next-line no-await-in-loop
@@ -1755,10 +1784,12 @@ shaka.hls.HlsParser = class {
     // value of the GROUP-ID attribute of an EXT-X-MEDIA tag elsewhere in the
     // Playlist whose TYPE attribute is CLOSED-CAPTIONS.
     if (type == ContentType.VIDEO) {
-      if (closedCaptionsAttr && closedCaptionsAttr != 'NONE') {
-        return this.groupIdToClosedCaptionsMap_.get(closedCaptionsAttr);
-      } else if (!closedCaptionsAttr &&
-          this.groupIdToClosedCaptionsMap_.size) {
+      if (closedCaptionsAttr) {
+        if (closedCaptionsAttr != 'NONE') {
+          return this.groupIdToClosedCaptionsMap_.get(closedCaptionsAttr);
+        }
+        this.needsClosedCaptionsDetection_ = false;
+      } else if (!closedCaptionsAttr && this.groupIdToClosedCaptionsMap_.size) {
         for (const key of this.groupIdToClosedCaptionsMap_.keys()) {
           return this.groupIdToClosedCaptionsMap_.get(key);
         }
@@ -1817,7 +1848,8 @@ shaka.hls.HlsParser = class {
 
     for (const info of videoInfos) {
       this.addVideoAttributes_(
-          info.stream, width, height, frameRate, videoRange, videoLayout);
+          info.stream, width, height, frameRate, videoRange, videoLayout,
+          /** colorGamut= */ null);
     }
 
     // In case of audio-only or video-only content or the audio/video is
@@ -1907,6 +1939,7 @@ shaka.hls.HlsParser = class {
   parseClosedCaptions_(mediaTags) {
     const closedCaptionsTags =
         shaka.hls.Utils.filterTagsByType(mediaTags, 'CLOSED-CAPTIONS');
+    this.needsClosedCaptionsDetection_ = closedCaptionsTags.length == 0;
     for (const tag of closedCaptionsTags) {
       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
           'Should only be called on media tags!');
@@ -2248,6 +2281,8 @@ shaka.hls.HlsParser = class {
 
     /** @param {!AbortSignal} abortSignal */
     const downloadSegmentIndex = async (abortSignal) => {
+      const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
       const uris = streamInfo.getUris();
       // Download the actual manifest.
       const response = await this.requestManifest_(
@@ -2267,24 +2302,47 @@ shaka.hls.HlsParser = class {
       /** @type {!shaka.hls.Playlist} */
       const playlist = this.manifestTextParser_.parsePlaylist(response.data);
 
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
+          'EXT-X-DEFINE');
+
+      const mediaVariables =
+          this.parseMediaVariables_(variablesTags, responseUri);
+
       let mimeType = undefined;
 
+      let closedCaptionsUpdated = false;
+
       // If no codec info was provided in the manifest and codec guessing is
       // disabled we try to get necessary info from the media data.
-      if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
-        const basicInfo =
-            await this.getMediaPlaylistBasicInfo_(playlist, getUris);
+      if ((!this.codecInfoInManifest_ &&
+          this.config_.hls.disableCodecGuessing) ||
+          (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
+          !this.config_.hls.disableClosedCaptionsDetection)) {
+        this.needsClosedCaptionsDetection_ = false;
+
+        const basicInfo = await this.getMediaPlaylistBasicInfo_(
+            playlist, getUris, mediaVariables);
 
         goog.asserts.assert(
             type === basicInfo.type, 'Media types should match!');
 
-        mimeType = basicInfo.mimeType;
-        codecs = basicInfo.codecs;
+        if (basicInfo.closedCaptions.size && (!closedCaptions ||
+            closedCaptions.size != basicInfo.closedCaptions.size)) {
+          closedCaptions = basicInfo.closedCaptions;
+          closedCaptionsUpdated = true;
+        }
+
+        if (!this.codecInfoInManifest_ &&
+            this.config_.hls.disableCodecGuessing) {
+          mimeType = basicInfo.mimeType;
+          codecs = basicInfo.codecs;
+        }
       }
 
       const wasLive = this.isLive_();
       const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
-          streamId, playlist, getUris, responseUri, codecs,
+          streamId, mediaVariables, playlist, getUris, responseUri, codecs,
           type, languageValue, primary, name, channelsCount, closedCaptions,
           characteristics, forced, sampleRate, spatialAudio, mimeType);
       if (abortSignal.aborted) {
@@ -2317,6 +2375,8 @@ shaka.hls.HlsParser = class {
       stream.mimeType = realStream.mimeType;
       stream.bandwidth = stream.bandwidth || realStream.bandwidth;
       stream.codecs = stream.codecs || realStream.codecs;
+      stream.closedCaptions =
+          stream.closedCaptions || realStream.closedCaptions;
       this.setFullTypeForStream_(stream);
 
       // Since we lazy-loaded this content, the player may need to create new
@@ -2325,7 +2385,10 @@ shaka.hls.HlsParser = class {
         this.playerInterface_.newDrmInfo(stream);
       }
 
-      const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      if (this.manifest_ && closedCaptionsUpdated) {
+        this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
+      }
+
       if (type == ContentType.VIDEO || type == ContentType.AUDIO) {
         for (const otherStreamInfo of this.uriToStreamInfosMap_.values()) {
           if (!otherStreamInfo.loadedOnce && otherStreamInfo.type == type) {
@@ -2556,7 +2619,7 @@ shaka.hls.HlsParser = class {
    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
-  async convertParsedPlaylistIntoStreamInfo_(streamId, playlist,
+  async convertParsedPlaylistIntoStreamInfo_(streamId, variables, playlist,
       getUris, responseUri, codecs, type, languageValue, primary, name,
       channelsCount, closedCaptions, characteristics, forced, sampleRate,
       spatialAudio, mimeType = undefined) {
@@ -2569,13 +2632,6 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
     }
 
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
-        'EXT-X-DEFINE');
-
-    const mediaVariables =
-        this.parseMediaVariables_(variablesTags, responseUri);
-
     goog.asserts.assert(playlist.segments != null,
         'Media playlist should have segments!');
 
@@ -2587,11 +2643,11 @@ shaka.hls.HlsParser = class {
 
     if (!mimeType) {
       mimeType = await this.guessMimeType_(type, codecs, playlist,
-          mediaVariables, getUris);
+          variables, getUris);
     }
 
     const {drmInfos, keyIds, encrypted, aesEncrypted} =
-        await this.parseDrmInfo_(playlist, mimeType, getUris, mediaVariables);
+        await this.parseDrmInfo_(playlist, mimeType, getUris, variables);
 
     if (encrypted && !drmInfos.length && !aesEncrypted) {
       throw new shaka.util.Error(
@@ -2613,8 +2669,7 @@ shaka.hls.HlsParser = class {
         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
 
     const {segments, bandwidth} = this.createSegments_(
-        playlist, stream, mediaSequenceToStartTime, mediaVariables, getUris,
-        type);
+        playlist, stream, mediaSequenceToStartTime, variables, getUris, type);
     if (bandwidth) {
       stream.bandwidth = bandwidth;
     }
@@ -2797,6 +2852,7 @@ shaka.hls.HlsParser = class {
       spatialAudio,
       closedCaptions,
       hdr: undefined,
+      colorGamut: undefined,
       videoLayout: undefined,
       tilesLayout: undefined,
       accessibilityPurpose: accessibilityPurpose,
@@ -3973,16 +4029,18 @@ shaka.hls.HlsParser = class {
    * @param {?string} frameRate
    * @param {?string} videoRange
    * @param {?string} videoLayout
+   * @param {?string} colorGamut
    * @private
    */
   addVideoAttributes_(stream, width, height, frameRate, videoRange,
-      videoLayout) {
+      videoLayout, colorGamut) {
     if (stream) {
       stream.width = Number(width) || undefined;
       stream.height = Number(height) || undefined;
       stream.frameRate = Number(frameRate) || undefined;
       stream.hdr = videoRange || undefined;
       stream.videoLayout = videoLayout || undefined;
+      stream.colorGamut = colorGamut || undefined;
     }
   }