shaka-player 4.2.5 → 4.3.1

package/lib/polyfill/media_capabilities.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.polyfill.MediaCapabilities');
 
 goog.require('shaka.log');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.polyfill');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Platform');
@@ -100,11 +101,14 @@ shaka.polyfill.MediaCapabilities = class {
     const videoConfig = mediaDecodingConfig['video'];
     const audioConfig = mediaDecodingConfig['audio'];
 
+    const Capabilities = shaka.media.Capabilities;
+
     if (mediaDecodingConfig.type == 'media-source') {
       if (!shaka.util.Platform.supportsMediaSource()) {
         return res;
       }
-      // Use 'MediaSource.isTypeSupported' to check if the stream is supported.
+      // Use 'shaka.media.Capabilities.isTypeSupported'to check if
+      // the stream is supported.
       // Cast platforms will additionally check canDisplayType(), which
       // accepts extended MIME type parameters.
       // See: https://github.com/shaka-project/shaka-player/issues/4726
@@ -114,7 +118,7 @@ shaka.polyfill.MediaCapabilities = class {
           isSupported =
               shaka.polyfill.MediaCapabilities.canCastDisplayType_(videoConfig);
         } else {
-          isSupported = MediaSource.isTypeSupported(videoConfig.contentType);
+          isSupported = Capabilities.isTypeSupported(videoConfig.contentType);
         }
         if (!isSupported) {
           return res;
@@ -123,7 +127,7 @@ shaka.polyfill.MediaCapabilities = class {
 
       if (audioConfig) {
         const contentType = audioConfig.contentType;
-        const isSupported = MediaSource.isTypeSupported(contentType);
+        const isSupported = Capabilities.isTypeSupported(contentType);
         if (!isSupported) {
           return res;
         }
@@ -231,8 +235,8 @@ shaka.polyfill.MediaCapabilities = class {
           shaka.util.Error.Code.CAST_API_UNAVAILABLE);
     } else if (!(cast.__platform__ && cast.__platform__.canDisplayType)) {
       shaka.log.warning('Expected cast APIs to be available! Falling back to ' +
-          'MediaSource.isTypeSupported() for type support.');
-      return MediaSource.isTypeSupported(videoConfig.contentType);
+          'shaka.media.Capabilities.isTypeSupported() for type support.');
+      return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
     }
 
     let displayType = videoConfig.contentType;

package/lib/polyfill/patchedmediakeys_apple.js

@@ -27,18 +27,38 @@ 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) {
+    // Alias
+    const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
+
     if (!window.HTMLVideoElement || !window.WebKitMediaKeys) {
       // No HTML5 video or no prefixed EME.
       return;
     }
 
-    shaka.log.info('Using Apple-prefixed EME');
+    if (enableUninstall) {
+      PatchedMediaKeysApple.enableUninstall = true;
+      PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys =
+        /** @type {!Object} */ (
+          Object.getOwnPropertyDescriptor(
+              // eslint-disable-next-line no-restricted-syntax
+              HTMLMediaElement.prototype, 'mediaKeys',
+          )
+        );
+      PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys =
+          // eslint-disable-next-line no-restricted-syntax
+          HTMLMediaElement.prototype.setMediaKeys;
+      PatchedMediaKeysApple.originalWindowMediaKeys = window.MediaKeys;
+      PatchedMediaKeysApple.originalWindowMediaKeySystemAccess =
+          window.MediaKeySystemAccess;
+      PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess =
+          navigator.requestMediaKeySystemAccess;
+    }
 
-    // Alias
-    const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
+    shaka.log.info('Using Apple-prefixed EME');
 
     // Delete mediaKeys to work around strict mode compatibility issues.
     // eslint-disable-next-line no-restricted-syntax
@@ -59,6 +79,45 @@ shaka.polyfill.PatchedMediaKeysApple = class {
     window.shakaMediaKeysPolyfill = true;
   }
 
+  /**
+   * Uninstalls the polyfill if needed and enabled.
+   * @export
+   */
+  static uninstall() {
+    // Alias
+    const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
+
+    if (!PatchedMediaKeysApple.enableUninstall) {
+      return;
+    }
+
+    shaka.log.info('Un-installing Apple-prefixed EME');
+
+    PatchedMediaKeysApple.enableUninstall = false;
+    Object.defineProperty(
+        // eslint-disable-next-line no-restricted-syntax
+        HTMLMediaElement.prototype,
+        'mediaKeys',
+        PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys,
+    );
+    // eslint-disable-next-line no-restricted-syntax
+    HTMLMediaElement.prototype.setMediaKeys =
+        PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys;
+    window.MediaKeys = PatchedMediaKeysApple.originalWindowMediaKeys;
+    window.MediaKeySystemAccess =
+        PatchedMediaKeysApple.originalWindowMediaKeySystemAccess;
+    navigator.requestMediaKeySystemAccess =
+        PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess;
+
+    PatchedMediaKeysApple.originalWindowMediaKeys = null;
+    PatchedMediaKeysApple.originalWindowMediaKeySystemAccess = null;
+    PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys = null;
+    PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess = null;
+    PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys = null;
+
+    window.shakaMediaKeysPolyfill = false;
+  }
+
   /**
    * An implementation of navigator.requestMediaKeySystemAccess.
    * Retrieves a MediaKeySystemAccess object.

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/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

@@ -7,6 +7,7 @@
 goog.provide('shaka.util.Mp4BoxParsers');
 
 goog.require('shaka.util.DataViewReader');
+goog.require('shaka.util.Mp4Parser');
 
 shaka.util.Mp4BoxParsers = class {
   /**
@@ -18,12 +19,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 +47,7 @@ shaka.util.Mp4BoxParsers = class {
       trackId,
       defaultSampleDuration,
       defaultSampleSize,
+      baseDataOffset,
     };
   }
 
@@ -112,10 +115,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 +163,7 @@ shaka.util.Mp4BoxParsers = class {
     return {
       sampleCount,
       sampleData,
+      dataOffset,
     };
   }
 
@@ -184,6 +189,17 @@ shaka.util.Mp4BoxParsers = class {
       trackId,
     };
   }
+
+  /**
+   * Parses a FRMA box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedFRMABox}
+   */
+  static parseFRMA(reader) {
+    const fourcc = reader.readUint32();
+    const codec = shaka.util.Mp4Parser.typeToString(fourcc);
+    return {codec};
+  }
 };
 
 
@@ -191,7 +207,8 @@ shaka.util.Mp4BoxParsers = class {
  * @typedef {{
  *    trackId: number,
  *    defaultSampleDuration: ?number,
- *    defaultSampleSize: ?number
+ *    defaultSampleSize: ?number,
+ *    baseDataOffset: ?number
  * }}
  *
  * @property {number} trackId
@@ -203,6 +220,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 +271,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
  */
@@ -296,3 +318,15 @@ shaka.util.ParsedTRUNSample;
  * @exportDoc
  */
 shaka.util.ParsedTKHDBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *   A fourcc for a codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedFRMABox;