shaka-player 4.9.32 → 4.9.34

package/externs/managedmediasource.js

@@ -22,3 +22,9 @@ function ManagedMediaSource() {}
  * @return {boolean}
  */
 ManagedMediaSource.isTypeSupported = function(type) {};
+
+/**
+ * @constructor
+ * @extends {SourceBuffer}
+ */
+function ManagedSourceBuffer() {}

package/externs/shaka/codecs.js

@@ -27,6 +27,27 @@
 shaka.extern.MPEG_PES;
 
 
+/**
+ * @typedef {{
+ *   data: !Uint8Array,
+ *   frame: boolean,
+ *   isKeyframe: boolean,
+ *   pts: ?number,
+ *   dts: ?number,
+ *   nalus: !Array.<!shaka.extern.VideoNalu>
+ * }}
+ *
+ * @summary VideoSample.
+ * @property {!Uint8Array} data
+ * @property {boolean} frame
+ * @property {boolean} isKeyframe
+ * @property {?number} pts
+ * @property {?number} dts
+ * @property {!Array.<!shaka.extern.VideoNalu>} nalus
+ */
+shaka.extern.VideoSample;
+
+
 /**
  * @typedef {{
  *   data: !Uint8Array,

package/externs/shaka/offline.js

@@ -141,6 +141,7 @@ shaka.extern.ManifestDB;
  *   spatialAudio: boolean,
  *   closedCaptions: Map.<string, string>,
  *   tilesLayout: (string|undefined),
+ *   mssPrivateData: (shaka.extern.MssPrivateData|undefined),
  *   external: boolean,
  *   fastSwitching: boolean
  * }}
@@ -213,6 +214,9 @@ shaka.extern.ManifestDB;
  *   The value is a grid-item-dimension consisting of two positive decimal
  *   integers in the format: column-x-row ('4x3'). It describes the arrangement
  *   of Images in a Grid. The minimum valid LAYOUT is '1x1'.
+ * @property {(shaka.extern.MssPrivateData|undefined)} mssPrivateData
+ *   <i>Microsoft Smooth Streaming only.</i> <br>
+ *   Private MSS data that is necessary to be able to do transmuxing.
  * @property {boolean} external
  *   Indicate if the stream was added externally.
  *   Eg: external text tracks.

package/lib/cast/cast_utils.js

@@ -326,6 +326,7 @@ shaka.cast.CastUtils.PlayerGetterMethods = {
   'seekRange': 1,
   'getLoadMode': 10,
   'getManifestType': 10,
+  'isEnded': 1,
 };
 
 

package/lib/hls/hls_parser.js

@@ -1012,8 +1012,8 @@ shaka.hls.HlsParser = class {
     }
 
     if (extension == 'ts' || contentMimeType == 'video/mp2t') {
-      const basicInfo =
-          shaka.media.SegmentUtils.getBasicInfoFromTs(response.data);
+      const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromTs(
+          response.data, this.config_.disableAudio, this.config_.disableVideo);
       if (basicInfo) {
         return basicInfo;
       }
@@ -2582,12 +2582,23 @@ shaka.hls.HlsParser = class {
       }
     }
     this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
-    const liveWithNoProgramaDateTime =
+
+    const activeStreamInfos = Array.from(this.uriToStreamInfosMap_.values())
+        .filter((s) => s.stream.segmentIndex);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const hasAudio =
+        activeStreamInfos.some((s) => s.stream.type == ContentType.AUDIO);
+    const hasVideo =
+        activeStreamInfos.some((s) => s.stream.type == ContentType.VIDEO);
+
+    const liveWithNoProgramDateTime =
         this.isLive_() && !this.usesProgramDateTime_;
+    const vodWithOnlyAudioOrVideo = !this.isLive_() &&
+        this.usesProgramDateTime_ && !(hasAudio && hasVideo);
     if (this.config_.hls.ignoreManifestProgramDateTime ||
-        liveWithNoProgramaDateTime) {
+        liveWithNoProgramDateTime || vodWithOnlyAudioOrVideo) {
       this.syncStreamsWithSequenceNumber_(
-          streamInfos, liveWithNoProgramaDateTime);
+          streamInfos, liveWithNoProgramDateTime);
     } else {
       this.syncStreamsWithProgramDateTime_(streamInfos);
       if (this.config_.hls.ignoreManifestProgramDateTimeForTypes.length > 0) {
@@ -2682,6 +2693,16 @@ shaka.hls.HlsParser = class {
 
     if (!mimeType) {
       mimeType = await this.guessMimeType_(type, codecs, segments);
+
+      // Some manifests don't say what text codec they use, this is a problem
+      // if the cmft extension is used because we identify the mimeType as
+      // application/mp4. In this case if we don't detect initialization
+      // segments, we assume that the mimeType is text/vtt.
+      if (type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
+          !codecs && mimeType == 'application/mp4' &&
+          segments[0] && !segments[0].initSegmentReference) {
+        mimeType = 'text/vtt';
+      }
     }
 
     const {drmInfos, keyIds, encrypted, aesEncrypted} =

package/lib/media/drm_engine.js

@@ -15,6 +15,7 @@ goog.require('shaka.util.DrmUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
 goog.require('shaka.util.ManifestParserUtils');
@@ -1419,6 +1420,11 @@ shaka.media.DrmEngine = class {
     }
     // NOTE: allowCrossSiteCredentials can be set in a request filter.
 
+    if (shaka.util.DrmUtils.isClearKeySystem(
+        this.currentDrmInfo_.keySystem)) {
+      this.fixClearKeyRequest_(request, this.currentDrmInfo_);
+    }
+
     if (shaka.util.DrmUtils.isPlayReadyKeySystem(
         this.currentDrmInfo_.keySystem)) {
       this.unpackPlayReadyRequest_(request);
@@ -1569,6 +1575,31 @@ shaka.media.DrmEngine = class {
         /** @type{string} */(shaka.util.TXml.getTextContents(challenge)));
   }
 
