shaka-player 4.3.0 → 4.3.1

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/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.
     };
 

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);
       }

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!');
 
@@ -6974,7 +6974,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.1-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/abort_controller.js

@@ -0,0 +1,143 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.polyfill.AbortController');
+
+goog.require('shaka.polyfill');
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
+
+/**
+ * @summary A polyfill for systems that do not implement AbortController.
+ * This is used both with the fetch API for HTTP requests and inside the HLS
+ * parser.
+ * @export
+ * @extends AbortController
+ */
+shaka.polyfill.AbortController = class {
+  /**
+   * Install the polyfill if needed.
+   * @export
+   */
+  static install() {
+    if (window.AbortController) {
+      // Not needed.
+      return;
+    }
+
+    window.AbortController = shaka.polyfill.AbortController;
+    window.AbortSignal = shaka.polyfill.AbortController.AbortSignal;
+  }
+
+  /** */
+  constructor() {
+    /** @private {!shaka.polyfill.AbortController.AbortSignal} */
+    this.signal_ = new shaka.polyfill.AbortController.AbortSignal();
+  }
+
+  /**
+   * @override
+   * @suppress {const|duplicate} Since the original is defined as "const", we
+   *   need this suppression to override it.
+   */
+  get signal() {
+    return this.signal_;
+  }
+
+  /**
+   * @param {*=} reason
+   * @override
+   */
+  abort(reason) {
+    this.signal_.doAbort_(reason);
+  }
+};
+
+/**
+ * @summary A polyfill for AbortSignal, part of the AbortController API.
+ * @implements {AbortSignal}
+ */
+shaka.polyfill.AbortController.AbortSignal =
+class extends shaka.util.FakeEventTarget {
+  /** */
+  constructor() {
+    super();
+
+    /** @private {boolean} */
+    this.aborted_ = false;
+
+    /** @private {*} */
+    this.reason_ = undefined;
+
+    /** @type {?function(!Event)} */
+    this.onabort = null;
+  }
+
+  /** @override */
+  get aborted() {
+    return this.aborted_;
+  }
+
+  /** @return {*} */
+  get reason() {
+    return this.reason_;
+  }
+
+  /**
+   * @param {*} reason
+   * @private
+   */
+  doAbort_(reason) {
+    if (this.aborted_) {
+      return;
+    }
+
+    this.aborted_ = true;
+    this.reason_ = reason;
+    if (this.reason_ === undefined) {
+      // This is equivalent to a native implementation.
+      this.reason_ = new DOMException(
+          'signal is aborted without reason', 'AbortError');
+    }
+
+    // According to MDN:
+    // "Event type - A generic Event with no added properties."
+    const event = new shaka.util.FakeEvent('abort');
+    if (this.onabort) {
+      this.onabort(event);
+    }
+    this.dispatchEvent(event);
+  }
+
+
+  /**
+   * @param {*=} reason
+   * @return {!AbortSignal}
+   */
+  static abort(reason) {
+    const signal = new shaka.polyfill.AbortController.AbortSignal();
+    signal.doAbort_(reason);
+    return signal;
+  }
+
+  /**
+   * @param {number} timeMs
+   * @return {!AbortSignal}
+   */
+  static timeout(timeMs) {
+    const signal = new shaka.polyfill.AbortController.AbortSignal();
+
+    window.setTimeout(() => {
+      // This is equivalent to a native implementation.
+      signal.doAbort_(new DOMException('signal timed out', 'TimeoutError'));
+    }, timeMs);
+
+    return signal;
+  }
+};
+
+
+shaka.polyfill.register(shaka.polyfill.AbortController.install);