shaka-player 4.3.7 → 4.3.8

package/docs/tutorials/drm-config.md

@@ -59,15 +59,18 @@ If this is the only `<ContentProtection>` element in the manifest, Shaka will
 try all key systems it knows. (Based on keySystemsByURI in
 {@linksource shaka.extern.DashManifestConfiguration}.)
 
-Through `player.configure()`, you can change the dash key systems mapping by
+Through `player.configure()`, you can update the dash key systems mapping by
 scheme URI:
+
 ```js
 player.configure({
-  dash: {
-    keySystemsByURI: {
-      'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
-      'urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
-    }
+  manifest: {
+    dash: {
+      keySystemsByURI: {
+        'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
+        'urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
+      }
+  }
   }
 });
 ```

package/externs/ima.js

@@ -513,6 +513,14 @@ google.ima.dai.api.StreamRequest.prototype.streamActivityMonitorId;
 google.ima.dai.api.StreamRequest.prototype.format;
 
 
+/**
+ * @type {Object.<
+ *   google.ima.dai.api.OmidVerificationVendor,
+ *   (google.ima.dai.api.OmidAccessMode | undefined)>}
+ */
+google.ima.dai.api.StreamRequest.prototype.omidAccessModeRules;
+
+
 /**
  * @enum {string}
  */
@@ -599,3 +607,29 @@ google.ima.dai.api.StreamEvent.Type = {
   SKIPPED: 'skip',
   VIDEO_CLICKED: 'videoClicked',
 };
+
+
+/**
+ * @enum {number}
+ */
+google.ima.dai.api.OmidVerificationVendor = {
+  OTHER: 1,
+  MOAT: 2,
+  DOUBLEVERIFY: 3,
+  INTEGRAL_AD_SCIENCE: 4,
+  PIXELATE: 5,
+  NIELSEN: 6,
+  COMSCORE: 7,
+  MEETRICS: 8,
+  GOOGLE: 9,
+};
+
+
+/**
+ * @enum {string}
+ */
+google.ima.dai.api.OmidAccessMode = {
+  FULL: 'full',
+  DOMAIN: 'domain',
+  LIMITED: 'limited',
+};

package/lib/abr/simple_abr_manager.js