+  /**
+   * Some old ClearKey CDMs don't include the type in the body request.
+   *
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.DrmInfo} drmInfo
+   * @private
+   */
+  fixClearKeyRequest_(request, drmInfo) {
+    try {
+      const body = shaka.util.StringUtils.fromBytesAutoDetect(request.body);
+      if (body) {
+        const licenseBody =
+          /** @type {shaka.media.DrmEngine.ClearKeyLicenceRequestFormat} */ (
+            JSON.parse(body));
+        if (!licenseBody.type) {
+          licenseBody.type = drmInfo.sessionType;
+          request.body =
+              shaka.util.StringUtils.toUTF8(JSON.stringify(licenseBody));
+        }
+      }
+    } catch (e) {
+      shaka.log.info('Error unpacking ClearKey license', e);
+    }
+  }
+
   /**
    * @param {!Event} event
    * @private
@@ -1849,9 +1880,16 @@ shaka.media.DrmEngine = class {
         offlineConfig.sessionTypes = ['persistent-license'];
 
         const configs = [offlineConfig, basicConfig];
-
-        const access = await navigator.requestMediaKeySystemAccess(
-            keySystem, configs);
+        // On some (Android) WebView environments,
+        // requestMediaKeySystemAccess will
+        // not resolve or reject, at least if RESOURCE_PROTECTED_MEDIA_ID
+        // is not set.  This is a workaround for that issue.
+        const TIMEOUT_FOR_CHECKACCESS_IN_SECONDS = 1;
+        const access =
+          await shaka.util.Functional.promiseWithTimeout(
+              TIMEOUT_FOR_CHECKACCESS_IN_SECONDS,
+              navigator.requestMediaKeySystemAccess(keySystem, configs),
+          );
         await processMediaKeySystemAccess(keySystem, access);
       } catch (error) {}  // Ignore errors.
     };
@@ -1886,13 +1924,22 @@ shaka.media.DrmEngine = class {
             },
           },
         };
-
+        // On some (Android) WebView environments, decodingInfo will
+        // not resolve or reject, at least if RESOURCE_PROTECTED_MEDIA_ID
+        // is not set.  This is a workaround for that issue.
+        const TIMEOUT_FOR_DECODING_INFO_IN_SECONDS = 1;
         const decodingInfo =
-            await navigator.mediaCapabilities.decodingInfo(decodingConfig);
+          await shaka.util.Functional.promiseWithTimeout(
+              TIMEOUT_FOR_DECODING_INFO_IN_SECONDS,
+              navigator.mediaCapabilities.decodingInfo(decodingConfig),
+          );
 
         const access = decodingInfo.keySystemAccess;
         await processMediaKeySystemAccess(keySystem, access);
-      } catch (error) {}  // Ignore errors.
+      } catch (error) {
+        // Ignore errors.
+        shaka.log.v2('Failed to probe support for', keySystem, error);
+      }
     };
 
     // Initialize the support structure for each key system.
@@ -2388,26 +2435,24 @@ shaka.media.DrmEngine = class {
     // The order of preference for drmInfo:
     // 1. Clear Key config, used for debugging, should override everything else.
     //    (The application can still specify a clearkey license server.)
-    // 2. Application-configured servers, if any are present, should override
-    //    anything from the manifest.  Nuance: if key system A is in the
-    //    manifest and key system B is in the player config, only B will be
-    //    used, not A.
+    // 2. Application-configured servers, if present, override
+    //    anything from the manifest.
     // 3. Manifest-provided license servers are only used if nothing else is
     //    specified.
     // This is important because it allows the application a clear way to
-    // indicate which DRM systems should be used on platforms with multiple DRM
-    // systems.
-    // The only way to get license servers from the manifest is not to specify
-    // any in your player config.
+    // indicate which DRM systems should be ignored on platforms with multiple
+    // DRM systems.
+    // Alternatively, use config.preferredKeySystems to specify the preferred
+    // key system.
 
     if (originalKeySystem == 'org.w3.clearkey' && drmInfo.licenseServerUri) {
       // Preference 1: Clear Key with pre-configured keys will have a data URI
       // assigned as its license server.  Don't change anything.
       return;
-    } else if (servers.size) {
-      // Preference 2: If anything is configured at the application level,
-      // override whatever was in the manifest.
-      const server = servers.get(originalKeySystem) || '';
+    } else if (servers.size && servers.get(originalKeySystem)) {
+      // Preference 2: If a license server for this keySystem is configured at
+      // the application level, override whatever was in the manifest.
+      const server = servers.get(originalKeySystem);
 
       drmInfo.licenseServerUri = server;
     } else {
@@ -2568,6 +2613,21 @@ shaka.media.DrmEngine.SessionMetaData;
  */
 shaka.media.DrmEngine.PlayerInterface;
 
