shaka-player 4.3.0 → 4.3.2

package/docs/tutorials/welcome.md

@@ -29,8 +29,8 @@ You can build Shaka on Linux, Windows, or Mac.
 To get the sources and compile the library, you will need:
   * {@link https://git-scm.com/downloads Git v1.9+}
   * {@link https://www.python.org/downloads/ Python v2.7 or v3.5+}
-  * {@link https://java.com/en/download/ Java Runtime Environment v8+}
-  * {@link https://nodejs.org/en/download/ NodeJS v10+}
+  * {@link https://java.com/en/download/ Java Runtime Environment v14+}
+  * {@link https://nodejs.org/en/download/ NodeJS v14+}
   * A local web server, such as {@link https://httpd.apache.org/ Apache}
     * _NOTE: A local web server is required because browsers place restrictions
       on applications from file:/// URLs._

package/externs/shaka/mp4_parser.js

@@ -11,6 +11,7 @@
 
 /**
  * @typedef {{
+ *    name: string,
  *    parser: !shaka.util.Mp4Parser,
  *    partialOkay: boolean,
  *    start: number,
@@ -21,6 +22,8 @@
  *    has64BitSize: boolean
  * }}
  *
+ * @property {string} name
+ *   The box name, a 4-character string (fourcc).
  * @property {!shaka.util.Mp4Parser} parser
  *   The parser that parsed this box. The parser can be used to parse child
  *   boxes where the configuration of the current parser is needed to parsed

package/externs/shaka/player.js

@@ -131,7 +131,8 @@ shaka.extern.StateChange;
  * @property {number} manifestTimeSeconds
  *   The amount of time it took to download and parse the manifest.
  * @property {number} drmTimeSeconds
- *   The amount of time it took to download the first drm key.
+ *   The amount of time it took to download the first drm key, and load that key
+ *   into the drm system.
  * @property {number} playTime
  *   The total time spent in a playing state in seconds.
  * @property {number} pauseTime

package/lib/ads/ad_manager.js

@@ -19,8 +19,8 @@ goog.require('shaka.util.IReleasable');
 
 
 /**
- * @event shaka.ads.AdManager.ADS_LOADED
- * @description Fired when an ad has started playing.
+ * @event shaka.ads.AdManager.AdsLoadedEvent
+ * @description Fired when a sequence of ads has been loaded.
  * @property {string} type
  *   'ads-loaded'
  * @property {number} loadTime

package/lib/cea/cea708_window.js

@@ -420,7 +420,7 @@ shaka.cea.Cea708Window.TextJustification = {
 shaka.cea.Cea708Window.MAX_COLS = 42;
 
 /**
- * Maximum of 15 rows that can be indexed from 0 to 14.
+ * Maximum of 16 rows that can be indexed from 0 to 15.
  * @private @const {number}
  */
-shaka.cea.Cea708Window.MAX_ROWS = 15;
+shaka.cea.Cea708Window.MAX_ROWS = 16;

package/lib/cea/mp4_cea_parser.js

@@ -66,14 +66,7 @@ shaka.cea.Mp4CeaParser = class {
     const trackIds = [];
     const timescales = [];
 
-    // This generates a box-parser callback that simply sets a particular
-    // bitstream format.  It makes the list of codec-signalling boxes below
-    // more compact and readable.
-    const bitstreamFormatSetter = (format) => {
-      return (box) => {
-        this.bitstreamFormat_ = format;
-      };
-    };
+    const codecBoxParser = (box) => this.setBitstreamFormat_(box.name);
 
     new Mp4Parser()
         .box('moov', Mp4Parser.children)
@@ -108,14 +101,21 @@ shaka.cea.Mp4CeaParser = class {
         .fullBox('stsd', Mp4Parser.sampleDescription)
 
         // These are the various boxes that signal a codec.
-        // Use these to set bistreamFormat_.
-        .box('avc1', bitstreamFormatSetter(BitstreamFormat.H264))
-        .box('avc3', bitstreamFormatSetter(BitstreamFormat.H264))
-        .box('hev1', bitstreamFormatSetter(BitstreamFormat.H265))
-        .box('hvc1', bitstreamFormatSetter(BitstreamFormat.H265))
-        // Dobly vision is also H265.
-        .box('dvh1', bitstreamFormatSetter(BitstreamFormat.H265))
-        .box('dvhe', bitstreamFormatSetter(BitstreamFormat.H265))
+        .box('avc1', codecBoxParser)
+        .box('avc3', codecBoxParser)
+        .box('hev1', codecBoxParser)
+        .box('hvc1', codecBoxParser)
+        .box('dvh1', codecBoxParser)
+        .box('dvhe', codecBoxParser)
+
+        // This signals an encrypted sample, which we can go inside of to find
+        // the codec used.
+        .box('encv', Mp4Parser.visualSampleEntry)
+        .box('sinf', Mp4Parser.children)
+        .box('frma', (box) => {
+          const {codec} = shaka.util.Mp4BoxParsers.parseFRMA(box.reader);
+          this.setBitstreamFormat_(codec);
+        })
 
         .parse(initSegment, /* partialOkay= */ true);
 
@@ -338,6 +338,16 @@ shaka.cea.Mp4CeaParser = class {
       }
     }
   }
+
+  /**
+   * @param {string} codec A fourcc for a codec.
+   * @private
+   */
+  setBitstreamFormat_(codec) {
+    if (codec in shaka.cea.Mp4CeaParser.CodecBitstreamMap_) {
+      this.bitstreamFormat_ = shaka.cea.Mp4CeaParser.CodecBitstreamMap_[codec];
+    }
+  }
 };
 
 /** @enum {number} */
@@ -346,3 +356,14 @@ shaka.cea.Mp4CeaParser.BitstreamFormat = {
   H264: 1,
   H265: 2,
 };
+
+/** @private {Object.<string, shaka.cea.Mp4CeaParser.BitstreamFormat>} */
+shaka.cea.Mp4CeaParser.CodecBitstreamMap_ = {
+  'avc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H264,
+  'avc3': shaka.cea.Mp4CeaParser.BitstreamFormat.H264,
+  'hev1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
+  'hvc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
+  // Dobly vision is also H265.
+  'dvh1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
+  'dvhe': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
+};

package/lib/dash/segment_template.js

@@ -67,7 +67,7 @@ shaka.dash.SegmentTemplate = class {
         },
       };
     } else if (info.segmentDuration) {
-      if (!isUpdate) {
+      if (!isUpdate && context.adaptationSet.contentType !== 'image') {
         context.presentationTimeline.notifyMaxSegmentDuration(
             info.segmentDuration);
         context.presentationTimeline.notifyMinSegmentStartTime(

package/lib/hls/hls_parser.js

@@ -618,9 +618,23 @@ shaka.hls.HlsParser = class {
       if (playlist.segments.length) {
         const parsedUri = new goog.Uri(playlist.segments[0].absoluteUri);
         const extension = parsedUri.getPath().split('.').pop();
-        const mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
+        let mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
         if (mimeType) {
           fullMimeType = mimeType;
+        } else if (extension === 'ts') {
+          // TODO: Fetch one segment a use the TsParser to analize if there is
+          // video, audio or both.
+        } else if (extension === 'mp4') {
+          // TODO: Fetch one segment a use the Mp4Parser to analize if there is
+          // video, audio or both.
+        } else if (HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_[extension]) {
+          mimeType = HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_[extension];
+          const defaultAudioCodec = this.config_.hls.defaultAudioCodec;
+          fullMimeType = `${mimeType}; codecs="${defaultAudioCodec}"`;
+        } else if (HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_[extension]) {
+          mimeType = HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_[extension];
+          const defaultVideoCodec = this.config_.hls.defaultVideoCodec;
+          fullMimeType = `${mimeType}; codecs="${defaultVideoCodec}"`;
         }
       }
 
@@ -1123,7 +1137,7 @@ shaka.hls.HlsParser = class {
       shaka.log.debug('Guessing audio-only.');
       type = ContentType.AUDIO;
       ignoreStream = true;
-    } else if (res.video.length) {
+    } else if (res.video.length && !res.audio.length) {
       // There are associated video streams.  Assume this is audio.
       shaka.log.debug('Guessing audio-only.');
       type = ContentType.AUDIO;
@@ -1677,9 +1691,10 @@ shaka.hls.HlsParser = class {
       stream.encrypted = realStream.encrypted;
       stream.drmInfos = realStream.drmInfos;
       stream.keyIds = realStream.keyIds;
-      stream.kind = realStream.kind;
-      stream.roles = realStream.roles;
       stream.mimeType = realStream.mimeType;
+      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
+        stream.codecs = '';
+      }
 
       // Since we lazy-loaded this content, the player may need to create new
       // sessions for the DRM info in this stream.
@@ -1694,6 +1709,10 @@ shaka.hls.HlsParser = class {
             // To aid manifest filtering, assume before loading that all video
             // renditions have the same MIME type.  (And likewise for audio.)
             otherStreamInfo.stream.mimeType = realStream.mimeType;
+            if (shaka.media.MediaSourceEngine.RAW_FORMATS
+                .includes(otherStreamInfo.stream.mimeType)) {
+              otherStreamInfo.stream.codecs = '';
+            }
           }
         }
       }
@@ -1923,23 +1942,20 @@ shaka.hls.HlsParser = class {
 
     const mediaSequenceToStartTime = this.isLive_() ?
         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
+    const prevLowLatencyMode = this.lowLatencyMode_;
     const segments = this.createSegments_(verbatimMediaPlaylistUri, playlist,
         type, mimeType, mediaSequenceToStartTime, mediaVariables);
 
+    // This happens when autoLowLatencyMode is true, so we need set the
+    // correct lowLatencyPresentationDelay_
+    if (prevLowLatencyMode != this.lowLatencyMode_) {
+      this.determinePresentationType_(playlist);
+    }
+
     const lastEndTime = segments[segments.length - 1].endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
 
-    const kind = (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
-        shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined;
-
-    const roles = [];
-    if (characteristics) {
-      for (const characteristic of characteristics.split(',')) {
-        roles.push(characteristic);
-      }
-    }
-
     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
         playlist.tags, 'EXT-X-SERVER-CONTROL');
     const canSkipSegments = serverControlTag ?
@@ -1951,8 +1967,6 @@ shaka.hls.HlsParser = class {
     stream.encrypted = encrypted;
     stream.drmInfos = drmInfos;
     stream.keyIds = keyIds;
-    stream.kind = kind;
-    stream.roles = roles;
     stream.mimeType = mimeType;
 
     return {
@@ -2002,7 +2016,8 @@ shaka.hls.HlsParser = class {
       segmentIndex: null,
       mimeType,
       codecs,
-      kind: undefined,
+      kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
+          shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
       encrypted: false,
       drmInfos: [],
       keyIds: new Set(),
@@ -2018,7 +2033,7 @@ shaka.hls.HlsParser = class {
       width: undefined,
       height: undefined,
       bandwidth: undefined,
-      roles: [],
+      roles: characteristics ? characteristics.split(',') : [],
       forced,
       channelsCount,
       audioSamplingRate: null,
@@ -2156,8 +2171,11 @@ shaka.hls.HlsParser = class {
             shaka.util.Error.Code.HLS_AES_128_INVALID_KEY_LENGTH);
       }
 
+      const algorithm = {
+        name: 'AES-CBC',
+      };
       keyInfo.cryptoKey = await window.crypto.subtle.importKey(
-          'raw', keyResponse.data, 'AES-CBC', true, ['decrypt']);
+          'raw', keyResponse.data, algorithm, true, ['decrypt']);
       keyInfo.fetchKey = undefined; // No longer needed.
     };
 
@@ -2574,12 +2592,12 @@ shaka.hls.HlsParser = class {
     /** @type {shaka.extern.HlsAes128Key|undefined} */
     let hlsAes128Key = undefined;
 
-    // We may need to look at the media itself to determine a segment start
-    // time.
+    let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
+        playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', 0);
     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
-    const skipTag = shaka.hls.Utils.getFirstTagWithName(playlist.tags,
-        'EXT-X-SKIP');
+    const skipTag = shaka.hls.Utils.getFirstTagWithName(
+        playlist.tags, 'EXT-X-SKIP');
     const skippedSegments =
         skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
     let position = mediaSequenceNumber + skippedSegments;
@@ -2602,6 +2620,12 @@ shaka.hls.HlsParser = class {
           (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
 
+      const discontinuityTag = shaka.hls.Utils.getFirstTagWithName(
+          playlist.tags, 'EXT-X-DISCONTINUITY');
+      if (discontinuityTag) {
+        discontinuitySequence++;
+      }
+
       // Apply new AES-128 tags as you see them, keeping a running total.
       for (const drmTag of item.tags) {
         if (drmTag.name == 'EXT-X-KEY' &&
@@ -2639,6 +2663,8 @@ shaka.hls.HlsParser = class {
       previousReference = reference;
 
       if (reference) {
+        reference.discontinuitySequence = discontinuitySequence;
+
         if (this.config_.hls.ignoreManifestProgramDateTime &&
             this.minSequenceNumber_ != null &&
             position < this.minSequenceNumber_) {

package/lib/media/content_workarounds.js

@@ -69,6 +69,18 @@ shaka.media.ContentWorkarounds = class {
         })
         .fullBox('encv', onEncryptionMetadataBox)
         .fullBox('enca', onEncryptionMetadataBox)
+        .fullBox('hev1', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
+        .fullBox('hvc1', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
         .fullBox('avc1', (box) => {
           boxesToModify.push({
             box,

package/lib/media/media_source_capabilities.js

@@ -0,0 +1,36 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.media.Capabilities');
+
+/**
+ * @summary
+ * This is for capturing all media source capabilities on current platform.
+ * And this is for static check and can not be constructed.
+ */
+shaka.media.Capabilities = class {
+  /**
+   * Cache browser engine call to improve performance on some poor platforms
+   *
+   * @param {string} type
+   * @return {boolean}
+   */
+  static isTypeSupported(type) {
+    const supportMap = shaka.media.Capabilities.MediaSourceTypeSupportMap;
+    if (supportMap.has(type)) {
+      return supportMap.get(type);
+    }
+    const currentSupport = MediaSource.isTypeSupported(type);
+    supportMap.set(type, currentSupport);
+    return currentSupport;
+  }
+};
+
+/**
+ * Public it for unit test, and developer could also check the support map.
+ * @type {!Map.<string, boolean>}
+ */
+shaka.media.Capabilities.MediaSourceTypeSupportMap = new Map();

package/lib/media/media_source_engine.js

@@ -8,6 +8,7 @@ goog.provide('shaka.media.MediaSourceEngine');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.media.ContentWorkarounds');
 goog.require('shaka.media.ClosedCaptionParser');
 goog.require('shaka.media.IClosedCaptionParser');
@@ -175,7 +176,7 @@ shaka.media.MediaSourceEngine = class {
         stream.mimeType, stream.codecs);
     const extendedMimeType = shaka.util.MimeUtils.getExtendedType(stream);
     return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
-        MediaSource.isTypeSupported(extendedMimeType) ||
+        shaka.media.Capabilities.isTypeSupported(extendedMimeType) ||
         shaka.media.Transmuxer.isSupported(fullMimeType, stream.type);
   }
 
@@ -231,7 +232,7 @@ shaka.media.MediaSourceEngine = class {
         if (shaka.text.TextEngine.isTypeSupported(type)) {
           support[type] = true;
         } else {
-          support[type] = MediaSource.isTypeSupported(type) ||
+          support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
                           shaka.media.Transmuxer.isSupported(type);
         }
       } else {
@@ -365,7 +366,8 @@ shaka.media.MediaSourceEngine = class {
       if (contentType == ContentType.TEXT) {
         this.reinitText(mimeType, sequenceMode);
       } else {
-        if ((forceTransmux || !MediaSource.isTypeSupported(mimeType)) &&
+        if ((forceTransmux ||
+            !shaka.media.Capabilities.isTypeSupported(mimeType)) &&
             shaka.media.Transmuxer.isSupported(mimeType, contentType)) {
           this.transmuxers_[contentType] =
               new shaka.media.Transmuxer(mimeType);
@@ -586,11 +588,14 @@ shaka.media.MediaSourceEngine = class {
       mimeType = this.transmuxers_[contentType].getOrginalMimeType();
     }
     if (shaka.util.TsParser.probe(uint8ArrayData)) {
-      const metadata = new shaka.util.TsParser().parse(uint8ArrayData)
-          .getMetadata();
+      const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
+      // The SourceBuffer timestampOffset may or may not be set yet, so this is
+      // the timestamp offset that would eventually compute for this segment
+      // either way.
+      const timestampOffset =
+          reference.startTime - (tsParser.getStartTime()[contentType] || 0);
+      const metadata = tsParser.getMetadata();
       if (metadata.length) {
-        const timestampOffset =
-            this.sourceBuffers_[contentType].timestampOffset;
         this.onMetadata_(metadata, timestampOffset,
             reference ? reference.endTime : null);
       }
@@ -919,6 +924,22 @@ shaka.media.MediaSourceEngine = class {
     ]);
   }
 
+  /**
+   * Adjust timestamp offset to maintain AV sync across discontinuities.
+   * Only used in sequence mode.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {number} timestampOffset
+   * @return {!Promise}
+   */
+  async resync(contentType, timestampOffset) {
+    goog.asserts.assert(this.sequenceMode_,
+        'resyncAudio only used with sequence mode!');
+    await this.enqueueOperation_(
+        contentType,
+        () => this.setTimestampOffset_(contentType, timestampOffset));
+  }
+
   /**
    * @param {string=} reason Valid reasons are 'network' and 'decode'.
    * @return {!Promise}

package/lib/media/segment_reference.js

@@ -246,6 +246,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?shaka.media.SegmentReference.ThumbnailSprite} */
     this.thumbnailSprite = null;
+
+    /** @type {number} */
+    this.discontinuitySequence = 0;
   }
 
   /**

package/lib/media/streaming_engine.js

@@ -622,6 +622,11 @@ shaka.media.StreamingEngine = class {
    * within the presentation timeline.
    */
   seeked() {
+    if (!this.playerInterface_) {
+      // Already destroyed.
+      return;
+    }
+
     const presentationTime = this.playerInterface_.getPresentationTime();
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const newTimeIsBuffered = (type) => {
@@ -679,7 +684,7 @@ shaka.media.StreamingEngine = class {
 
   /**
    * Clear the buffer for a given stream.  Unlike clearBuffer_, this will handle
-   * cases where a MediaState is performing an update.  After this runs, every
+   * cases where a MediaState is performing an update.  After this runs, the
    * MediaState will have a pending update.
    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
    * @private
@@ -795,9 +800,9 @@ shaka.media.StreamingEngine = class {
     for (const type of streamsByType.keys()) {
       const stream = streamsByType.get(type);
       if (!this.mediaStates_.has(type)) {
-        const state = this.createMediaState_(stream);
-        this.mediaStates_.set(type, state);
-        this.scheduleUpdate_(state, 0);
+        const mediaState = this.createMediaState_(stream);
+        this.mediaStates_.set(type, mediaState);
+        this.scheduleUpdate_(mediaState, 0);
       }
     }
   }
@@ -909,7 +914,7 @@ shaka.media.StreamingEngine = class {
               'mediastate.stream should not have segmentIndex yet.');
           thisStream.closeSegmentIndex();
         }
-        if (mediaState.updateTimer == null) {
+        if (!mediaState.performingUpdate && !mediaState.updateTimer) {
           this.scheduleUpdate_(mediaState, 0);
         }
         return;
@@ -1394,7 +1399,7 @@ shaka.media.StreamingEngine = class {
         // If the network slows down, abort the current fetch request and start
         // a new one, and ignore the error message.
         mediaState.performingUpdate = false;
-        mediaState.updateTimer = null;
+        this.cancelUpdate_(mediaState);
         this.scheduleUpdate_(mediaState, 0);
       } else if (mediaState.type == ContentType.TEXT &&
           this.config_.ignoreTextStreamFailures) {
@@ -1467,7 +1472,10 @@ shaka.media.StreamingEngine = class {
 
     for (const mediaState of this.mediaStates_.values()) {
       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
-      if (mediaState.hasError) {
+      // Only schedule an update if it has an error, but it's not mid-update
+      // and there is not already an update scheduled.
+      if (mediaState.hasError && !mediaState.performingUpdate &&
+          !mediaState.updateTimer) {
         shaka.log.info(logPrefix, 'Retrying after failure...');
         mediaState.hasError = false;
         this.scheduleUpdate_(mediaState, delaySeconds);
@@ -1661,6 +1669,19 @@ shaka.media.StreamingEngine = class {
       }
     }
 
+    if (this.manifest_.sequenceMode) {
+      // Across discontinuity bounds, we should resync timestamps for
+      // sequence mode playbacks.  The next segment appended should
+      // land at its theoretical timestamp from the segment index.
+      const lastDiscontinuitySequence =
+          mediaState.lastSegmentReference ?
+              mediaState.lastSegmentReference.discontinuitySequence : null;
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
+        operations.push(this.playerInterface_.mediaSourceEngine.resync(
+            mediaState.type, reference.startTime));
+      }
+    }
+
     await Promise.all(operations);
   }
 
@@ -1715,8 +1736,6 @@ shaka.media.StreamingEngine = class {
 
     await this.evict_(mediaState, presentationTime);
     this.destroyer_.ensureNotDestroyed();
-    shaka.log.v1(logPrefix, 'appending media segment at',
-        (reference.syncTime == null ? 'unknown' : reference.syncTime));
 
     // 'seeked' or 'adaptation' triggered logic applies only to this
     // appendBuffer() call.
@@ -2079,7 +2098,11 @@ shaka.media.StreamingEngine = class {
     shaka.log.debug(logPrefix, 'cleared buffer');
     mediaState.clearingBuffer = false;
     mediaState.endOfStream = false;
-    this.scheduleUpdate_(mediaState, 0);
+    // Since the clear operation was async, check to make sure we're not doing
+    // another update and we don't have one scheduled yet.
+    if (!mediaState.performingUpdate && !mediaState.updateTimer) {
+      this.scheduleUpdate_(mediaState, 0);
+    }
   }
 
 

package/lib/media/transmuxer.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.media.Transmuxer');
 
 goog.require('goog.asserts');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.IDestroyable');
@@ -74,6 +75,7 @@ shaka.media.Transmuxer = class {
    */
   static isSupported(mimeType, contentType) {
     const Transmuxer = shaka.media.Transmuxer;
+    const Capabilities = shaka.media.Capabilities;
 
     const isTs = Transmuxer.isTsContainer_(mimeType);
     const isAac = Transmuxer.isAacContainer_(mimeType);
@@ -83,11 +85,11 @@ shaka.media.Transmuxer = class {
     }
 
     if (isAac) {
-      return MediaSource.isTypeSupported(Transmuxer.convertAacCodecs_());
+      return Capabilities.isTypeSupported(Transmuxer.convertAacCodecs_());
     }
 
     if (contentType) {
-      return MediaSource.isTypeSupported(
+      return Capabilities.isTypeSupported(
           Transmuxer.convertTsCodecs_(contentType, mimeType));
     }
 
@@ -95,8 +97,8 @@ shaka.media.Transmuxer = class {
 
     const audioMime = Transmuxer.convertTsCodecs_(ContentType.AUDIO, mimeType);
     const videoMime = Transmuxer.convertTsCodecs_(ContentType.VIDEO, mimeType);
-    return MediaSource.isTypeSupported(audioMime) ||
-        MediaSource.isTypeSupported(videoMime);
+    return Capabilities.isTypeSupported(audioMime) ||
+        Capabilities.isTypeSupported(videoMime);
   }
 
 

package/lib/player.js

@@ -2160,15 +2160,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Unless the user has already picked a variant, anyway, by calling
     // selectVariantTrack before this loading stage.
     let initialVariant = null;
-    const activeVariantTrack = this.getVariantTracks().find((t) => t.active);
-    if (!activeVariantTrack) {
+    const activeVariant = this.streamingEngine_.getCurrentVariant();
+    if (!activeVariant) {
       initialVariant = this.chooseVariant_();
       goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
     }
 
     // Lazy-load the stream, so we will have enough info to make the playhead.
     const createSegmentIndexPromises = [];
-    const toLazyLoad = activeVariantTrack || initialVariant;
+    const toLazyLoad = activeVariant || initialVariant;
     for (const stream of [toLazyLoad.video, toLazyLoad.audio]) {
       if (stream && !stream.segmentIndex) {
         createSegmentIndexPromises.push(stream.createSegmentIndex());
@@ -2189,7 +2189,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.startBufferManagement_(rebufferThreshold);
 
     // Now we can switch to the initial variant.
-    if (!activeVariantTrack) {
+    if (!activeVariant) {
       goog.asserts.assert(initialVariant,
           'Must have choosen an initial variant!');
 
@@ -4330,6 +4330,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return [];
     }
     const chapters = [];
+    const uniqueChapters = new Set();
     for (const chaptersTrack of chaptersTracksWithLanguage) {
       if (chaptersTrack && chaptersTrack.cues) {
         for (const cue of chaptersTrack.cues) {
@@ -4344,7 +4345,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             startTime: cue.startTime,
             endTime: cue.endTime,
           };
-          chapters.push(chapter);
+          if (!uniqueChapters.has(id)) {
+            chapters.push(chapter);
+            uniqueChapters.add(id);
+          }
         }
       }
     }
@@ -6974,7 +6978,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.3.0-uncompiled';
+shaka.Player.version = 'v4.3.2-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.