shaka-player 4.2.3 → 4.3.0

package/lib/media/streaming_engine.js

@@ -24,6 +24,7 @@ goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IDestroyable');
+goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Parser');
@@ -77,6 +78,9 @@ shaka.media.StreamingEngine = class {
     /** @private {?shaka.extern.Stream} */
     this.currentTextStream_ = null;
 
+    /** @private {boolean} */
+    this.parsedPrftEventRaised_ = false;
+
     /**
      * Maps a content type, e.g., 'audio', 'video', or 'text', to a MediaState.
      *
@@ -780,9 +784,9 @@ shaka.media.StreamingEngine = class {
 
     // Init MediaSourceEngine.
     const mediaSourceEngine = this.playerInterface_.mediaSourceEngine;
-    const forceTransmuxTS = this.config_.forceTransmuxTS;
+    const forceTransmux = this.config_.forceTransmux;
 
-    await mediaSourceEngine.init(streamsByType, forceTransmuxTS,
+    await mediaSourceEngine.init(streamsByType, forceTransmux,
         this.manifest_.sequenceMode);
     this.destroyer_.ensureNotDestroyed();
 
@@ -1370,7 +1374,8 @@ shaka.media.StreamingEngine = class {
           JSON.stringify(buffered));
 
       if (!mediaState.waitingToClearBuffer) {
-        this.playerInterface_.onSegmentAppended();
+        this.playerInterface_.onSegmentAppended(
+            reference.startTime, reference.endTime, mediaState.type);
       }
 
       // Update right away.
@@ -1403,16 +1408,6 @@ shaka.media.StreamingEngine = class {
         this.mediaStates_.delete(ContentType.TEXT);
       } else if (error.code == shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR) {
         this.handleQuotaExceeded_(mediaState, error);
-      } else if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS &&
-          error.data && error.data[1] == 404) {
-        // The segment could not be found, does not exist, or is not available.
-        // In any case just try again.
-        // The current segment is not available. Schedule another update to
-        // fetch the segment again.
-        shaka.log.v2(logPrefix, 'segment not available.');
-        mediaState.performingUpdate = false;
-        mediaState.updateTimer = null;
-        this.scheduleUpdate_(mediaState, 1);
       } else {
         shaka.log.error(logPrefix, 'failed fetch and append: code=' +
             error.code);
@@ -1455,9 +1450,10 @@ shaka.media.StreamingEngine = class {
 
   /**
    * Clear per-stream error states and retry any failed streams.
+   * @param {number} delaySeconds
    * @return {boolean} False if unable to retry.
    */
-  retry() {
+  retry(delaySeconds) {
     if (this.destroyer_.destroyed()) {
       shaka.log.error('Unable to retry after StreamingEngine is destroyed!');
       return false;
@@ -1474,7 +1470,7 @@ shaka.media.StreamingEngine = class {
       if (mediaState.hasError) {
         shaka.log.info(logPrefix, 'Retrying after failure...');
         mediaState.hasError = false;
-        this.scheduleUpdate_(mediaState, 0.1);
+        this.scheduleUpdate_(mediaState, delaySeconds);
       }
     }
 
@@ -1635,6 +1631,17 @@ shaka.media.StreamingEngine = class {
           try {
             const initSegment = await fetchInit;
             this.destroyer_.ensureNotDestroyed();
+
+            const parser = new shaka.util.Mp4Parser();
+            const Mp4Parser = shaka.util.Mp4Parser;
+            parser.box('moov', Mp4Parser.children)
+                .box('trak', Mp4Parser.children)
+                .box('mdia', Mp4Parser.children)
+                .fullBox('mdhd', (box) => {
+                  this.parseMDHD_(reference, box);
+                })
+                .parse(initSegment);
+
             shaka.log.v1(logPrefix, 'appending init segment');
             const hasClosedCaptions = mediaState.stream.closedCaptions &&
                 mediaState.stream.closedCaptions.size > 0;
@@ -1674,15 +1681,36 @@ shaka.media.StreamingEngine = class {
 
     const hasClosedCaptions = stream.closedCaptions &&
         stream.closedCaptions.size > 0;
-    if ((stream.emsgSchemeIdUris != null &&
-        stream.emsgSchemeIdUris.length > 0) ||
-        this.config_.dispatchAllEmsgBoxes) {
-      new shaka.util.Mp4Parser()
+
+    let parser;
+    const hasEmsg = ((stream.emsgSchemeIdUris != null &&
+      stream.emsgSchemeIdUris.length > 0) ||
+      this.config_.dispatchAllEmsgBoxes);
+    const shouldParsePrftBox =
+      (this.config_.parsePrftBox && !this.parsedPrftEventRaised_);
+
+    if (hasEmsg || shouldParsePrftBox) {
+      parser = new shaka.util.Mp4Parser();
+    }
+
+    if (hasEmsg) {
+      parser
           .fullBox(
               'emsg',
               (box) => this.parseEMSG_(
-                  reference, stream.emsgSchemeIdUris, box))
-          .parse(segment);
+                  reference, stream.emsgSchemeIdUris, box));
+    }
+
+    if (shouldParsePrftBox) {
+      parser
+          .fullBox(
+              'prft',
+              (box) => this.parsePrft_(
+                  reference, box));
+    }
+
+    if (hasEmsg || shouldParsePrftBox) {
+      parser.parse(segment);
     }
 
     await this.evict_(mediaState, presentationTime);
@@ -1778,6 +1806,21 @@ 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 {
         /** @type {shaka.extern.EmsgInfo} */
         const emsg = {
@@ -1801,6 +1844,77 @@ shaka.media.StreamingEngine = class {
     }
   }
 
+  /**
+   * Parse MDHD box.
+   * @param {!shaka.media.SegmentReference} reference
+   * @param {!shaka.extern.ParsedBox} box
+   * @private
+   */
+  parseMDHD_(reference, box) {
+    const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
+        box.reader || 0, box.version || 0);
+    reference.initSegmentReference.timescale = parsedMDHDBox.timescale;
+  }
+
+  /**
+   * Parse PRFT box.
+   * @param {!shaka.media.SegmentReference} reference
+   * @param {!shaka.extern.ParsedBox} box
+   * @private
+   */
+  parsePrft_(reference, box) {
+    if (this.parsedPrftEventRaised_ ||
+      !reference.initSegmentReference.timescale) {
+      return;
+    }
+    box.reader.readUint32(); // Ignore referenceTrackId
+    const ntpTimestampSec = box.reader.readUint32();
+    const ntpTimestampFrac = box.reader.readUint32();
+    const ntpTimestamp = ntpTimestampSec * 1000 +
+        ntpTimestampFrac / 2**32 * 1000;
+
+    let mediaTime;
+    if (box.version === 0) {
+      mediaTime = box.reader.readUint32();
+    } else {
+      try {
+        mediaTime = box.reader.readUint64();
+      } catch (e) {
+        shaka.log.warning('parsePrft_: parsing mediatime resulted in a '+
+          'MEDIA.JS_INTEGER_OVERFLOW exception');
+        this.parsedPrftEventRaised_ = true;
+        return;
+      }
+    }
+
+    const timescale = reference.initSegmentReference.timescale;
+    const wallClockTime = this.convertNtp(ntpTimestamp);
+    const programStartDate = new Date(wallClockTime -
+      (mediaTime / timescale) * 1000);
+    const prftInfo = {
+      wallClockTime,
+      programStartDate,
+    };
+
+    const eventName = shaka.util.FakeEvent.EventName.Prft;
+    const data = (new Map()).set('detail', prftInfo);
+    const event = new shaka.util.FakeEvent(
+        eventName, data);
+    this.playerInterface_.onEvent(event);
+    this.parsedPrftEventRaised_ = true;
+  }
+
+
+  /**
+     * Convert Ntp ntpTimeStamp to UTC Time
+     *
+     * @param {number} ntpTimeStamp
+     * @return {number} utcTime
+     */
+  convertNtp(ntpTimeStamp) {
+    const start = new Date(Date.UTC(1900, 0, 1, 0, 0, 0));
+    return new Date(start.getTime() + ntpTimeStamp).getTime();
+  }
 
   /**
    * Evicts media to meet the max buffer behind limit.
@@ -2080,10 +2194,12 @@ shaka.media.StreamingEngine = class {
  *   onError: function(!shaka.util.Error),
  *   onEvent: function(!Event),
  *   onManifestUpdate: function(),
- *   onSegmentAppended: function(),
+ *   onSegmentAppended: function(number, number,
+ *     !shaka.util.ManifestParserUtils.ContentType),
  *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference),
  *   beforeAppendSegment: function(
- *     shaka.util.ManifestParserUtils.ContentType,!BufferSource):Promise
+ *     shaka.util.ManifestParserUtils.ContentType,!BufferSource):Promise,
+ *   onMetadata: !function(!Array.<shaka.extern.ID3Metadata>, number, ?number)
  * }}
  *
  * @property {function():number} getPresentationTime
@@ -2106,14 +2222,19 @@ shaka.media.StreamingEngine = class {
  *   Called when an event occurs that should be sent to the app.
  * @property {function()} onManifestUpdate
  *   Called when an embedded 'emsg' box should trigger a manifest update.
- * @property {function()} onSegmentAppended
+ * @property {function(number, number,
+ *   !shaka.util.ManifestParserUtils.ContentType)} onSegmentAppended
  *   Called after a segment is successfully appended to a MediaSource.
+ *   The parameters are the start and end time.
  * @property
  *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
  *   Called when an init segment is appended to a MediaSource.
  * @property {!function(shaka.util.ManifestParserUtils.ContentType,
  *   !BufferSource):Promise} beforeAppendSegment
  *   A function called just before appending to the source buffer.
+ * @property
+ *  {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)} onMetadata
+ *   Called when an ID3 is found in a EMSG.
  */
 shaka.media.StreamingEngine.PlayerInterface;
 

package/lib/media/transmuxer.js

@@ -18,13 +18,18 @@ goog.require('shaka.dependencies');
 
 /**
  * Transmuxer provides all operations for transmuxing from Transport
- * Stream to MP4.
+ * Stream or AAC to MP4.
  *
  * @implements {shaka.util.IDestroyable}
  */
 shaka.media.Transmuxer = class {
-  /** */
-  constructor() {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {
+    /** @private {string} */
+    this.originalMimeType_ = mimeType;
+
     /** @private {?muxjs} */
     this.muxjs_ = shaka.dependencies.muxjs();
 
@@ -42,9 +47,6 @@ shaka.media.Transmuxer = class {
     /** @private {!Array.<muxjs.mp4.ClosedCaption>} */
     this.captions_ = [];
 
-    /** @private {!Array.<muxjs.mp4.Metadata>} */
-    this.metadata_ = [];
-
     /** @private {boolean} */
     this.isTransmuxing_ = false;
 
@@ -64,7 +66,8 @@ shaka.media.Transmuxer = class {
 
 
   /**
-   * Check if the content type is Transport Stream, and if muxjs is loaded.
+   * Check if the content type is Transport Stream or AAC, and if muxjs is
+   * loaded.
    * @param {string} mimeType
    * @param {string=} contentType
    * @return {boolean}
@@ -72,41 +75,88 @@ shaka.media.Transmuxer = class {
   static isSupported(mimeType, contentType) {
     const Transmuxer = shaka.media.Transmuxer;
 
-    if (!shaka.dependencies.muxjs() || !Transmuxer.isTsContainer(mimeType)) {
+    const isTs = Transmuxer.isTsContainer_(mimeType);
+    const isAac = Transmuxer.isAacContainer_(mimeType);
+
+    if (!shaka.dependencies.muxjs() || (!isTs && !isAac)) {
       return false;
     }
 
+    if (isAac) {
+      return MediaSource.isTypeSupported(Transmuxer.convertAacCodecs_());
+    }
+
     if (contentType) {
       return MediaSource.isTypeSupported(
-          Transmuxer.convertTsCodecs(contentType, mimeType));
+          Transmuxer.convertTsCodecs_(contentType, mimeType));
     }
 
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    const audioMime = Transmuxer.convertTsCodecs(ContentType.AUDIO, mimeType);
-    const videoMime = Transmuxer.convertTsCodecs(ContentType.VIDEO, mimeType);
+    const audioMime = Transmuxer.convertTsCodecs_(ContentType.AUDIO, mimeType);
+    const videoMime = Transmuxer.convertTsCodecs_(ContentType.VIDEO, mimeType);
     return MediaSource.isTypeSupported(audioMime) ||
         MediaSource.isTypeSupported(videoMime);
   }
 
 
+  /**
+   * Check if the mimetype is 'audio/aac'.
+   * @param {string} mimeType
+   * @return {boolean}
+   * @private
+   */
+  static isAacContainer_(mimeType) {
+    return mimeType.toLowerCase().split(';')[0] == 'audio/aac';
+  }
+
+
   /**
    * Check if the mimetype contains 'mp2t'.
    * @param {string} mimeType
    * @return {boolean}
+   * @private
    */
-  static isTsContainer(mimeType) {
+  static isTsContainer_(mimeType) {
     return mimeType.toLowerCase().split(';')[0].split('/')[1] == 'mp2t';
   }
 
 
+  /**
+   * For any stream, convert its codecs to MP4 codecs.
+   * @param {string} contentType
+   * @param {string} mimeType
+   * @return {string}
+   */
+  static convertCodecs(contentType, mimeType) {
+    const Transmuxer = shaka.media.Transmuxer;
+    if (Transmuxer.isAacContainer_(mimeType)) {
+      return Transmuxer.convertAacCodecs_();
+    } else if (Transmuxer.isTsContainer_(mimeType)) {
+      return Transmuxer.convertTsCodecs_(contentType, mimeType);
+    }
+    return mimeType;
+  }
+
+
+  /**
+   * For aac stream, convert its codecs to MP4 codecs.
+   * @return {string}
+   * @private
+   */
+  static convertAacCodecs_() {
+    return 'audio/mp4; codecs="mp4a.40.2"';
+  }
+
+
   /**
    * For transport stream, convert its codecs to MP4 codecs.
    * @param {string} contentType
    * @param {string} tsMimeType
    * @return {string}
+   * @private
    */
-  static convertTsCodecs(contentType, tsMimeType) {
+  static convertTsCodecs_(contentType, tsMimeType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     let mp4MimeType = tsMimeType.replace(/mp2t/i, 'mp4');
     if (contentType == ContentType.AUDIO) {
@@ -148,12 +198,20 @@ shaka.media.Transmuxer = class {
   }
 
 
+  /**
+   * Returns the original mimetype of the transmuxer.
+   * @return {string}
+   */
+  getOrginalMimeType() {
+    return this.originalMimeType_;
+  }
+
+
   /**
    * Transmux from Transport stream to MP4, using the mux.js library.
    * @param {BufferSource} data
    * @return {!Promise.<{data: !Uint8Array,
-   *                     captions: !Array.<!muxjs.mp4.ClosedCaption>,
-   *                     metadata: !Array.<!Object>}>}
+   *                     captions: !Array.<!muxjs.mp4.ClosedCaption>}>}
    */
   transmux(data) {
     goog.asserts.assert(!this.isTransmuxing_,
@@ -162,7 +220,6 @@ shaka.media.Transmuxer = class {
     this.transmuxPromise_ = new shaka.util.PublicPromise();
     this.transmuxedData_ = [];
     this.captions_ = [];
-    this.metadata_ = [];
 
     const dataArray = shaka.util.BufferUtils.toUint8(data);
     this.muxTransmuxer_.push(dataArray);
@@ -182,6 +239,12 @@ shaka.media.Transmuxer = class {
     return this.transmuxPromise_;
   }
 
+  /**
+   * Reset captions from Transport stream to MP4, using the mux.js library.
+  */
+  resetCaptions() {
+    this.muxTransmuxer_.resetCaptions();
+  }
 
   /**
    * Handles the 'data' event of the transmuxer.
@@ -194,7 +257,6 @@ shaka.media.Transmuxer = class {
    */
   onTransmuxed_(segment) {
     this.captions_ = segment.captions;
-    this.metadata_ = segment.metadata;
     this.transmuxedData_.push(
         shaka.util.Uint8ArrayUtils.concat(segment.initSegment, segment.data));
   }
@@ -209,7 +271,6 @@ shaka.media.Transmuxer = class {
     const output = {
       data: shaka.util.Uint8ArrayUtils.concat(...this.transmuxedData_),
       captions: this.captions_,
-      metadata: this.metadata_,
     };
 
     this.transmuxPromise_.resolve(output);

package/lib/offline/storage.js

@@ -1170,6 +1170,7 @@ shaka.offline.Storage = class {
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
+      newDrmInfo: (stream) => {},
     };
 
     parser.configure(config.manifest);