+/**
+ * @typedef {{
+ *   kids: !Array.<string>,
+ *   type: string
+ * }}
+ *
+ * @property {!Array.<string>} kids
+ *   An array of key IDs. Each element of the array is the base64url encoding of
+ *   the octet sequence containing the key ID value.
+ * @property {string} type
+ *   The requested MediaKeySessionType.
+ * @see https://www.w3.org/TR/encrypted-media/#clear-key-request-format
+ */
+shaka.media.DrmEngine.ClearKeyLicenceRequestFormat;
+
 /**
  * The amount of time, in seconds, we wait to consider a session closed.
  * This allows us to work around Chrome bug https://crbug.com/1108158.

package/lib/media/media_source_capabilities.js

@@ -40,9 +40,10 @@ shaka.media.Capabilities = class {
    * @return {boolean}
    */
   static isChangeTypeSupported() {
-    return !!window.SourceBuffer &&
+    const sourceBuffer = window.ManagedSourceBuffer || window.SourceBuffer;
+    return !!sourceBuffer &&
         // eslint-disable-next-line no-restricted-syntax
-        !!SourceBuffer.prototype && !!SourceBuffer.prototype.changeType;
+        !!sourceBuffer.prototype && !!sourceBuffer.prototype.changeType;
   }
 };
 

package/lib/media/media_source_engine.js

