shaka-player 4.7.11 → 4.7.13

package/lib/offline/manifest_converter.js

@@ -14,6 +14,7 @@ goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.offline.OfflineUri');
 goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.MimeUtils');
 
 
 /**
@@ -169,7 +170,7 @@ shaka.offline.ManifestConverter = class {
   fromStreamDB_(streamDB, timeline) {
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const segments = streamDB.segments.map(
-        (segment, index) => this.fromSegmentDB_(index, segment));
+        (segment, index) => this.fromSegmentDB_(index, segment, streamDB));
 
     timeline.notifySegments(segments);
 
@@ -212,6 +213,8 @@ shaka.offline.ManifestConverter = class {
       accessibilityPurpose: null,
       external: streamDB.external,
       fastSwitching: streamDB.fastSwitching,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          streamDB.mimeType, streamDB.codecs)]),
     };
 
     return stream;
@@ -220,10 +223,11 @@ shaka.offline.ManifestConverter = class {
   /**
    * @param {number} index
    * @param {shaka.extern.SegmentDB} segmentDB
+   * @param {shaka.extern.StreamDB} streamDB
    * @return {!shaka.media.SegmentReference}
    * @private
    */
-  fromSegmentDB_(index, segmentDB) {
+  fromSegmentDB_(index, segmentDB, streamDB) {
     /** @type {!shaka.offline.OfflineUri} */
     const uri = shaka.offline.OfflineUri.segment(
         this.mechanism_, this.cell_, segmentDB.dataKey);
@@ -231,7 +235,7 @@ shaka.offline.ManifestConverter = class {
     const initSegmentReference = segmentDB.initSegmentKey != null ?
         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
 
-    return new shaka.media.SegmentReference(
+    const ref = new shaka.media.SegmentReference(
         segmentDB.startTime,
         segmentDB.endTime,
         () => [uri.toString()],
@@ -243,6 +247,9 @@ shaka.offline.ManifestConverter = class {
         segmentDB.appendWindowEnd,
         /* partialReferences= */ [],
         segmentDB.tilesLayout || '');
+    ref.mimeType = segmentDB.mimeType || streamDB.mimeType || '';
+    ref.codecs = segmentDB.codecs || streamDB.codecs || '';
+    return ref;
   }
 
   /**

package/lib/offline/storage.js

@@ -1389,6 +1389,8 @@ shaka.offline.Storage = class {
         tilesLayout: segment.tilesLayout,
         pendingSegmentRefId,
         dataKey: 0,
+        mimeType: segment.mimeType,
+        codecs: segment.codecs,
       };
       streamDb.segments.push(segmentDB);
       groupId = (groupId + 1) % numberOfParallelDownloads;

package/lib/player.js

@@ -2174,12 +2174,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         accessibilityPurpose: null,
         external: false,
         fastSwitching: false,
+        fullMimeTypes: new Set(),
       },
       bandwidth: 100,
       allowedByApplication: true,
       allowedByKeySystem: true,
       decodingInfos: [],
     };
+    variant.video.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
+        variant.video.mimeType, variant.video.codecs));
 
     this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
     await this.drmEngine_.initForPlayback(
@@ -3620,12 +3623,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const currentTime = this.video_.currentTime;
         const seekRange = this.seekRange();
         const safeSeekOffset = this.config_.streaming.safeSeekOffset;
+
+        // Cancel trick play if we hit the beginning or end of the seekable
+        // (Sub-second accuracy not required here)
         if (rate > 0) {
-          if (currentTime >= seekRange.end) {
+          if (Math.floor(currentTime) >= Math.floor(seekRange.end)) {
             this.cancelTrickPlay();
           }
         } else {
-          if (currentTime <= (seekRange.start + safeSeekOffset)) {
+          if (Math.floor(currentTime) <=
+              Math.floor(seekRange.start + safeSeekOffset)) {
             this.cancelTrickPlay();
           }
         }
@@ -4494,7 +4501,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (this.manifest_) {
       const timeline = this.manifest_.presentationTimeline;
-      const startTime = timeline.getPresentationStartTime();
+      const startTime = timeline.getInitialProgramDateTime() ||
+          timeline.getPresentationStartTime();
       return new Date(/* ms= */ (startTime + presentationTime) * 1000);
     } else if (this.video_ && this.video_.getStartDate) {
       // Apple's native HLS gives us getStartDate(), which is only available if
@@ -4803,6 +4811,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       accessibilityPurpose: null,
       external: true,
       fastSwitching: false,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          mimeType || '', codec || '')]),
     };
 
     const fullMimeType = shaka.util.MimeUtils.getFullType(
@@ -4959,6 +4969,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       accessibilityPurpose: null,
       external: true,
       fastSwitching: false,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          mimeType || '', '')]),
     };
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
@@ -5389,6 +5401,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               accessibilityPurpose: null,
               external: false,
               fastSwitching: false,
