shaka-player 3.1.5 → 3.2.3

package/lib/util/stream_utils.js

@@ -8,7 +8,6 @@ goog.provide('shaka.util.StreamUtils');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
-goog.require('shaka.media.MediaSourceEngine');
 goog.require('shaka.text.TextEngine');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.LanguageUtils');
@@ -28,30 +27,43 @@ shaka.util.StreamUtils = class {
    * bandwidth and filter out the rest.
    * Also filters out variants that have too many audio channels.
    * @param {!shaka.extern.Manifest} manifest
+   * @param {!Array.<string>} preferredVideoCodecs
+   * @param {!Array.<string>} preferredAudioCodecs
    * @param {number} preferredAudioChannelCount
+   * @param {!Array.<string>} preferredDecodingAttributes
    */
-  static chooseCodecsAndFilterManifest(manifest, preferredAudioChannelCount) {
+  static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
+      preferredAudioCodecs, preferredAudioChannelCount,
+      preferredDecodingAttributes) {
     const StreamUtils = shaka.util.StreamUtils;
 
-    // To start, consider a subset of variants based on audio channel
+    let variants = manifest.variants;
+    // To start, choose the codecs based on configured preferences if available.
+    if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
+      variants = StreamUtils.choosePreferredCodecs(variants,
+          preferredVideoCodecs, preferredAudioCodecs);
+    }
+
+    // Consider a subset of variants based on audio channel
     // preferences.
     // For some content (#1013), surround-sound variants will use a different
     // codec than stereo variants, so it is important to choose codecs **after**
     // considering the audio channel config.
-    const variants = StreamUtils.filterVariantsByAudioChannelCount(
-        manifest.variants, preferredAudioChannelCount);
+    variants = StreamUtils.filterVariantsByAudioChannelCount(
+        variants, preferredAudioChannelCount);
 
     // Now organize variants into buckets by codecs.
     /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
     let variantsByCodecs = StreamUtils.getVariantsByCodecs_(variants);
     variantsByCodecs = StreamUtils.filterVariantsByDensity_(variantsByCodecs);
 
-    const bestCodecs = StreamUtils.findBestCodecs_(variantsByCodecs);
+    const bestCodecs = StreamUtils.chooseCodecsByDecodingAttributes_(
+        variantsByCodecs, preferredDecodingAttributes);
 
     // Filter out any variants that don't match, forcing AbrManager to choose
-    // from the most efficient variants possible.
+    // from a single video codec and a single audio codec possible.
     manifest.variants = manifest.variants.filter((variant) => {
-      const codecs = StreamUtils.getGroupVariantCodecs_(variant);
+      const codecs = StreamUtils.getVariantCodecs_(variant);
       if (codecs == bestCodecs) {
         return true;
       }
@@ -71,8 +83,8 @@ shaka.util.StreamUtils = class {
   static getVariantsByCodecs_(variants) {
     const variantsByCodecs = new shaka.util.MultiMap();
     for (const variant of variants) {
-      const group = shaka.util.StreamUtils.getGroupVariantCodecs_(variant);
-      variantsByCodecs.push(group, variant);
+      const variantCodecs = shaka.util.StreamUtils.getVariantCodecs_(variant);
+      variantsByCodecs.push(variantCodecs, variant);
     }
 
     return variantsByCodecs;
@@ -80,6 +92,8 @@ shaka.util.StreamUtils = class {
 
   /**
   * Filters variants by density.
+  * Get variants by codecs map with the max density where all codecs are
+  * present.
   *
   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
@@ -120,6 +134,107 @@ shaka.util.StreamUtils = class {
     return maxDensity ? codecGroupsByDensity.get(maxDensity) : variantsByCodecs;
   }
 
+  /**
+   * Choose the codecs by configured preferred audio and video codecs.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {!Array.<string>} preferredVideoCodecs
+   * @param {!Array.<string>} preferredAudioCodecs
+   * @return {!Array<shaka.extern.Variant>}
+   */
+  static choosePreferredCodecs(variants, preferredVideoCodecs,
+      preferredAudioCodecs) {
+    let subset = variants;
+    for (const videoCodec of preferredVideoCodecs) {
+      const filtered = subset.filter((variant) => {
+        return variant.video && variant.video.codecs.startsWith(videoCodec);
+      });
+      if (filtered.length) {
+        subset = filtered;
+        break;
+      }
+    }
+
+    for (const audioCodec of preferredAudioCodecs) {
+      const filtered = subset.filter((variant) => {
+        return variant.audio && variant.audio.codecs.startsWith(audioCodec);
+      });
+      if (filtered.length) {
+        subset = filtered;
+        break;
+      }
+    }
+    return subset;
+  }
+
+  /**
+   * Choose the codecs by configured preferred decoding attributes.
+   *
+   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
+   * @param {!Array.<string>} attributes
+   * @return {string}
+   * @private
+   */
+  static chooseCodecsByDecodingAttributes_(variantsByCodecs, attributes) {
+    const StreamUtils = shaka.util.StreamUtils;
+
+    for (const attribute of attributes) {
+      if (attribute == StreamUtils.DecodingAttributes.SMOOTH ||
+          attribute == StreamUtils.DecodingAttributes.POWER) {
+        variantsByCodecs = StreamUtils.chooseCodecsByMediaCapabilitiesInfo_(
+            variantsByCodecs, attribute);
+        // If we only have one smooth or powerEfficient codecs, choose it as the
+        // best codecs.
+        if (variantsByCodecs.size() == 1) {
+          return variantsByCodecs.keys()[0];
+        }
+      } else if (attribute == StreamUtils.DecodingAttributes.BANDWIDTH) {
+        return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
+      }
+    }
+    // If there's no configured decoding preferences, or we have multiple codecs
+    // that meets the configured decoding preferences, choose the one with
+    // the lowest bandwidth.
+    return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
+  }
+
+  /**
+   * Choose the best codecs by configured preferred MediaCapabilitiesInfo
+   * attributes.
+   *
+   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
+   * @param {string} attribute
+   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
+   * @private
+   */
+  static chooseCodecsByMediaCapabilitiesInfo_(variantsByCodecs, attribute) {
+    let highestScore = 0;
+    const bestVariantsByCodecs = new shaka.util.MultiMap();
+    variantsByCodecs.forEach((codecs, variants) => {
+      let sum = 0;
+      let num = 0;
+
+      for (const variant of variants) {
+        if (variant.decodingInfos.length) {
+          sum += variant.decodingInfos[0][attribute] ? 1 : 0;
+          num++;
+        }
+      }
+
+      const averageScore = sum / num;
+      shaka.log.debug('codecs', codecs, 'avg', attribute, averageScore);
+
+      if (averageScore > highestScore) {
+        bestVariantsByCodecs.clear();
+        bestVariantsByCodecs.push(codecs, variants);
+        highestScore = averageScore;
+      } else if (averageScore == highestScore) {
+        bestVariantsByCodecs.push(codecs, variants);
+      }
+    });
+    return bestVariantsByCodecs;
+  }
+
   /**
    * Find the lowest-bandwidth (best) codecs.
    * Compute the average bandwidth for each group of variants.
@@ -128,7 +243,7 @@ shaka.util.StreamUtils = class {
    * @return {string}
    * @private
    */
-  static findBestCodecs_(variantsByCodecs) {
+  static findCodecsByLowestBandwidth_(variantsByCodecs) {
     let bestCodecs = '';
     let lowestAverageBandwidth = Infinity;
 
@@ -163,7 +278,7 @@ shaka.util.StreamUtils = class {
    * @return {string}
    * @private
    */
-  static getGroupVariantCodecs_(variant) {
+  static getVariantCodecs_(variant) {
     // Only consider the base of the codec string.  For example, these should
     // both be considered the same codec: avc1.42c01e, avc1.4d401f
     let baseVideoCodec = '';
@@ -183,7 +298,7 @@ shaka.util.StreamUtils = class {
    * Filter the variants in |manifest| to only include the variants that meet
    * the given restrictions.
    *
-   * @param {shaka.extern.Manifest} manifest
+   * @param {!shaka.extern.Manifest} manifest
    * @param {shaka.extern.Restrictions} restrictions
    * @param {{width: number, height:number}} maxHwResolution
    */
@@ -283,17 +398,11 @@ shaka.util.StreamUtils = class {
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {?shaka.extern.Variant} currentVariant
    * @param {shaka.extern.Manifest} manifest
-   * @param {boolean=} useMediaCapabilities
    */
   static async filterManifest(
-      drmEngine, currentVariant, manifest, useMediaCapabilities) {
-    if (useMediaCapabilities) {
-      await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
-          manifest.offlineSessionIds.length > 0);
-    } else {
-      shaka.util.StreamUtils.filterManifestByDrm(manifest, drmEngine);
-      shaka.util.StreamUtils.filterManifestByMediaSource(manifest);
-    }
+      drmEngine, currentVariant, manifest) {
+    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
+        manifest.offlineSessionIds.length > 0);
     shaka.util.StreamUtils.filterManifestByCurrentVariant(
         currentVariant, manifest);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
@@ -301,29 +410,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Filter the variants in |manifest| to only include those that are supported
-   * by |drm|.
-   * @param {shaka.extern.Manifest} manifest
-   * @param {shaka.media.DrmEngine} drmEngine
-   */
-  static filterManifestByDrm(manifest, drmEngine) {
-    manifest.variants = manifest.variants.filter((variant) => {
-      if (drmEngine && drmEngine.initialized()) {
-        if (!drmEngine.supportsVariant(variant)) {
-          shaka.log.debug('Dropping variant - not compatible with key system',
-              variant);
-          return false;
-        }
-        return true;
-      }
-
-      shaka.log.debug('DrmEngine is not initialized yet.');
-      return true;
-    });
-  }
-
-
   /**
    * Alters the given Manifest to filter out any streams unsupported by the
    * platform via MediaCapabilities.decodingInfo() API.
@@ -398,46 +484,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Filter the variants in the |manifest| to only include those that are
-   * supported by media source.
-   * TODO: remove once MediaCap implementations are done.
-   * @param {shaka.extern.Manifest} manifest
-   */
-  static filterManifestByMediaSource(manifest) {
-    const StreamUtils = shaka.util.StreamUtils;
-
-    manifest.variants = manifest.variants.filter((variant) => {
-      const audio = variant.audio;
-      const video = variant.video;
-
-      if (audio && !shaka.media.MediaSourceEngine.isStreamSupported(audio)) {
-        shaka.log.debug('Dropping variant - audio not compatible with platform',
-            StreamUtils.getStreamSummaryString_(audio));
-        return false;
-      }
-
-      if (video && !shaka.media.MediaSourceEngine.isStreamSupported(video)) {
-        shaka.log.debug('Dropping variant - video not compatible with platform',
-            StreamUtils.getStreamSummaryString_(video));
-        return false;
-      }
-
-      // See: https://github.com/google/shaka-player/issues/3380
-      if (shaka.util.Platform.isXboxOne() && video &&
-          ((video.width && video.width > 1920) ||
-          (video.height && video.height > 1080)) &&
-          video.codecs.includes('avc1.')) {
-        shaka.log.debug('Dropping variant - video not compatible with platform',
-            StreamUtils.getStreamSummaryString_(video));
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-
   /**
    * Get the decodingInfo results of the variants via MediaCapabilities.
    * This should be called after the DrmEngine is created and configured, and
@@ -994,6 +1040,31 @@ shaka.util.StreamUtils = class {
   static imageStreamToTrack(stream) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
+    let width = stream.width || null;
+    let height = stream.height || null;
+
+    // The stream width and height represent the size of the entire thumbnail
+    // sheet, so divide by the layout.
+    let reference = null;
+    // Note: segmentIndex is built by default for HLS, but not for DASH, but
+    // in DASH this information comes at the stream level and not at the
+    // segment level.
+    if (stream.segmentIndex) {
+      reference = stream.segmentIndex.get(0);
+    }
+    let layout = stream.tilesLayout;
+    if (reference) {
+      layout = reference.getTilesLayout() || layout;
+    }
+    if (layout && width != null) {
+      width /= Number(layout.split('x')[0]);
+    }
+    if (layout && height != null) {
+      height /= Number(layout.split('x')[1]);
+    }
+    // TODO: What happens if there are multiple grids, with different
+    // layout sizes, inside this image stream?
+
     /** @type {shaka.extern.Track} */
     const track = {
       id: stream.id,
@@ -1003,8 +1074,8 @@ shaka.util.StreamUtils = class {
       language: '',
       label: null,
       kind: null,
-      width: stream.width || null,
-      height: stream.height || null,
+      width,
+      height,
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
@@ -1021,7 +1092,7 @@ shaka.util.StreamUtils = class {
       channelsCount: null,
       audioSamplingRate: null,
       spatialAudio: false,
-      tilesLayout: stream.tilesLayout || null,
+      tilesLayout: layout || null,
       audioBandwidth: null,
       videoBandwidth: null,
       originalVideoId: null,
@@ -1422,3 +1493,12 @@ shaka.util.StreamUtils = class {
 
 /** @private {number} */
 shaka.util.StreamUtils.nextTrackId_ = 0;
+
+/**
+ * @enum {string}
+ */
+shaka.util.StreamUtils.DecodingAttributes = {
+  SMOOTH: 'smooth',
+  POWER: 'powerEfficient',
+  BANDWIDTH: 'bandwidth',
+};

package/lib/util/xml_utils.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.XmlUtils');
 
+goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.util.StringUtils');
 
@@ -331,29 +332,46 @@ shaka.util.XmlUtils = class {
 
 
   /**
-   * Parse a string and return the resulting root element if
-   * it was valid XML.
+   * Parse a string and return the resulting root element if it was valid XML.
+   *
    * @param {string} xmlString
    * @param {string} expectedRootElemName
    * @return {Element}
    */
   static parseXmlString(xmlString, expectedRootElemName) {
     const parser = new DOMParser();
-    let rootElem = null;
     let xml = null;
     try {
       xml = parser.parseFromString(xmlString, 'text/xml');
-    } catch (exception) {}
-    if (xml) {
-      // The top-level element in the loaded xml should have the
-      // same type as the element linking.
-      if (xml.documentElement.tagName == expectedRootElemName) {
-        rootElem = xml.documentElement;
-      }
+    } catch (exception) {
+      shaka.log.error('XML parsing exception:', exception);
+      return null;
     }
-    if (rootElem && rootElem.getElementsByTagName('parsererror').length > 0) {
+
+    // According to MDN, parseFromString never returns null.
+    goog.asserts.assert(xml, 'Parsed XML document cannot be null!');
+
+    // Check for empty documents.
+    const rootElem = xml.documentElement;
+    if (!rootElem) {
+      shaka.log.error('XML document was empty!');
       return null;
-    }  // It had a parser error in it.
+    }
+
+    // Check for parser errors.
+    const parserErrorElements = rootElem.getElementsByTagName('parsererror');
+    if (parserErrorElements.length) {
+      shaka.log.error('XML parser error found:', parserErrorElements[0]);
+      return null;
+    }
+
+    // The top-level element in the loaded XML should have the name we expect.
+    if (xml.documentElement.tagName != expectedRootElemName) {
+      shaka.log.error(
+          `XML tag name does not match expected "${expectedRootElemName}":`,
+          xml.documentElement.tagName);
+      return null;
+    }
 
     return rootElem;
   }
@@ -371,6 +389,7 @@ shaka.util.XmlUtils = class {
       const string = shaka.util.StringUtils.fromUTF8(data);
       return shaka.util.XmlUtils.parseXmlString(string, expectedRootElemName);
     } catch (exception) {
+      shaka.log.error('parseXmlString threw!', exception);
       return null;
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "3.1.5",
+  "version": "3.2.3",
   "homepage": "https://github.com/google/shaka-player",
   "author": "Google",
   "maintainers": [

package/roadmap.md

@@ -8,49 +8,51 @@ CHANGELOG.md.
 The goals of future milestones are fluid until we begin that development cycle,
 so the exact milestone for future features is not pre-determined.
 
-Candidate features for future release cycles
- - HLS performance improvements
-   https://github.com/google/shaka-player/issues/3363
- - HLS interstitial support
-   https://github.com/google/shaka-player/issues/3364
- - Integration with Google Video ML/Cloud AI
+Priority features up next:
  - Support containerless formats
    https://github.com/google/shaka-player/issues/2337
+ - Preload API
+   https://github.com/google/shaka-player/issues/880
+ - Codec-switching and order preference
+   https://github.com/google/shaka-player/issues/1528
+   https://github.com/google/shaka-player/issues/2179
+
+Candidate features for future release cycles:
+ - HLS interstitial support
+   https://github.com/google/shaka-player/issues/3364
  - Support ID3 tags in mp4
    https://github.com/google/shaka-player/issues/3351
  - MSE support for FairPlay
    https://github.com/google/shaka-player/issues/3346
- - Codec-switching and order preference
-   https://github.com/google/shaka-player/issues/1528
-   https://github.com/google/shaka-player/issues/2179
- - Configurable key-system priority
-   https://github.com/google/shaka-player/issues/3002
- - Preload API
-   https://github.com/google/shaka-player/issues/880
- - Thumbnail tracks
-   DASH: https://github.com/google/shaka-player/issues/559
-   HLS: https://github.com/google/shaka-player/issues/2429
  - Smaller, more modular binary
  - Official TypeScript defs, generated from source
    https://github.com/google/shaka-player/issues/1030
+ - Shaka Analytics Component and an integration with BigQuery Analytics
+   https://github.com/google/shaka-player/issues/3359
+ - Integration with Google Video ML/Cloud AI
 
-v3.3 - 2021 Q3
+v3.3 - 2021 Q3 or Q4
  - Background fetch for offline storage
    https://github.com/google/shaka-player/issues/879
- - Shaka Analytics Component and an integration with BigQuery Analytics
-   https://github.com/google/shaka-player/issues/3359
+ - HLS performance improvements
+   https://github.com/google/shaka-player/issues/3363
 
-v3.2 - 2021 Q2
+=====
+
+v3.2 - 2021 Q3
  - MediaCapabilities to make performance-based decisions
    https://github.com/google/shaka-player/issues/1391
+ - Configurable key-system priority
+   https://github.com/google/shaka-player/issues/3002
 
 v3.1 - 2021 Q2
  - Low-latency live (LL-HLS, LL-DASH)
    https://github.com/google/shaka-player/issues/1525
  - Own CEA parser, use mux.js only for TS
    https://github.com/google/shaka-player/issues/2648
-
-=====
+ - Thumbnail tracks
+   DASH: https://github.com/google/shaka-player/issues/559
+   HLS: https://github.com/google/shaka-player/issues/2429
 
 v3.0 - 2020 Q2
  - Code health improvements

package/shaka-player.uncompiled.js

@@ -32,6 +32,7 @@ goog.require('shaka.offline.OfflineManifestParser');
 goog.require('shaka.offline.OfflineScheme');
 goog.require('shaka.offline.Storage');
 goog.require('shaka.offline.indexeddb.StorageMechanism');
+goog.require('shaka.polyfill.Aria');
 goog.require('shaka.polyfill.EncryptionScheme');
 goog.require('shaka.polyfill.Fullscreen');
 goog.require('shaka.polyfill.MathRound');

package/test/cast/cast_utils_unit.js

@@ -27,6 +27,7 @@ describe('CastUtils', () => {
       'getAdManager',  // Handled specially
       'getSharedConfiguration',  // Handled specially
       'getNetworkingEngine',  // Handled specially
+      'getDrmEngine',  // Handled specially
       'getMediaElement',  // Handled specially
       'setMaxHardwareResolution',
       'destroy',  // Should use CastProxy.destroy instead

package/test/cea/cea608_memory_unit.js

@@ -17,7 +17,7 @@ describe('Cea608Memory', () => {
   /** @type {!shaka.cea.Cea608Memory} */
   let memory;
 
-  /** @type {!string} */
+  /** @type {string} */
   const stream = 'CC1';
 
   beforeEach(() => {

package/test/cea/cea708_service_unit.js

@@ -19,39 +19,39 @@ describe('Cea708Service', () => {
 
   /**
    * Hide window (2 bytes), with a bitmap provided to indicate all windows.
-   * @type {!Array<!number>}
+   * @type {!Array<number>}
    */
   const hideWindow = [0x8a, 0xff];
 
   /**
    * Define window (7 bytes), defines window #0 to be a visible window
    * with 32 rows and 32 columns. (We specify 31 for each since decoder adds 1).
-   * @type {!Array<!number>}
+   * @type {!Array<number>}
    */
   const defineWindow = [
     0x98, 0x38, 0x00, 0x00, 0x1f, 0x1f, 0x00,
   ];
 
-  /** @type {!number} */
+  /** @type {number} */
   const startTime = 1;
 
-  /** @type {!number} */
+  /** @type {number} */
   const endTime = 2;
 
   /**
    * We arbitrarily pick service 1 for all of these tests.
-   * @type {!number}
+   * @type {number}
    */
   const serviceNumber = 1;
 
-  /** @type {!string} */
+  /** @type {string} */
   const stream = `svc${serviceNumber}`;
 
   /**
    * Takes in a array of bytes and a presentation timestamp (in seconds),
    * and converts it into a CEA-708 DTVCC Packet.
-   * @param {!Array<!number>} bytes
-   * @param {!number} pts
+   * @param {!Array<number>} bytes
+   * @param {number} pts
    */
   const createCea708PacketFromBytes = (bytes, pts) => {
     const cea708Bytes = bytes.map((code, i) => {

package/test/cea/cea708_window_unit.js

@@ -15,22 +15,22 @@ describe('Cea708Window', () => {
   /** @type {!shaka.cea.Cea708Window} */
   let window;
 
-  /** @type {!number} */
+  /** @type {number} */
   const serviceNumber = 1; // We will arbitrarily pick service 1 for all tests.
 
-  /** @type {!string} */
+  /** @type {string} */
   const stream = `svc${serviceNumber}`;
 
-  /** @type {!number} */
+  /** @type {number} */
   const rowCount = 10;
 
-  /** @type {!number} */
+  /** @type {number} */
   const colCount = 32;
 
-  /** @type {!number} */
+  /** @type {number} */
   const startTime = 1;
 
-  /** @type {!number} */
+  /** @type {number} */
   const endTime = 2;
 
   beforeEach(() => {

package/test/cea/cea_decoder_unit.js

@@ -13,7 +13,7 @@ goog.require('shaka.text.Cue');
 describe('CeaDecoder', () => {
   const CeaUtils = shaka.test.CeaUtils;
 
-  /** @type {!string} */
+  /** @type {string} */
   const DEFAULT_BG_COLOR = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
 
   /**

package/test/cea/dtvcc_packet_builder_unit.js

@@ -11,10 +11,10 @@ describe('DtvccPacketBuilder', () => {
   /** @type {!shaka.cea.DtvccPacketBuilder} */
   let dtvccPacketBuilder;
 
-  /** @type {!number} */
+  /** @type {number} */
   const DTVCC_PACKET_START = shaka.cea.DtvccPacketBuilder.DTVCC_PACKET_START;
 
-  /** @type {!number} */
+  /** @type {number} */
   const DTVCC_PACKET_DATA = shaka.cea.DtvccPacketBuilder.DTVCC_PACKET_DATA;
 
   beforeEach(() => {