@@ -270,6 +270,11 @@ shaka.media.MediaSourceEngine = class {
     for (const ref of stream.segmentIndex) {
       const mimeType = ref.mimeType || stream.mimeType || '';
       let codecs = ref.codecs || stream.codecs || '';
+      // Optimization for the case where the codecs and mimetype of the stream
+      // match the reference.
+      if (mimeType == stream.mimeType && codecs == stream.codecs) {
+        continue;
+      }
       // Don't check the same combination of mimetype + codecs twice.
       const combo = mimeType + ':' + codecs;
       if (seenCombos.has(combo)) {
@@ -484,6 +489,13 @@ shaka.media.MediaSourceEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     await this.mediaSourceOpen_;
+    if (this.ended() || this.closed()) {
+      shaka.log.alwaysError('Expected MediaSource to be open during init(); ' +
+          'reopening the media source.');
+      this.mediaSourceOpen_ = new shaka.util.PublicPromise();
+      this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
+      await this.mediaSourceOpen_;
+    }
 
     this.sequenceMode_ = sequenceMode;
     this.manifestType_ = manifestType;
@@ -652,6 +664,17 @@ shaka.media.MediaSourceEngine = class {
     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
   }
 
+  /**
+   * @return {boolean} True if the MediaSource is in an "closed" state, or if
+   *   the object has been destroyed.
+   */
+  closed() {
+    if (this.reloadingMediaSource_) {
+      return false;
+    }
+    return this.mediaSource_ ? this.mediaSource_.readyState == 'closed' : true;
+  }
+
   /**
    * Gets the first timestamp in buffer for the given content type.
    *
@@ -808,7 +831,7 @@ shaka.media.MediaSourceEngine = class {
           return frame.description ===
               'com.apple.streaming.transportStreamTimestamp';
         });
-        if (metadataTimestamp && metadataTimestamp.data) {
+        if (metadataTimestamp) {
           timestamp = Math.round(metadataTimestamp.data) / 1000;
         }
         /** @private {shaka.extern.ID3Metadata} */
@@ -891,8 +914,7 @@ shaka.media.MediaSourceEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
-      if (this.manifestType_ == shaka.media.ManifestParser.HLS &&
-          reference.discontinuitySequence >= 0) {
+      if (this.manifestType_ == shaka.media.ManifestParser.HLS) {
         // This won't be known until the first video segment is appended.
         const offset = await this.textSequenceModeOffset_;
         this.textEngine_.setTimestampOffset(offset);
@@ -962,7 +984,16 @@ shaka.media.MediaSourceEngine = class {
             this.audioCompensation_.resolve(compensation);
           }
         }
-        const calculatedTimestampOffset = reference.startTime - timestamp;
+        let realTimestamp = timestamp;
+        const RAW_FORMATS = shaka.util.MimeUtils.RAW_FORMATS;
+        // For formats without containers and using segments mode, we need to
+        // adjust TimestampOffset relative to 0 because segments do not have
+        // any timestamp information.
+        if (!this.sequenceMode_ &&
+            RAW_FORMATS.includes(this.sourceBufferTypes_[contentType])) {
+          realTimestamp = 0;
+        }
+        const calculatedTimestampOffset = reference.startTime - realTimestamp;
         const timestampOffsetDifference =
             Math.abs(timestampOffset - calculatedTimestampOffset);
         if ((timestampOffsetDifference >= 0.001 || seeked || adaptation) &&
@@ -1319,6 +1350,13 @@ shaka.media.MediaSourceEngine = class {
       return;
     }
 
+    // Avoid changing timestampOffset when the difference is less than 100 ms
+    // from the end of the current buffer.
+    const bufferEnd = this.bufferEnd(contentType);
+    if (bufferEnd && Math.abs(bufferEnd - timestampOffset) < 0.1) {
+      return;
+    }
+
     // Queue an abort() to help MSE splice together overlapping segments.
     // We set appendWindowEnd when we change periods in DASH content, and the
     // period transition may result in overlap.
@@ -1360,7 +1398,7 @@ shaka.media.MediaSourceEngine = class {
       // don't call it again. Also do not call if readyState is
       // 'closed' (not attached to video element) since it is not a
       // valid operation.
-      if (this.ended() || this.mediaSource_.readyState === 'closed') {
+      if (this.ended() || this.closed()) {
         return;
       }
       // Tizen won't let us pass undefined, but it will let us omit the
@@ -2040,32 +2078,32 @@ shaka.media.MediaSourceEngine = class {
   }
 
   /**
-   * Codec switch if necessary, this will not resolve until the codec
-   * switch is over.
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {string} mimeType
    * @param {string} codecs
-   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
-   *               shaka.extern.Stream>} streamsByType
-   * @return {!Promise.<boolean>} true if there was a codec switch,
-   *                              false otherwise.
+   * @return {{transmuxer: ?shaka.extern.Transmuxer,
+   *          transmuxerMuxed: boolean, basicType: string, codec: string,
+   *          mimeType: string}}
    * @private
    */
-  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+  getRealInfo_(contentType, mimeType, codecs) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    if (contentType == ContentType.TEXT) {
-      return false;
-    }
     const MimeUtils = shaka.util.MimeUtils;
-    const currentCodec = MimeUtils.getNormalizedCodec(
-        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
-    const currentBasicType = MimeUtils.getBasicType(
-        this.sourceBufferTypes_[contentType]);
-
     /** @type {?shaka.extern.Transmuxer} */
     let transmuxer;
     let transmuxerMuxed = false;
-    let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
+    const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+        ContentType.AUDIO, (codecs || '').split(','));
+    const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+        ContentType.VIDEO, (codecs || '').split(','));
+    let codec = videoCodec;
+    if (contentType == ContentType.AUDIO) {
+      codec = audioCodec;
+    }
+    if (!codec) {
+      codec = codecs;
+    }
+    let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codec);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
@@ -2075,36 +2113,79 @@ shaka.media.MediaSourceEngine = class {
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
       const newMimeTypeWithAllCodecs =
-          shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codecs);
+          shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec);
       const transmuxerPlugin =
           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
       if (transmuxerPlugin) {
         transmuxer = transmuxerPlugin();
-        const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
-            ContentType.AUDIO, (codecs || '').split(','));
-        const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
-            ContentType.VIDEO, (codecs || '').split(','));
         if (audioCodec && videoCodec) {
           transmuxerMuxed = true;
-          let codec = videoCodec;
-          if (contentType == ContentType.AUDIO) {
-            codec = audioCodec;
-          }
-          newMimeType = transmuxer.convertCodecs(contentType,
-              shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec));
-        } else {
-          newMimeType =
-              transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
         }
+        newMimeType =
+            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
       }
     }
 
     const newCodec = MimeUtils.getNormalizedCodec(
         MimeUtils.getCodecs(newMimeType));
     const newBasicType = MimeUtils.getBasicType(newMimeType);