+              fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+                  mimeType, '')]),
             };
             manifest.textStreams.push(textStream);
             closedCaptionsSet.add(id);
@@ -6099,6 +6113,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // change.
     if (this.playhead_) {
       this.playhead_.notifyOfBufferingChange();
+      // Skip the initial buffer gap
+      const startTime = this.mediaSourceEngine_.bufferStart(contentType);
+      if (
+        !this.isLive() &&
+        // If not paused then GapJumpingController will handle this gap.
+        this.video_.paused &&
+        startTime != null &&
+        startTime > 0 &&
+        this.playhead_.getTime() < startTime
+      ) {
+        this.playhead_.setStartTime(startTime);
+      }
     }
     this.pollBufferState_();
 
@@ -6934,7 +6960,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.7.11' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.7.13' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -300,7 +300,17 @@ shaka.polyfill.MediaCapabilities = class {
       // this query is specifically for HDR.
       displayType += '; eotf=smpte2084';
     }
-    return cast.__platform__.canDisplayType(displayType);
+    let result = false;
+    if (displayType in shaka.polyfill.MediaCapabilities
+        .memoizedCanDisplayTypeRequests_) {
+      result = shaka.polyfill.MediaCapabilities
+          .memoizedCanDisplayTypeRequests_[displayType];
+    } else {
+      result = cast.__platform__.canDisplayType(displayType);
+      shaka.polyfill.MediaCapabilities
+          .memoizedCanDisplayTypeRequests_[displayType] = result;
+    }
+    return result;
   }
 
   /**
@@ -337,6 +347,15 @@ shaka.polyfill.MediaCapabilities.originalMcap = null;
  */
 shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
 
+/**
+ * A cache that stores the canDisplayType result of calling
+ * `cast.__platform__.canDisplayType`.
+ *
+ * @type {(Object<(!string), (!boolean)>)}
+ * @export
+ */
+shaka.polyfill.MediaCapabilities.memoizedCanDisplayTypeRequests_ = {};
+
 // Install at a lower priority than MediaSource polyfill, so that we have
 // MediaSource available first.
 shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);

package/lib/polyfill/mediasource.js

