shaka-player 4.2.3 → 4.3.0

package/lib/polyfill/patchedmediakeys_apple.js

@@ -27,14 +27,33 @@ goog.require('shaka.util.StringUtils');
 shaka.polyfill.PatchedMediaKeysApple = class {
   /**
    * Installs the polyfill if needed.
+   * @param {boolean} enableUninstall enables uninstalling the polyfill
    * @export
    */
-  static install() {
+  static install(enableUninstall = false) {
     if (!window.HTMLVideoElement || !window.WebKitMediaKeys) {
       // No HTML5 video or no prefixed EME.
       return;
     }
 
+    if (enableUninstall) {
+      this.enableUninstall = true;
+      this.originalHTMLMediaElementPrototypeMediaKeys =
+        /** @type {!Object} */ (
+          Object.getOwnPropertyDescriptor(
+              // eslint-disable-next-line no-restricted-syntax
+              HTMLMediaElement.prototype, 'mediaKeys',
+          )
+        );
+      // eslint-disable-next-line no-restricted-syntax
+      this.originalHTMLMediaElementPrototypeSetMediaKeys = HTMLMediaElement
+          .prototype.setMediaKeys;
+      this.originalWindowMediaKeys = window.MediaKeys;
+      this.originalWindowMediaKeySystemAccess = window.MediaKeySystemAccess;
+      this.originalNavigatorRequestMediaKeySystemAccess = navigator
+          .requestMediaKeySystemAccess;
+    }
+
     shaka.log.info('Using Apple-prefixed EME');
 
     // Alias
@@ -59,6 +78,41 @@ shaka.polyfill.PatchedMediaKeysApple = class {
     window.shakaMediaKeysPolyfill = true;
   }
 
+  /**
+   * Uninstalls the polyfill if needed and enabled.
+   * @export
+   */
+  static uninstall() {
+    if (!this.enableUninstall) {
+      return;
+    }
+
+    shaka.log.info('Un-installing Apple-prefixed EME');
+
+    this.enableUninstall = false;
+    Object.defineProperty(
+        // eslint-disable-next-line no-restricted-syntax
+        HTMLMediaElement.prototype,
+        'mediaKeys',
+        this.originalHTMLMediaElementPrototypeMediaKeys,
+    );
+    // eslint-disable-next-line no-restricted-syntax
+    HTMLMediaElement.prototype.setMediaKeys = this
+        .originalHTMLMediaElementPrototypeSetMediaKeys;
+    window.MediaKeys = this.originalWindowMediaKeys;
+    window.MediaKeySystemAccess = this.originalWindowMediaKeySystemAccess;
+    navigator.requestMediaKeySystemAccess = this
+        .originalNavigatorRequestMediaKeySystemAccess;
+
+    this.originalWindowMediaKeys = null;
+    this.originalWindowMediaKeySystemAccess = null;
+    this.originalHTMLMediaElementPrototypeSetMediaKeys = null;
+    this.originalNavigatorRequestMediaKeySystemAccess = null;
+    this.originalHTMLMediaElementPrototypeMediaKeys = null;
+
+    window.shakaMediaKeysPolyfill = false;
+  }
+
   /**
    * An implementation of navigator.requestMediaKeySystemAccess.
    * Retrieves a MediaKeySystemAccess object.

package/lib/text/ui_text_displayer.js

@@ -578,7 +578,7 @@ shaka.text.UITextDisplayer = class {
     //   (for vertical growing left) is aligned at the line.
     // TODO: Implement line alignment with line number.
     // TODO: Implement lineAlignment of 'CENTER'.
-    if (cue.line) {
+    if (cue.line != null) {
       if (cue.lineInterpretation == Cue.lineInterpretation.PERCENTAGE) {
         // When setting absolute positioning, you need to set x/y/width/height
         // so the element is positioned correctly.  Set these as default and
@@ -591,21 +591,21 @@ shaka.text.UITextDisplayer = class {
           if (cue.lineAlign == Cue.lineAlign.START) {
             style.top = cue.line + '%';
           } else if (cue.lineAlign == Cue.lineAlign.END) {
-            style.bottom = cue.line + '%';
+            style.bottom = (100 - cue.line) + '%';
           }
         } else if (cue.writingMode == Cue.writingMode.VERTICAL_LEFT_TO_RIGHT) {
           style.height = '100%';
           if (cue.lineAlign == Cue.lineAlign.START) {
             style.left = cue.line + '%';
           } else if (cue.lineAlign == Cue.lineAlign.END) {
-            style.right = cue.line + '%';
+            style.right = (100 - cue.line) + '%';
           }
         } else {
           style.height = '100%';
           if (cue.lineAlign == Cue.lineAlign.START) {
             style.right = cue.line + '%';
           } else if (cue.lineAlign == Cue.lineAlign.END) {
-            style.left = cue.line + '%';
+            style.left = (100 - cue.line) + '%';
           }
         }
       }
@@ -615,7 +615,7 @@ shaka.text.UITextDisplayer = class {
 
     // The position defines the indent of the text container in the
     // direction defined by the writing direction.
-    if (cue.position) {
+    if (cue.position != null) {
       if (cue.writingMode == Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM) {
         style.paddingLeft = cue.position;
       } else {

package/lib/text/vtt_text_parser.js

@@ -366,7 +366,8 @@ shaka.text.VttTextParser = class {
     end += timeOffset;
 
     // Get the payload.
-    const payload = text.slice(1).join('\n').trim();
+    const payload = VttTextParser.htmlUnescape_(
+        text.slice(1).join('\n').trim());
 
     let cue = null;
     if (styles.has('global')) {
@@ -843,6 +844,39 @@ shaka.text.VttTextParser = class {
 
     return (milliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
   }
+
+  /**
+   * This method converts the HTML entities &, <, >, ", and
+   * ' in string to their corresponding characters.
+   *
+   * @param {!string} input
+   * @return {string}
+   * @private
+   */
+  static htmlUnescape_(input) {
+    // Used to map HTML entities to characters.
+    const htmlUnescapes = {
+      '&': '&',
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&#39;': '\'',
+    };
+
+    // Used to match HTML entities and HTML characters.
+    const reEscapedHtml = /&(?:amp|lt|gt|quot|#(0+)?39);/g;
+    const reHasEscapedHtml = RegExp(reEscapedHtml.source);
+    // This check is an optimization, since replace always makes a copy
+    if (input && reHasEscapedHtml.test(input)) {
+      return input.replace(reEscapedHtml, (entity) => {
+        // The only thing that might not match the dictionary above is the
+        // single quote, which can be matched by many strings in the regex, but
+        // only has a single entry in the dictionary.
+        return htmlUnescapes[entity] || '\'';
+      });
+    }
+    return input || '';
+  }
 };
 
 /**

package/lib/util/dom_utils.js

@@ -78,7 +78,6 @@ shaka.util.Dom = class {
     return shaka.util.Dom.asHTMLElement(elements[0]);
   }
 
-
   /**
    * Remove all of the child nodes of an element.
    * @param {!Element} element

package/lib/util/error.js

@@ -358,6 +358,18 @@ shaka.util.Error.Code = {
    */
   'CHAPTERS_TRACK_FAILED': 2015,
 
+  /**
+   * External thumbnails tracks cannot be added in src= because native platform
+   * doesn't support it.
+   */
+  'CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_SRC_EQUALS': 2016,
+
+  /**
+   * Only external urls of WebVTT type are supported.
+   * <br> error.data[0] is the uri.
+   */
+  'UNSUPPORTED_EXTERNAL_THUMBNAILS_URI': 2017,
+
   /**
    * Some component tried to read past the end of a buffer.  The segment index,
    * init segment, or PSSH may be malformed.
@@ -707,6 +719,11 @@ shaka.util.Error.Code = {
    */
   'HLS_AES_128_INVALID_KEY_LENGTH': 4044,
 
+  /**
+   * External thumbnails tracks cannot be added to live streams.
+   */
+  'CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_LIVE_STREAM': 4045,
+
 
   // RETIRED: 'INCONSISTENT_BUFFER_STATE': 5000,
   // RETIRED: 'INVALID_SEGMENT_INDEX': 5001,

package/lib/util/fake_event.js

@@ -160,6 +160,7 @@ shaka.util.FakeEvent.EventName = {
   DownloadHeadersReceived: 'downloadheadersreceived',
   DrmSessionUpdate: 'drmsessionupdate',
   Emsg: 'emsg',
+  Prft: 'prft',
   Error: 'error',
   ExpirationUpdated: 'expirationupdated',
   GapJumped: 'gapjumped',
@@ -171,6 +172,7 @@ shaka.util.FakeEvent.EventName = {
   OnStateChange: 'onstatechange',
   OnStateIdle: 'onstateidle',
   RateChange: 'ratechange',
+  SegmentAppended: 'segmentappended',
   SessionDataEvent: 'sessiondata',
   StallDetected: 'stalldetected',
   Streaming: 'streaming',

package/lib/util/id3_utils.js

@@ -0,0 +1,300 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.Id3Utils');
+
+goog.require('shaka.log');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.StringUtils');
+
+
+/**
+ * @summary A set of Id3Utils utility functions.
+ * @export
+ */
+shaka.util.Id3Utils = class {
+  /**
+   * @param {Uint8Array} data
+   * @param {number} offset
+   * @return {boolean}
+   * @private
+   */
+  static isHeader_(data, offset) {
+    /*
+     * http://id3.org/id3v2.3.0
+     * [0]     = 'I'
+     * [1]     = 'D'
+     * [2]     = '3'
+     * [3,4]   = {Version}
+     * [5]     = {Flags}
+     * [6-9]   = {ID3 Size}
+     *
+     * An ID3v2 tag can be detected with the following pattern:
+     *  $49 44 33 yy yy xx zz zz zz zz
+     * Where yy is less than $FF, xx is the 'flags' byte and zz is less than $80
+     */
+    if (offset + 10 <= data.length) {
+      // look for 'ID3' identifier
+      if (data[offset] === 0x49 &&
+          data[offset + 1] === 0x44 &&
+          data[offset + 2] === 0x33) {
+        // check version is within range
+        if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
+          // check size is within range
+          if (data[offset + 6] < 0x80 &&
+              data[offset + 7] < 0x80 &&
+              data[offset + 8] < 0x80 &&
+              data[offset + 9] < 0x80) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * @param {Uint8Array} data
+   * @param {number} offset
+   * @return {boolean}
+   * @private
+   */
+  static isFooter_(data, offset) {
+    /*
+     * The footer is a copy of the header, but with a different identifier
+     */
+    if (offset + 10 <= data.length) {
+      // look for '3DI' identifier
+      if (data[offset] === 0x33 &&
+          data[offset + 1] === 0x44 &&
+          data[offset + 2] === 0x49) {
+        // check version is within range
+        if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
+          // check size is within range
+          if (data[offset + 6] < 0x80 &&
+              data[offset + 7] < 0x80 &&
+              data[offset + 8] < 0x80 &&
+              data[offset + 9] < 0x80) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * @param {Uint8Array} data
+   * @param {number} offset
+   * @return {number}
+   * @private
+   */
+  static readSize_(data, offset) {
+    let size = 0;
+    size = (data[offset] & 0x7f) << 21;
+    size |= (data[offset + 1] & 0x7f) << 14;
+    size |= (data[offset + 2] & 0x7f) << 7;
+    size |= data[offset + 3] & 0x7f;
+    return size;
+  }
+
+  /**
+   * @param {Uint8Array} data
+   * @return {shaka.extern.MetadataRawFrame}
+   * @private
+   */
+  static getFrameData_(data) {
+    /*
+     * Frame ID       $xx xx xx xx (four characters)
+     * Size           $xx xx xx xx
+     * Flags          $xx xx
+     */
+    const type = String.fromCharCode(data[0], data[1], data[2], data[3]);
+    const size = shaka.util.Id3Utils.readSize_(data, 4);
+
+    // skip frame id, size, and flags
+    const offset = 10;
+
+    return {
+      type,
+      size,
+      data: data.subarray(offset, offset + size),
+    };
+  }
+
+  /**
+   * @param {shaka.extern.MetadataRawFrame} frame
+   * @return {?shaka.extern.MetadataFrame}
+   * @private
+   */
+  static decodeFrame_(frame) {
+    const BufferUtils = shaka.util.BufferUtils;
+    const StringUtils = shaka.util.StringUtils;
+
+    const metadataFrame = {
+      key: frame.type,
+      description: '',
+      data: '',
+    };
+
+    if (frame.type === 'TXXX') {
+      /*
+       * Format:
+       * [0]   = {Text Encoding}
+       * [1-?] = {Description}\0{Value}
+       */
+      if (frame.size < 2) {
+        return null;
+      }
+      if (frame.data[0] !== shaka.util.Id3Utils.UTF8_encoding) {
+        shaka.log.warning('Ignore frame with unrecognized character ' +
+            'encoding');
+        return null;
+      }
+      const descriptionEndIndex = frame.data.subarray(1).indexOf(0);
+
+      if (descriptionEndIndex === -1) {
+        return null;
+      }
+      const description = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 1, descriptionEndIndex));
+      const data = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 2 + descriptionEndIndex))
+          .replace(/\0*$/, '');
+
+      metadataFrame.description = description;
+      metadataFrame.data = data;
+      return metadataFrame;
+    } else if (frame.type === 'WXXX') {
+      /*
+       * Format:
+       * [0]   = {Text Encoding}
+       * [1-?] = {Description}\0{URL}
+       */
+      if (frame.size < 2) {
+        return null;
+      }
+      if (frame.data[0] !== shaka.util.Id3Utils.UTF8_encoding) {
+        shaka.log.warning('Ignore frame with unrecognized character ' +
+            'encoding');
+        return null;
+      }
+      const descriptionEndIndex = frame.data.subarray(1).indexOf(0);
+
+      if (descriptionEndIndex === -1) {
+        return null;
+      }
+      const description = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 1, descriptionEndIndex));
+      const data = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 2 + descriptionEndIndex))
+          .replace(/\0*$/, '');
+
+      metadataFrame.description = description;
+      metadataFrame.data = data;
+      return metadataFrame;
+    } else if (frame.type === 'PRIV') {
+      /*
+       * Format: <text string>\0<binary data>
+       */
+      if (frame.size < 2) {
+        return null;
+      }
+      const textEndIndex = frame.data.indexOf(0);
+      if (textEndIndex === -1) {
+        return null;
+      }
+      const text = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 0, textEndIndex));
+      const data = BufferUtils.toArrayBuffer(
+          frame.data.subarray(text.length + 1));
+      metadataFrame.description = text;
+      metadataFrame.data = data;
+      return metadataFrame;
+    } else if (frame.type[0] === 'T') {
+      /*
+       * Format:
+       * [0]   = {Text Encoding}
+       * [1-?] = {Value}
+       */
+      if (frame.size < 2) {
+        return null;
+      }
+      if (frame.data[0] !== shaka.util.Id3Utils.UTF8_encoding) {
+        shaka.log.warning('Ignore frame with unrecognized character ' +
+            'encoding');
+        return null;
+      }
+      const text = StringUtils.fromUTF8(frame.data.subarray(1))
+          .replace(/\0*$/, '');
+      metadataFrame.data = text;
+      return metadataFrame;
+    } else if (frame.type[0] === 'W') {
+      /*
+       * Format:
+       * [0-?] = {URL}
+       */
+      const url = StringUtils.fromUTF8(frame.data)
+          .replace(/\0*$/, '');
+      metadataFrame.data = url;
+      return metadataFrame;
+    } else if (frame.data) {
+      shaka.log.warning('Unrecognized ID3 frame type:', frame.type);
+      metadataFrame.data = BufferUtils.toArrayBuffer(frame.data);
+      return metadataFrame;
+    }
+
+    return null;
+  }
+
+  /**
+   * Returns an array of ID3 frames found in all the ID3 tags in the id3Data
+   * @param {Uint8Array} id3Data - The ID3 data containing one or more ID3 tags
+   * @return {!Array.<shaka.extern.MetadataFrame>}
+   * @export
+   */
+  static getID3Frames(id3Data) {
+    const Id3Utils = shaka.util.Id3Utils;
+    let offset = 0;
+    const frames = [];
+    while (Id3Utils.isHeader_(id3Data, offset)) {
+      const size = Id3Utils.readSize_(id3Data, offset + 6);
+
+      if ((id3Data[offset + 5] >> 6) & 1) {
+        // skip extended header
+        offset += 10;
+      }
+      // skip past ID3 header
+      offset += 10;
+
+      const end = offset + size;
+      // loop through frames in the ID3 tag
+      while (offset + 10 < end) {
+        const frameData = Id3Utils.getFrameData_(id3Data.subarray(offset));
+        const frame = Id3Utils.decodeFrame_(frameData);
+        if (frame) {
+          frames.push(frame);
+        }
+
+        // skip frame header and frame data
+        offset += frameData.size + 10;
+      }
+
+      if (Id3Utils.isFooter_(id3Data, offset)) {
+        offset += 10;
+      }
+    }
+    return frames;
+  }
+};
+
+/**
+ * UTF8 encoding byte
+ * @const {number}
+ */
+shaka.util.Id3Utils.UTF8_encoding = 0x03;

package/lib/util/manifest_parser_utils.js

@@ -168,6 +168,7 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
   /^hvc/,
   /^vp0?[89]/,
   /^av01/,
+  /^dvhe/,
 ];
 
 