+    return {
+      transmuxer,
+      transmuxerMuxed,
+      basicType: newBasicType,
+      codec: newCodec,
+      mimeType: newMimeType,
+    };
+  }
+
+  /**
+   * Codec switch if necessary, this will not resolve until the codec
+   * switch is over.
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {string} mimeType
+   * @param {string} codecs
+   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   * @return {!Promise.<boolean>} true if there was a codec switch,
+   *                              false otherwise.
+   * @private
+   */
+  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (contentType == ContentType.TEXT) {
+      return false;
+    }
+    const MimeUtils = shaka.util.MimeUtils;
+    const currentCodec = MimeUtils.getNormalizedCodec(
+        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
+    const currentBasicType = MimeUtils.getBasicType(
+        this.sourceBufferTypes_[contentType]);
+
+    const realInfo = this.getRealInfo_(contentType, mimeType, codecs);
+    const transmuxer = realInfo.transmuxer;
+    const transmuxerMuxed = realInfo.transmuxerMuxed;
+    const newBasicType = realInfo.basicType;
+    const newCodec = realInfo.codec;
+    const newMimeType = realInfo.mimeType;
+
+    let muxedContentCheck = true;
+    if (transmuxerMuxed) {
+      const muxedRealInfo =
+          this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
+      const muxedCurrentCodec = MimeUtils.getNormalizedCodec(
+          MimeUtils.getCodecs(this.sourceBufferTypes_[ContentType.AUDIO]));
+      const muxedCurrentBasicType = MimeUtils.getBasicType(
+          this.sourceBufferTypes_[ContentType.AUDIO]);
+      muxedContentCheck = muxedCurrentCodec == muxedRealInfo.codec &&
+        muxedCurrentBasicType == muxedRealInfo.basicType;
+      if (muxedRealInfo.transmuxer) {
+        muxedRealInfo.transmuxer.destroy();
+      }
+    }
 
     // Current/new codecs base and basic type match then no need to switch
-    if (currentCodec === newCodec && currentBasicType === newBasicType) {
+    if (currentCodec === newCodec && currentBasicType === newBasicType &&
+        muxedContentCheck) {
       if (this.transmuxers_[contentType] && !transmuxer) {
         this.transmuxers_[contentType].destroy();
         delete this.transmuxers_[contentType];

package/lib/media/segment_utils.js

@@ -47,9 +47,11 @@ shaka.media.SegmentUtils = class {
 
   /**
    * @param {!BufferSource} data
+   * @param {boolean=} disableAudio
+   * @param {boolean=} disableVideo
    * @return {?shaka.media.SegmentUtils.BasicInfo}
    */
-  static getBasicInfoFromTs(data) {
+  static getBasicInfoFromTs(data, disableAudio = false, disableVideo = false) {
     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
     const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
     const tsCodecs = tsParser.getCodecs();
@@ -57,50 +59,54 @@ shaka.media.SegmentUtils = class {
     const codecs = [];
     let hasAudio = false;
     let hasVideo = false;
-    switch (tsCodecs.audio) {
-      case 'aac':
-      case 'aac-loas':
-        codecs.push('mp4a.40.2');
-        hasAudio = true;
-        break;
-      case 'mp3':
-        codecs.push('mp4a.40.34');
-        hasAudio = true;
-        break;
-      case 'ac3':
-        codecs.push('ac-3');
-        hasAudio = true;
-        break;
-      case 'ec3':
-        codecs.push('ec-3');
-        hasAudio = true;
-        break;
-      case 'opus':
-        codecs.push('opus');
-        hasAudio = true;
-        break;
+    if (!disableAudio) {
+      switch (tsCodecs.audio) {
+        case 'aac':
+        case 'aac-loas':
+          codecs.push('mp4a.40.2');
+          hasAudio = true;
+          break;
+        case 'mp3':
+          codecs.push('mp4a.40.34');
+          hasAudio = true;
+          break;
+        case 'ac3':
+          codecs.push('ac-3');
+          hasAudio = true;
+          break;
+        case 'ec3':
+          codecs.push('ec-3');
+          hasAudio = true;
+          break;
+        case 'opus':
+          codecs.push('opus');
+          hasAudio = true;
+          break;
+      }
     }
-    switch (tsCodecs.video) {
-      case 'avc':
-        if (videoInfo.codec) {
-          codecs.push(videoInfo.codec);
-        } else {
-          codecs.push('avc1.42E01E');
-        }
-        hasVideo = true;
-        break;
-      case 'hvc':
-        if (videoInfo.codec) {
-          codecs.push(videoInfo.codec);
-        } else {
-          codecs.push('hvc1.1.6.L93.90');
-        }
-        hasVideo = true;
-        break;
-      case 'av1':
-        codecs.push('av01.0.01M.08');
-        hasVideo = true;
-        break;
+    if (!disableVideo) {
+      switch (tsCodecs.video) {
+        case 'avc':
+          if (videoInfo.codec) {
+            codecs.push(videoInfo.codec);
+          } else {
+            codecs.push('avc1.42E01E');
+          }
+          hasVideo = true;
+          break;
+        case 'hvc':
+          if (videoInfo.codec) {
+            codecs.push(videoInfo.codec);
+          } else {
+            codecs.push('hvc1.1.6.L93.90');
+          }
+          hasVideo = true;
+          break;
+        case 'av1':
+          codecs.push('av01.0.01M.08');
+          hasVideo = true;
+          break;
+      }
     }
     if (!codecs.length) {
       return null;
@@ -381,9 +387,13 @@ shaka.media.SegmentUtils = class {
       if (initData) {
         captionParser.init(initData);
       }
-      captionParser.parseFrom(data);
-      for (const stream of captionParser.getStreams()) {
-        closedCaptions.set(stream, stream);
+      try {
+        captionParser.parseFrom(data);
+        for (const stream of captionParser.getStreams()) {
+          closedCaptions.set(stream, stream);
+        }
+      } catch (e) {
+        shaka.log.debug('Error detecting CC streams', e);
       }
       captionParser.reset();
     }