@@ -30,14 +30,8 @@ shaka.polyfill.MediaSource = class {
     // platform detection tricks to decide which patches to install.
     const safariVersion = shaka.util.Platform.safariVersion();
 
-    if (!window.MediaSource) {
+    if (!window.MediaSource && !window.ManagedMediaSource) {
       shaka.log.info('No MSE implementation available.');
-    } else if (shaka.util.Platform.isChromecast()) {
-      shaka.log.info('Patching Chromecast MSE bugs.');
-      // Chromecast fails on some TS content, even though it is supposed to
-      // support it.  Better to transmux.
-      // See https://github.com/shaka-project/shaka-player/issues/5278
-      shaka.polyfill.MediaSource.rejectContainer_('mp2t');
     } else if (safariVersion) {
       // NOTE:  shaka.Player.isBrowserSupported() has its own restrictions on
       // Safari version.
@@ -73,11 +67,6 @@ shaka.polyfill.MediaSource = class {
         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
         shaka.polyfill.MediaSource.stubAbort_();
       }
-    } else if (shaka.util.Platform.isEdge()) {
-      shaka.log.info('Rejecting TS container.');
-      // TS content is broken on Edge in general.
-      // See https://github.com/shaka-project/shaka-player/issues/4955
-      shaka.polyfill.MediaSource.rejectContainer_('mp2t');
     } else if (shaka.util.Platform.isTizen2() ||
         shaka.util.Platform.isTizen3() ||
         shaka.util.Platform.isTizen4()) {
@@ -90,6 +79,14 @@ shaka.polyfill.MediaSource = class {
       shaka.log.info('Using native MSE as-is.');
     }
 
+    if (window.MediaSource || window.ManagedMediaSource) {
+      // TS content is broken on all browsers in general.
+      // See https://github.com/shaka-project/shaka-player/issues/4955
+      // See https://github.com/shaka-project/shaka-player/issues/5278
+      // See https://github.com/shaka-project/shaka-player/issues/6334
+      shaka.polyfill.MediaSource.rejectContainer_('mp2t');
+    }
+
     if (window.MediaSource &&
         MediaSource.isTypeSupported('video/webm; codecs="vp9"') &&
         !MediaSource.isTypeSupported('video/webm; codecs="vp09.00.10.08"')) {
@@ -158,12 +155,25 @@ shaka.polyfill.MediaSource = class {
    * @private
    */
   static rejectContainer_(container) {
-    const isTypeSupported = MediaSource.isTypeSupported;
+    const isTypeSupported =
+        // eslint-disable-next-line no-restricted-syntax
+        MediaSource.isTypeSupported.bind(MediaSource);
 
     MediaSource.isTypeSupported = (mimeType) => {
       const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
       return actualContainer != container && isTypeSupported(mimeType);
     };
+
+    if (window.ManagedMediaSource) {
+      const isTypeSupportedManaged =
+          // eslint-disable-next-line no-restricted-syntax
+          ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
+
+      window.ManagedMediaSource.isTypeSupported = (mimeType) => {
+        const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
+        return actualContainer != container && isTypeSupportedManaged(mimeType);
+      };
+    }
   }
 
   /**
@@ -175,12 +185,25 @@ shaka.polyfill.MediaSource = class {
    * @private
    */
   static rejectCodec_(codec) {
-    const isTypeSupported = MediaSource.isTypeSupported;
+    const isTypeSupported =
+        // eslint-disable-next-line no-restricted-syntax
+        MediaSource.isTypeSupported.bind(MediaSource);
 
     MediaSource.isTypeSupported = (mimeType) => {
       const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
       return actualCodec != codec && isTypeSupported(mimeType);
     };
+
+    if (window.ManagedMediaSource) {
+      const isTypeSupportedManaged =
+          // eslint-disable-next-line no-restricted-syntax
+          ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
+
+      window.ManagedMediaSource.isTypeSupported = (mimeType) => {
+        const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
+        return actualCodec != codec && isTypeSupportedManaged(mimeType);
+      };
+    }
   }
 
   /**

package/lib/text/vtt_text_parser.js

@@ -84,51 +84,16 @@ shaka.text.VttTextParser = class {
     // HLS content, which should use X-TIMESTAMP-MAP and periodStart instead.
     let offset = time.vttOffset;
 
-    // Only use 'X-TIMESTAMP-MAP' in sequence mode.
-    // Note that an offset based on the first video
-    // timestamp has already been extracted, and appears in periodStart.
-    if (blocks[0].includes('X-TIMESTAMP-MAP') && this.sequenceMode_) {
-      // https://bit.ly/2K92l7y
-      // The 'X-TIMESTAMP-MAP' header is used in HLS to align text with
-      // the rest of the media.
-      // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
-      // (the attributes can go in any order)
-      // where n is MPEG-2 time and m is cue time it maps to.
-      // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
-      // means an offset of 10 seconds
-      // 900000/MPEG_TIMESCALE - cue time.
-      const cueTimeMatch =
-            blocks[0].match(/LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
-
-      const mpegTimeMatch = blocks[0].match(/MPEGTS:(\d+)/m);
-      if (cueTimeMatch && mpegTimeMatch) {
-        const parser = new shaka.util.TextParser(cueTimeMatch[1]);
-        const cueTime = shaka.text.VttTextParser.parseTime_(parser);
-        if (cueTime == null) {
-          throw new shaka.util.Error(
-              shaka.util.Error.Severity.CRITICAL,
-              shaka.util.Error.Category.TEXT,
-              shaka.util.Error.Code.INVALID_TEXT_HEADER);
-        }
-
-        let mpegTime = Number(mpegTimeMatch[1]);
-        const mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
-
-        const rolloverSeconds =
-            shaka.text.VttTextParser.TS_ROLLOVER_ / mpegTimescale;
-        let segmentStart = time.segmentStart - time.periodStart;
-        while (segmentStart >= rolloverSeconds) {
-          segmentStart -= rolloverSeconds;
-          mpegTime += shaka.text.VttTextParser.TS_ROLLOVER_;
-        }
-
-        offset = time.periodStart + mpegTime / mpegTimescale - cueTime;
-      }
-    } else if (blocks[0].includes('X-TIMESTAMP-MAP') &&
+    // Only use 'X-TIMESTAMP-MAP' with HLS.  This overrides offset above.
+    if (blocks[0].includes('X-TIMESTAMP-MAP') &&
         this.manifestType_ == shaka.media.ManifestParser.HLS) {
-      // In we use HLS segments mode, with the presence of this tag we need
-      // calculate the offset from the segment startTime.
-      offset = time.segmentStart;
+      if (this.sequenceMode_) {
+        // Compute a different, rollover-based offset for sequence mode.
+        offset = this.computeHlsSequenceModeOffset_(blocks[0], time);
+      } else {
+        // Calculate the offset from the segment startTime.
+        offset = time.segmentStart;
+      }
     }
 
     // Parse VTT regions.
@@ -159,6 +124,48 @@ shaka.text.VttTextParser = class {
     return ret;
   }
 
+  /**
+   * @param {string} headerBlock Contains X-TIMESTAMP-MAP.
+   * @param {shaka.extern.TextParser.TimeContext} time
+   * @return {number}
+   * @private
+   */
+  computeHlsSequenceModeOffset_(headerBlock, time) {
+    // https://bit.ly/2K92l7y
+    // The 'X-TIMESTAMP-MAP' header is used in HLS to align text with
+    // the rest of the media.
+    // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
+    // (the attributes can go in any order)
+    // where n is MPEG-2 time and m is cue time it maps to.
+    // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
+    // means an offset of 10 seconds
+    // 900000/MPEG_TIMESCALE - cue time.
+    const cueTimeMatch = headerBlock.match(
+        /LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
+    const mpegTimeMatch = headerBlock.match(/MPEGTS:(\d+)/m);
+
+    if (!cueTimeMatch || !mpegTimeMatch) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_TEXT_HEADER);
+    }
+
+    const parser = new shaka.util.TextParser(cueTimeMatch[1]);
+    const cueTime = shaka.text.VttTextParser.parseTime_(parser);
+    if (cueTime == null) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_TEXT_HEADER);
+    }
+
+    const mpegTime = Number(mpegTimeMatch[1]);
+    const mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
+
+    return time.periodStart + mpegTime / mpegTimescale - cueTime;
+  }
+
   /**
    * Add default color
    *
@@ -1061,13 +1068,6 @@ shaka.text.VttTextParser = class {
  */
 shaka.text.VttTextParser.MPEG_TIMESCALE_ = 90000;
 
-/**
- * At this value, timestamps roll over in TS content.
- * @const {number}
- * @private
- */
-shaka.text.VttTextParser.TS_ROLLOVER_ = 0x200000000;
-
 /**
  * @const
  * @private {!RegExp}

package/lib/transmuxer/h264.js

@@ -144,7 +144,7 @@ shaka.transmuxer.H264 = class {
         const vSpacingTable = [
           1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1,
         ];
-        if (aspectRatioIdc > 0 && aspectRatioIdc < 16) {
+        if (aspectRatioIdc > 0 && aspectRatioIdc <= 16) {
           hSpacing = hSpacingTable[aspectRatioIdc - 1];
           vSpacing = vSpacingTable[aspectRatioIdc - 1];
         } else if (aspectRatioIdc === 255) {
@@ -267,8 +267,8 @@ shaka.transmuxer.H264 = class {
         naluLength[1] = (size >> 16) & 0xff;
         naluLength[2] = (size >> 8) & 0xff;
         naluLength[3] = size & 0xff;
-        nalusData.push(shaka.util.Uint8ArrayUtils.concat(
-            naluLength, nalu.fullData));
+        nalusData.push(naluLength);
+        nalusData.push(nalu.fullData);
       }
     }
     if (!nalusData.length) {

package/lib/transmuxer/h265.js

@@ -317,7 +317,7 @@ shaka.transmuxer.H265 = class {
         const sarHeightTable = [
           1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1,
         ];
-        if (aspectRatioIdc > 0 && aspectRatioIdc < 16) {
+        if (aspectRatioIdc > 0 && aspectRatioIdc <= 16) {
           sarWidth = sarWidthTable[aspectRatioIdc - 1];
           sarHeight = sarHeightTable[aspectRatioIdc - 1];
         } else if (aspectRatioIdc === 255) {
@@ -652,8 +652,8 @@ shaka.transmuxer.H265 = class {
         naluLength[1] = (size >> 16) & 0xff;
         naluLength[2] = (size >> 8) & 0xff;
         naluLength[3] = size & 0xff;
-        nalusData.push(shaka.util.Uint8ArrayUtils.concat(
-            naluLength, nalu.fullData));
+        nalusData.push(naluLength);
+        nalusData.push(nalu.fullData);
       }
     }
     if (!nalusData.length) {

package/lib/transmuxer/ts_transmuxer.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.transmuxer.TsTransmuxer');
 
 goog.require('shaka.media.Capabilities');
+goog.require('shaka.transmuxer.AacTransmuxer');
 goog.require('shaka.transmuxer.Ac3');
 goog.require('shaka.transmuxer.ADTS');
 goog.require('shaka.transmuxer.Ec3');
@@ -16,6 +17,7 @@ goog.require('shaka.transmuxer.MpegAudio');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
+goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
@@ -45,6 +47,9 @@ shaka.transmuxer.TsTransmuxer = class {
 
     /** @private {?shaka.util.TsParser} */
     this.tsParser_ = null;
+
+    /** @private {?shaka.transmuxer.AacTransmuxer} */
+    this.aacTransmuxer_ = null;
   }
 
 
@@ -54,6 +59,10 @@ shaka.transmuxer.TsTransmuxer = class {
    */
   destroy() {
     this.initSegments.clear();
+
+    if (this.aacTransmuxer_) {
+      this.aacTransmuxer_.destroy();
+    }
   }
 
 
@@ -187,14 +196,44 @@ shaka.transmuxer.TsTransmuxer = class {
    */
   transmux(data, stream, reference, duration, contentType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+
+    if (contentType == ContentType.AUDIO &&
+        !shaka.util.TsParser.probe(uint8ArrayData)) {
+      const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
+      let offset = id3Data.length;
+      for (; offset < uint8ArrayData.length; offset++) {
+        if (shaka.transmuxer.MpegAudio.probe(uint8ArrayData, offset)) {
+          return Promise.reject(new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.MEDIA,
+              shaka.util.Error.Code.TRANSMUXING_FAILED));
+        }
+      }
+      offset = id3Data.length;
+      for (; offset < uint8ArrayData.length; offset++) {
+        if (shaka.transmuxer.ADTS.probe(uint8ArrayData, offset)) {
+          if (!this.aacTransmuxer_) {
+            this.aacTransmuxer_ =
+                new shaka.transmuxer.AacTransmuxer('audio/aac');
+          }
+          return this.aacTransmuxer_
+              .transmux(data, stream, reference, duration, contentType);
+        }
+      }
+      return Promise.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED));
+    }
+
     if (!this.tsParser_) {
       this.tsParser_ = new shaka.util.TsParser();
     } else {
       this.tsParser_.clearData();
     }
-    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
-
-    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
 
     const tsParser = this.tsParser_.parse(uint8ArrayData);
     const streamInfos = [];

package/lib/util/manifest_parser_utils.js

@@ -203,6 +203,7 @@ shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^[ae]c-3$/,
   /^ac-4$/,
   /^dts[cex]$/, // DTS Digital Surround (dtsc), DTS Express (dtse), DTS:X (dtsx)
+  /^iamf/,
 ];
 
 