@@ -183,6 +184,9 @@ shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^flac$/,
   /^mp4a/,
   /^[ae]c-3$/,
+  /^ac-4$/,
+  /^dts[cx]$/, // DTS Surround Sound
+  /^[du]dts$/, // DTS Surround Sound
 ];
 
 

package/lib/util/mime_utils.js

@@ -6,7 +6,6 @@
 
 goog.provide('shaka.util.MimeUtils');
 
-goog.require('shaka.dependencies');
 goog.require('shaka.media.Transmuxer');
 goog.require('shaka.util.ManifestParserUtils');
 
@@ -46,12 +45,10 @@ shaka.util.MimeUtils = class {
   static getFullOrConvertedType(mimeType, codecs, contentType) {
     const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const Transmuxer = shaka.media.Transmuxer;
 
-    if (shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
-      if (shaka.dependencies.muxjs()) {
-        return shaka.media.Transmuxer.convertTsCodecs(
-            contentType, fullMimeType);
-      }
+    if (Transmuxer.isSupported(fullMimeType, contentType)) {
+      return shaka.media.Transmuxer.convertCodecs(contentType, fullMimeType);
     } else if (contentType == ContentType.AUDIO) {
       // video/mp2t is the correct mime type for TS audio, so only replace the
       // word "video" with "audio" for non-TS audio content.

package/lib/util/mp4_box_parsers.js

@@ -18,12 +18,13 @@ shaka.util.Mp4BoxParsers = class {
   static parseTFHD(reader, flags) {
     let defaultSampleDuration = null;
     let defaultSampleSize = null;
+    let baseDataOffset = null;
 
     const trackId = reader.readUint32(); // Read "track_ID"
 
     // Skip "base_data_offset" if present.
     if (flags & 0x000001) {
-      reader.skip(8);
+      baseDataOffset = reader.readUint64();
     }
 
     // Skip "sample_description_index" if present.
@@ -45,6 +46,7 @@ shaka.util.Mp4BoxParsers = class {
       trackId,
       defaultSampleDuration,
       defaultSampleSize,
+      baseDataOffset,
     };
   }
 
@@ -112,10 +114,11 @@ shaka.util.Mp4BoxParsers = class {
   static parseTRUN(reader, version, flags) {
     const sampleCount = reader.readUint32();
     const sampleData = [];
+    let dataOffset = null;
 
-    // Skip "data_offset" if present.
+    // "data_offset"
     if (flags & 0x000001) {
-      reader.skip(4);
+      dataOffset = reader.readUint32();
     }
 
     // Skip "first_sample_flags" if present.
@@ -159,6 +162,7 @@ shaka.util.Mp4BoxParsers = class {
     return {
       sampleCount,
       sampleData,
+      dataOffset,
     };
   }
 
@@ -191,7 +195,8 @@ shaka.util.Mp4BoxParsers = class {
  * @typedef {{
  *    trackId: number,
  *    defaultSampleDuration: ?number,
- *    defaultSampleSize: ?number
+ *    defaultSampleSize: ?number,
+ *    baseDataOffset: ?number
  * }}
  *
  * @property {number} trackId
@@ -203,6 +208,8 @@ shaka.util.Mp4BoxParsers = class {
  * @property {?number} defaultSampleSize
  *   If specified via flags, this overrides the default sample
  *   size in the Track Extends Box for this fragment
+ * @property {?number} baseDataOffset
+ *   If specified via flags, this indicate the base data offset
  *
  * @exportDoc
  */
@@ -252,13 +259,16 @@ shaka.util.ParsedTREXBox;
 /**
  * @typedef {{
  *    sampleCount: number,
- *    sampleData: !Array.<shaka.util.ParsedTRUNSample>
+ *    sampleData: !Array.<shaka.util.ParsedTRUNSample>,
+ *    dataOffset: ?number
  * }}
  *
  * @property {number} sampleCount
  *   As per the spec: the number of samples being added in this run;
  * @property {!Array.<shaka.util.ParsedTRUNSample>} sampleData
  *   An array of size <sampleCount> containing data for each sample
+ * @property {?number} dataOffset
+ *   If specified via flags, this indicate the offset of the sample in bytes.
  *
  * @exportDoc
  */

package/lib/util/platform.js

@@ -174,7 +174,7 @@ shaka.util.Platform = class {
    * @return {?number} A major version number or null if not Chromium-based.
    */
   static chromeVersion() {
-    if (!shaka.util.Platform.userAgentContains_('Chrome')) {
+    if (!shaka.util.Platform.isChrome()) {
       return null;
     }
 
@@ -213,6 +213,7 @@ shaka.util.Platform = class {
     return !!navigator.vendor && navigator.vendor.includes('Apple') &&
         !shaka.util.Platform.isTizen() &&
         !shaka.util.Platform.isEOS() &&
+        !shaka.util.Platform.isVirginMedia() &&
         !shaka.util.Platform.isPS4() &&
         !shaka.util.Platform.isAmazonFireTV();
   }
@@ -237,6 +238,13 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('PlayStation 4');
   }
 
+  /**
+   * Check if the current platform is Virgin Media device.
+   */
+  static isVirginMedia() {
+    return shaka.util.Platform.userAgentContains_('VirginMedia');
+  }
+
   /**
    * Check if the current platform is Amazon Fire TV.
    * https://developer.amazon.com/docs/fire-tv/identify-amazon-fire-tv-devices.html