@@ -54,7 +54,7 @@ shaka.abr.SimpleAbrManager = class {
     // of connectivity changes.
     if (navigator.connection && navigator.connection.addEventListener) {
       this.onNetworkInformationChange_ = () => {
-        if (this.config_.useNetworkInformation && this.enabled_) {
+        if (this.enabled_ && this.config_.useNetworkInformation) {
           this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
           if (this.config_) {
             this.bandwidthEstimator_.configure(this.config_.advanced);

package/lib/cea/mp4_cea_parser.js

@@ -163,15 +163,17 @@ shaka.cea.Mp4CeaParser = class {
     // Fields that are found in MOOF boxes
     let defaultSampleDuration = this.defaultSampleDuration_;
     let defaultSampleSize = this.defaultSampleSize_;
-    let sampleData = [];
-    let moofOffset = null;
-    let trunOffset = null;
+    let moofOffset = 0;
+    /** @type {!Array<shaka.util.ParsedTRUNBox>} */
+    let parsedTRUNs = [];
     let baseMediaDecodeTime = null;
     let timescale = shaka.cea.ICeaParser.DEFAULT_TIMESCALE_VALUE;
 
     new Mp4Parser()
         .box('moof', (box) => {
           moofOffset = box.start;
+          // trun box parsing is reset on each moof.
+          parsedTRUNs = [];
           Mp4Parser.children(box);
         })
         .box('traf', Mp4Parser.children)
@@ -182,11 +184,8 @@ shaka.cea.Mp4CeaParser = class {
 
           const parsedTRUN = shaka.util.Mp4BoxParsers.parseTRUN(
               box.reader, box.version, box.flags);
-
-          sampleData = parsedTRUN.sampleData;
-          trunOffset = parsedTRUN.dataOffset;
+          parsedTRUNs.push(parsedTRUN);
         })
-
         .fullBox('tfhd', (box) => {
           goog.asserts.assert(
               box.flags != null,
@@ -210,7 +209,6 @@ shaka.cea.Mp4CeaParser = class {
             timescale = this.trackIdToTimescale_.get(trackId);
           }
         })
-
         .fullBox('tfdt', (box) => {
           goog.asserts.assert(
               box.version != null,
@@ -223,16 +221,19 @@ shaka.cea.Mp4CeaParser = class {
         })
         .box('mdat', (box) => {
           if (baseMediaDecodeTime === null) {
-            // This field should have been populated by
-            // the Base Media Decode time in the TFDT box
+            // This field should have been populated by the Base Media Decode
+            // Time in the tfdt box.
+            shaka.log.alwaysWarn(
+                'Unable to find base media decode time for CEA captions!');
             throw new shaka.util.Error(
                 shaka.util.Error.Severity.CRITICAL,
                 shaka.util.Error.Category.TEXT,
                 shaka.util.Error.Code.INVALID_MP4_CEA);
           }
-          const offset = (moofOffset || 0) + (trunOffset || 0) - box.start - 8;
+
+          const offset = moofOffset - box.start - 8;
           this.parseMdat_(box.reader, baseMediaDecodeTime, timescale,
-              defaultSampleDuration, defaultSampleSize, offset, sampleData,
+              defaultSampleDuration, defaultSampleSize, offset, parsedTRUNs,
               captionPackets);
         })
         .parse(mediaSegment, /* partialOkay= */ false);
@@ -248,12 +249,12 @@ shaka.cea.Mp4CeaParser = class {
    * @param {number} defaultSampleDuration
    * @param {number} defaultSampleSize
    * @param {number} offset
-   * @param {!Array<shaka.util.ParsedTRUNSample>} sampleData
+   * @param {!Array<shaka.util.ParsedTRUNBox>} parsedTRUNs
    * @param {!Array<!shaka.cea.ICeaParser.CaptionPacket>} captionPackets
    * @private
    */
   parseMdat_(reader, time, timescale, defaultSampleDuration,
-      defaultSampleSize, offset, sampleData, captionPackets) {
+      defaultSampleSize, offset, parsedTRUNs, captionPackets) {
     const BitstreamFormat = shaka.cea.Mp4CeaParser.BitstreamFormat;
     const ICeaParser = shaka.cea.ICeaParser;
     let sampleIndex = 0;
@@ -264,11 +265,16 @@ shaka.cea.Mp4CeaParser = class {
     // composition time offset, we default to 0.
     let sampleSize = defaultSampleSize;
 
+    // Combine all sample data.  This assumes that the samples described across
+    // multiple trun boxes are still continuous in the mdat box.
+    const sampleDatas = parsedTRUNs.map((t) => t.sampleData);
+    const sampleData = [].concat(...sampleDatas);
+
     if (sampleData.length) {
       sampleSize = sampleData[0].sampleSize || defaultSampleSize;
     }
 
-    reader.skip(offset);
+    reader.skip(offset + parsedTRUNs[0].dataOffset);
 
     while (reader.hasMoreData()) {
       const naluSize = reader.readUint32();
@@ -301,7 +307,7 @@ shaka.cea.Mp4CeaParser = class {
       if (isSeiMessage) {
         let timeOffset = 0;
 
-        if (sampleData.length > sampleIndex) {
+        if (sampleIndex < sampleData.length) {
           timeOffset = sampleData[sampleIndex].sampleCompositionTimeOffset || 0;
         }
 
@@ -324,7 +330,7 @@ shaka.cea.Mp4CeaParser = class {
       }
       sampleSize -= (naluSize + 4);
       if (sampleSize == 0) {
-        if (sampleData.length > sampleIndex) {
+        if (sampleIndex < sampleData.length) {
           time += sampleData[sampleIndex].sampleDuration ||
               defaultSampleDuration;
         } else {
@@ -333,7 +339,7 @@ shaka.cea.Mp4CeaParser = class {
 
         sampleIndex++;
 
-        if (sampleData.length > sampleIndex) {
+        if (sampleIndex < sampleData.length) {
           sampleSize = sampleData[sampleIndex].sampleSize || defaultSampleSize;
         } else {
           sampleSize = defaultSampleSize;

package/lib/dash/dash_parser.js

@@ -886,7 +886,19 @@ shaka.dash.DashParser = class {
 
     // Parallel for HLS VIDEO-RANGE as defined in DASH-IF IOP v4.3 6.2.5.1.
     let videoRange;
-    const videoRangeScheme = 'urn:mpeg:mpegB:cicp:TransferCharacteristics';
+
+    // Ref. https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf
+    // If signaled, a Supplemental or Essential Property descriptor
+    // shall be used, with the schemeIdUri set to
+    // urn:mpeg:mpegB:cicp:<Parameter> as defined in
+    // ISO/IEC 23001-8 [49] and <Parameter> one of the
+    // following: ColourPrimaries, TransferCharacteristics,
+    // or MatrixCoefficients.
+    const scheme = 'urn:mpeg:mpegB:cicp';
+    const transferCharacteristicsScheme = `${scheme}:TransferCharacteristics`;
+    const colourPrimariesScheme = `${scheme}:ColourPrimaries`;
+    const matrixCoefficientsScheme = `${scheme}:MatrixCoefficients`;
+
     const getVideoRangeFromTransferCharacteristicCICP = (cicp) => {
       switch (cicp) {
         case 1:
@@ -912,10 +924,13 @@ shaka.dash.DashParser = class {
       const schemeId = prop.getAttribute('schemeIdUri');
       if (schemeId == 'http://dashif.org/guidelines/trickmode') {
         trickModeFor = prop.getAttribute('value');
-      } else if (schemeId == videoRangeScheme) {
+      } else if (schemeId == transferCharacteristicsScheme) {
         videoRange = getVideoRangeFromTransferCharacteristicCICP(
             parseInt(prop.getAttribute('value'), 10),
         );
+      } else if (schemeId == colourPrimariesScheme ||
+                 schemeId == matrixCoefficientsScheme) {
+        continue;
       } else {
         unrecognizedEssentialProperty = true;
       }
@@ -925,7 +940,7 @@ shaka.dash.DashParser = class {
         XmlUtils.findChildren(elem, 'SupplementalProperty');
     for (const prop of supplementalProperties) {
       const schemeId = prop.getAttribute('schemeIdUri');
-      if (schemeId == videoRangeScheme) {
+      if (schemeId == transferCharacteristicsScheme) {
         videoRange = getVideoRangeFromTransferCharacteristicCICP(
             parseInt(prop.getAttribute('value'), 10),
         );

package/lib/hls/hls_parser.js

@@ -2066,6 +2066,22 @@ shaka.hls.HlsParser = class {
     // stream is lazy-loaded.
     const mimeType = this.guessMimeTypeBeforeLoading_(type, codecs) ||
         this.guessMimeTypeFallback_(type);
+    const roles = [];
+    if (characteristics) {
+      for (const characteristic of characteristics.split(',')) {
+        roles.push(characteristic);
+      }
+    }
+
+    const kind = (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
+        shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined;
+
+    // If there are no roles, and we have defaulted to the subtitle "kind" for
+    // this track, add the implied subtitle role.
+    if (!roles.length &&
+        kind === shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE) {
+      roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
+    }
 
     return {
       id: this.globalId_++,
@@ -2074,8 +2090,7 @@ shaka.hls.HlsParser = class {
       segmentIndex: null,
       mimeType,
       codecs,
-      kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
-          shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
+      kind,
       encrypted: false,
       drmInfos: [],
       keyIds: new Set(),
@@ -2091,7 +2106,7 @@ shaka.hls.HlsParser = class {
       width: undefined,
       height: undefined,
       bandwidth: undefined,
-      roles: characteristics ? characteristics.split(',') : [],
+      roles,
       forced,
       channelsCount,
       audioSamplingRate: null,
@@ -2549,6 +2564,10 @@ shaka.hls.HlsParser = class {
       // We're interested in the duration part.
       const extinfValues = extinfTag.value.split(',');
       const duration = Number(extinfValues[0]);
+      // Skip segments without duration
+      if (duration == 0) {
+        return null;
+      }
       endTime = startTime + duration;
     } else {
       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
@@ -2729,9 +2748,9 @@ shaka.hls.HlsParser = class {
           type,
           lastDiscontinuityStartTime,
           hlsAes128Key);
-      previousReference = reference;
 
       if (reference) {
+        previousReference = reference;
         reference.discontinuitySequence = discontinuitySequence;
 
         if (this.config_.hls.ignoreManifestProgramDateTime &&

package/lib/media/drm_engine.js

@@ -354,18 +354,24 @@ shaka.media.DrmEngine = class {
       shaka.media.DrmEngine.replaceDrmInfo_(variants, servers);
     }
 
-    // Make sure all the drm infos are valid and filled in correctly.
+    /** @type {!Set<shaka.extern.DrmInfo>} */
+    const drmInfos = new Set();
     for (const variant of variants) {
-      const drmInfos = this.getVariantDrmInfos_(variant);
-      for (const info of drmInfos) {
-        shaka.media.DrmEngine.fillInDrmInfoDefaults_(
-            info,
-            shaka.util.MapUtils.asMap(this.config_.servers),
-            shaka.util.MapUtils.asMap(this.config_.advanced || {}),
-            this.config_.keySystemsMapping);
+      const variantDrmInfos = this.getVariantDrmInfos_(variant);
+      for (const info of variantDrmInfos) {
+        drmInfos.add(info);
       }
     }
 
+    for (const info of drmInfos) {
+      shaka.media.DrmEngine.fillInDrmInfoDefaults_(
+          info,
+          shaka.util.MapUtils.asMap(this.config_.servers),
+          shaka.util.MapUtils.asMap(this.config_.advanced || {}),
+          this.config_.keySystemsMapping);
+    }
+
+
     /** @type {!Map.<string, MediaKeySystemConfiguration>} */
     let configsByKeySystem;
 

package/lib/media/gap_jumping_controller.js

@@ -58,6 +58,9 @@ shaka.media.GapJumpingController = class {
     /** @private {number} */
     this.prevReadyState_ = video.readyState;
 
+    /** @private {number} */
+    this.startTime_ = 0;
+
     /** @private {number} */
     this.gapsJumped_ = 0;
 
@@ -123,6 +126,18 @@ shaka.media.GapJumpingController = class {
     this.onPollGapJump_();
   }
 
+  /**
+   * Called when playback has started and the video element is
+   * listening for seeks.
+   *
+   * @param {number} startTime
+   */
+  onStarted(startTime) {
+    if (this.video_.seeking && !this.seekingEventReceived_) {
+      this.seekingEventReceived_ = true;
+      this.startTime_ = startTime;
+    }
+  }
 
   /** Called when a seek has started. */
   onSeeking() {
@@ -164,8 +179,8 @@ shaka.media.GapJumpingController = class {
     // while paused on a livestream.  We make an exception for time 0, since we
     // may be _required_ to seek on startup before play can begin, but only if
     // autoplay is enabled.
-    if (this.video_.paused && (this.video_.currentTime != 0 ||
-      (!this.video_.autoplay && this.video_.currentTime == 0))) {
+    if (this.video_.paused && (this.video_.currentTime != this.startTime_ ||
+      (!this.video_.autoplay && this.video_.currentTime == this.startTime_))) {
       return;
     }
 
@@ -228,6 +243,13 @@ shaka.media.GapJumpingController = class {
     }
 
     this.video_.currentTime = jumpTo;
+    // This accounts for the possibility that we jump a gap at the start
+    // position but we jump _into_ another gap. By setting the start
+    // position to the new jumpTo we ensure that the check above will
+    // pass even though the video is still paused.
+    if (currentTime == this.startTime_) {
+      this.startTime_ = jumpTo;
+    }
     this.gapsJumped_++;
     this.onEvent_(
         new shaka.util.FakeEvent(shaka.util.FakeEvent.EventName.GapJumped));

package/lib/media/media_source_engine.js

@@ -582,11 +582,13 @@ shaka.media.MediaSourceEngine = class {
    * @param {boolean=} seeked True if we just seeked
    * @param {boolean=} adaptation True if we just automatically switched active
    *   variant(s).
+   * @param {boolean=} isChunkedData True if we add to the buffer from the
+   *   partial read of the segment.
    * @return {!Promise}
    */
   async appendBuffer(
       contentType, data, reference, hasClosedCaptions, seeked = false,
-      adaptation = false) {
+      adaptation = false, isChunkedData = false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
@@ -787,13 +789,13 @@ shaka.media.MediaSourceEngine = class {
     let bufferedBefore = null;
 
     await this.enqueueOperation_(contentType, () => {
-      if (goog.DEBUG && reference) {
+      if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
         bufferedBefore = this.getBuffered_(contentType);
       }
       this.append_(contentType, data);
     });
 
-    if (goog.DEBUG && reference && !reference.isPreload()) {
+    if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
       const bufferedAfter = this.getBuffered_(contentType);
       const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
           bufferedBefore, bufferedAfter);

package/lib/media/playhead.js

@@ -251,6 +251,7 @@ shaka.media.MediaSourcePlayhead = class {
     this.videoWrapper_ = new shaka.media.VideoWrapper(
         mediaElement,
         () => this.onSeeking_(),
+        (realStartTime) => this.onStarted_(realStartTime),
         this.getStartTime_(startTime));
 
     /** @type {shaka.util.Timer} */
@@ -390,6 +391,16 @@ shaka.media.MediaSourcePlayhead = class {
     }
   }
 
+  /**
+   * Called when the video element has started up and is listening for new seeks
+   *
+   * @param {number} startTime
+   * @private
+   */
+  onStarted_(startTime) {
+    this.gapController_.onStarted(startTime);
+  }
+
   /**
    * Handles when a seek happens on the video.
    *

package/lib/media/region_observer.js

@@ -27,13 +27,24 @@ shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
    * destroy the timeline.
    *
    * @param {!shaka.media.RegionTimeline} timeline
+   * @param {boolean} startsPastZero
    */
-  constructor(timeline) {
+  constructor(timeline, startsPastZero) {
     super();
 
     /** @private {shaka.media.RegionTimeline} */
     this.timeline_ = timeline;
 
+    /**
+     * Whether the asset is expected to start at a time beyond 0 seconds.
+     * For example, if the asset is a live stream.
+     * If true, we will not start polling for regions until the playhead has
+     * moved past 0 seconds, to avoid bad behaviors where the current time is
+     * briefly 0 before we have enough data to play.
+     * @private {boolean}
+     */
+    this.startsPastZero_ = startsPastZero;
+
     /**
      * A mapping between a region and where we previously were relative to it.
      * When the value here differs from what we calculate, it means we moved and
@@ -121,6 +132,13 @@ shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
   /** @override */
   poll(positionInSeconds, wasSeeking) {
     const RegionObserver = shaka.media.RegionObserver;
+    if (this.startsPastZero_ && positionInSeconds == 0) {
+      // Don't start checking regions until the timeline has begun moving.
+      return;
+    }
+    // Now that we have seen the playhead go past 0, it's okay if it goes
+    // back there (e.g. seeking back to the start).
+    this.startsPastZero_ = false;
 
     for (const region of this.timeline_.regions()) {
       const previousPosition = this.oldPosition_.get(region);

package/lib/media/streaming_engine.js

@@ -1319,7 +1319,8 @@ shaka.media.StreamingEngine = class {
             const dataToAppend = remaining.subarray(0, offset);
             remaining = remaining.subarray(offset);
             await this.append_(
-                mediaState, presentationTime, stream, reference, dataToAppend);
+                mediaState, presentationTime, stream, reference, dataToAppend,
+                /* isChunkedData= */ true);
           }
         };
 
@@ -1731,10 +1732,12 @@ shaka.media.StreamingEngine = class {
    * @param {shaka.extern.Stream} stream
    * @param {!shaka.media.SegmentReference} reference
    * @param {BufferSource} segment
+   * @param {boolean=} isChunkedData
    * @return {!Promise}
    * @private
    */
-  async append_(mediaState, presentationTime, stream, reference, segment) {
+  async append_(mediaState, presentationTime, stream, reference, segment,
+      isChunkedData = false) {
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
 
     const hasClosedCaptions = stream.closedCaptions &&
@@ -1788,7 +1791,8 @@ shaka.media.StreamingEngine = class {
         reference,
         hasClosedCaptions,
         seeked,
-        adaptation);
+        adaptation,
+        isChunkedData);
     this.destroyer_.ensureNotDestroyed();
     shaka.log.v2(logPrefix, 'appended media segment');
   }
@@ -1852,7 +1856,6 @@ shaka.media.StreamingEngine = class {
     const messageData = box.reader.readBytes(
         box.reader.getLength() - box.reader.getPosition());
 
-
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
@@ -1862,22 +1865,8 @@ shaka.media.StreamingEngine = class {
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {
         this.playerInterface_.onManifestUpdate();
-      } else if (schemeId == 'https://aomedia.org/emsg/ID3') {
-        // See https://aomediacodec.github.io/id3-emsg/
-        const frames = shaka.util.Id3Utils.getID3Frames(messageData);
-        if (frames.length && reference) {
-          /** @private {shaka.extern.ID3Metadata} */
-          const metadata = {
-            cueTime: reference.startTime,
-            data: messageData,
-            frames: frames,
-            dts: reference.startTime,
-            pts: reference.startTime,
-          };
-          this.playerInterface_.onMetadata(
-              [metadata], /* offset= */ 0, reference.endTime);
-        }
       } else {
+        // All other schemes are dispatched as a general 'emsg' event.
         /** @type {shaka.extern.EmsgInfo} */
         const emsg = {
           startTime: startTime,
@@ -1895,7 +1884,38 @@ shaka.media.StreamingEngine = class {
         const eventName = shaka.util.FakeEvent.EventName.Emsg;
         const data = (new Map()).set('detail', emsg);
         const event = new shaka.util.FakeEvent(eventName, data);
+        // A user can call preventDefault() on a cancelable event.
+        event.cancelable = true;
+
         this.playerInterface_.onEvent(event);
+
+        if (event.defaultPrevented) {
+          // If the caller uses preventDefault() on the 'emsg' event, don't
+          // process any further, and don't generate an ID3 'metadata' event
+          // for the same data.
+          return;
+        }
+
+        // Additionally, ID3 events generate a 'metadata' event.  This is a
+        // pre-parsed version of the metadata blob already dispatched in the
+        // 'emsg' event.
+        if (schemeId == 'https://aomedia.org/emsg/ID3' ||
+            schemeId == 'https://developer.apple.com/streaming/emsg-id3') {
+          // See https://aomediacodec.github.io/id3-emsg/
+          const frames = shaka.util.Id3Utils.getID3Frames(messageData);
+          if (frames.length && reference) {
+            /** @private {shaka.extern.ID3Metadata} */
+            const metadata = {
+              cueTime: reference.startTime,
+              data: messageData,
+              frames: frames,
+              dts: reference.startTime,
+              pts: reference.startTime,
+            };
+            this.playerInterface_.onMetadata(
+                [metadata], /* offset= */ 0, reference.endTime);
+          }
+        }
       }
     }
   }

package/lib/media/video_wrapper.js

@@ -27,15 +27,19 @@ shaka.media.VideoWrapper = class {
   /**
    * @param {!HTMLMediaElement} video
    * @param {function()} onSeek Called when the video seeks.
+   * @param {function(number)} onStarted Called when the video has started.
    * @param {number} startTime The time to start at.
    */
-  constructor(video, onSeek, startTime) {
+  constructor(video, onSeek, onStarted, startTime) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
     /** @private {function()} */
     this.onSeek_ = onSeek;
 
+    /** @private {function(number)} */
+    this.onStarted_ = onStarted;
+
     /** @private {number} */
     this.startTime_ = startTime;
 
@@ -165,6 +169,7 @@ shaka.media.VideoWrapper = class {
     this.started_ = true;
 
     this.eventManager_.listen(this.video_, 'seeking', () => this.onSeek_());
+    this.onStarted_(this.video_.currentTime);
   }
 };