package/lib/util/mime_utils.js

@@ -84,17 +84,22 @@ shaka.util.MimeUtils = class {
    * beyond the container and codec type, when available.
    *
    * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {string}
    */
-  static getExtendedType(stream) {
-    const components = [stream.mimeType];
+  static getExtendedType(stream, mimeType, codecs) {
+    const components = [mimeType];
 
     const extendedMimeParams = shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_;
     extendedMimeParams.forEach((mimeKey, streamKey) => {
       const value = stream[streamKey];
-      if (streamKey == 'codecs' &&
-          shaka.util.MimeUtils.RAW_FORMATS.includes(stream.mimeType)) {
-        // Skip codecs for raw formats
+      if (streamKey == 'codecs') {
+        if (shaka.util.MimeUtils.RAW_FORMATS.includes(stream.mimeType)) {
+          // Skip codecs for raw formats
+        } else {
+          components.push('codecs="' + codecs + '"');
+        }
       } else if (value) {
         components.push(mimeKey + '="' + value + '"');
       }

package/lib/util/mp4_parser.js

@@ -271,6 +271,63 @@ shaka.util.Mp4Parser = class {
   }
 
 
+  /**
+   * A callback that tells the Mp4 parser to treat the body of a box as a audio
+   * sample entry.  A audio sample entry has some fixed-sized fields
+   * describing the audio codec parameters, followed by an arbitrary number of
+   * appended children.  Each child is a box.
+   *
+   * @param {!shaka.extern.ParsedBox} box
+   * @export
+   */
+  static audioSampleEntry(box) {
+    // The "reader" starts at the payload, so we need to add the header to the
+    // start position.  The header size varies.
+    const headerSize = shaka.util.Mp4Parser.headerSize(box);
+
+    // 6 bytes reserved
+    // 2 bytes data reference index
+    box.reader.skip(8);
+    // 2 bytes version
+    const version = box.reader.readUint16();
+    // 2 bytes revision (0, could be ignored)
+    // 4 bytes reserved
+    box.reader.skip(6);
+
+    if (version == 2) {
+      // 16 bytes hard-coded values with no comments
+      // 8 bytes sample rate
+      // 4 bytes channel count
+      // 4 bytes hard-coded values with no comments
+      // 4 bytes bits per sample
+      // 4 bytes lpcm flags
+      // 4 bytes sample size
+      // 4 bytes samples per packet
+      box.reader.skip(48);
+    } else {
+      // 2 bytes channel count
+      // 2 bytes bits per sample
+      // 2 bytes compression ID
+      // 2 bytes packet size
+      // 2 bytes sample rate
+      // 2 byte reserved
+      box.reader.skip(12);
+    }
+
+    if (version == 1) {
+      // 4 bytes samples per packet
+      // 4 bytes bytes per packet
+      // 4 bytes bytes per frame
+      // 4 bytes bytes per sample
+      box.reader.skip(16);
+    }
+
+    while (box.reader.hasMoreData() && !box.parser.done_) {
+      box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
+    }
+  }
+
+
   /**
    * Create a callback that tells the Mp4 parser to treat the body of a box as a
    * binary blob and to parse the body's contents using the provided callback.