shaka-player 3.3.4 → 4.0.1

package/lib/util/manifest_parser_utils.js

@@ -167,7 +167,7 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
   /^hev/,
   /^hvc/,
   /^vp0?[89]/,
-  /^av1$/,
+  /^av01/,
 ];
 
 

package/lib/util/mime_utils.js

@@ -11,6 +11,7 @@ goog.require('shaka.media.Transmuxer');
 
 /**
  * @summary A set of utility functions for dealing with MIME types.
+ * @export
  */
 shaka.util.MimeUtils = class {
   /**
@@ -20,6 +21,7 @@ shaka.util.MimeUtils = class {
    * @param {string} mimeType
    * @param {string=} codecs
    * @return {string}
+   * @export
    */
   static getFullType(mimeType, codecs) {
     let fullMimeType = mimeType;
@@ -94,6 +96,53 @@ shaka.util.MimeUtils = class {
     return codecs.split(',');
   }
 
+  /**
+   * Get the normalized codec from a codec string,
+   * independently of their container.
+   *
+   * @param {string} codecString
+   * @return {string}
+   */
+  static getNormalizedCodec(codecString) {
+    const parts =
+      shaka.util.MimeUtils.getCodecParts_(codecString);
+    const base = parts[0];
+    const profile = parts[1].toLowerCase();
+    switch (true) {
+      case base === 'mp4a' && profile === '69':
+      case base === 'mp4a' && profile === '6b':
+        return 'mp3';
+      case base === 'mp4a' && profile === '66':
+      case base === 'mp4a' && profile === '67':
+      case base === 'mp4a' && profile === '68':
+      case base === 'mp4a' && profile === '40.2':
+      case base === 'mp4a' && profile === '40.02':
+      case base === 'mp4a' && profile === '40.5':
+      case base === 'mp4a' && profile === '40.05':
+      case base === 'mp4a' && profile === '40.29':
+      case base === 'mp4a' && profile === '40.42': // Extended HE-AAC
+        return 'aac';
+      case base === 'mp4a' && profile === 'a5':
+        return 'ac-3'; // Dolby Digital
+      case base === 'mp4a' && profile === 'a6':
+        return 'ec-3'; // Dolby Digital Plus
+      case base === 'mp4a' && profile === 'b2':
+        return 'dtsx'; // DTS:X
+      case base === 'mp4a' && profile === 'a9':
+        return 'dtsc'; // DTS Digital Surround
+      case base === 'avc1':
+      case base === 'avc3':
+        return 'avc'; // H264
+      case base === 'hvc1':
+      case base === 'hev1':
+        return 'hevc'; // H265
+      case base === 'dvh1':
+      case base === 'dvhe':
+        return 'dovi'; // Dolby Vision
+    }
+    return base;
+  }
+
   /**
    * Get the base codec from a codec string.
    *
@@ -150,7 +199,7 @@ shaka.util.MimeUtils = class {
 
     const base = parts[0];
 
-    parts.pop();
+    parts.shift();
     const profile = parts.join('.');
 
     // Make sure that we always return a "base" and "profile".

package/lib/util/periods.js

@@ -573,8 +573,8 @@ shaka.util.PeriodCombiner = class {
         // TODO(#1528): Consider changing this when we support codec switching.
         const hasCodec = outputStreams.some((s) => {
           return s.mimeType == stream.mimeType &&
-                shaka.util.MimeUtils.getCodecBase(s.codecs) ==
-                    shaka.util.MimeUtils.getCodecBase(stream.codecs);
+                shaka.util.MimeUtils.getNormalizedCodec(s.codecs) ==
+                    shaka.util.MimeUtils.getNormalizedCodec(stream.codecs);
         });
         if (!hasCodec) {
           continue;
@@ -1050,10 +1050,11 @@ shaka.util.PeriodCombiner = class {
    * @private
    */
   static areAVStreamsCompatible_(outputStream, candidate) {
-    const getCodecBase = (codecs) => shaka.util.MimeUtils.getCodecBase(codecs);
+    const getCodec = (codecs) =>
+      shaka.util.MimeUtils.getNormalizedCodec(codecs);
     // Check MIME type and codecs, which should always be the same.
     if (candidate.mimeType != outputStream.mimeType ||
-        getCodecBase(candidate.codecs) != getCodecBase(outputStream.codecs)) {
+        getCodec(candidate.codecs) != getCodec(outputStream.codecs)) {
       return false;
     }
 

package/lib/util/platform.js

@@ -142,6 +142,18 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('Web0S');
   }
 
+  /**
+   * Check if the current platform is a WebOS 3.
+   *
+   * @return {boolean}
+   */
+  static isWebOS3() {
+    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
+    return shaka.util.Platform.userAgentContains_('Web0S') &&
+        shaka.util.Platform.userAgentContains_(
+            'Chrome/38.0.2125.122 Safari/537.36');
+  }
+
   /**
    * Check if the current platform is a Google Chromecast.
    *
@@ -151,6 +163,16 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('CrKey');
   }
 
+  /**
+   * Check if the current platform is a Android-based Cast devices.
+   *
+   * @return {boolean}
+   */
+  static isAndroidCastDevice() {
+    return shaka.util.Platform.isChromecast() &&
+        shaka.util.Platform.userAgentContains_('Android');
+  }
+
   /**
    * Check if the current platform is Google Chrome.
    *
@@ -228,6 +250,16 @@ shaka.util.Platform = class {
     return null;
   }
 
+  /**
+   * Check if the current platform is Apple Safari
+   * or Safari-based iOS browsers.
+   *
+   * @return {boolean}
+   */
+  static isSafari() {
+    return !!shaka.util.Platform.safariVersion();
+  }
+
   /**
    * Guesses if the platform is a mobile one (iOS or Android).
    *
@@ -318,6 +350,19 @@ shaka.util.Platform = class {
     const Platform = shaka.util.Platform;
     return Platform.isTizen() || Platform.isXboxOne();
   }
+
+  /**
+   * Returns true if MediaKeys is polyfilled
+   *
+   * @return {boolean}
+   */
+  static isMediaKeysPolyfilled() {
+    if (window.shakaMediaKeysPolyfill) {
+      return true;
+    }
+
+    return false;
+  }
 };
 
 /** @private {shaka.util.Timer} */

package/lib/util/player_configuration.js

@@ -9,7 +9,6 @@ goog.provide('shaka.util.PlayerConfiguration');
 goog.require('goog.asserts');
 goog.require('shaka.abr.SimpleAbrManager');
 goog.require('shaka.log');
-goog.require('shaka.media.DrmEngine');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.LanguageUtils');
@@ -17,20 +16,15 @@ goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.Platform');
 
 
-// TODO(vaage): Many times in our configs, we need to create an empty
-//  implementation of a method, but to avoid closure from removing unused
-//  parameters (and breaking our merge config code) we need to use each
-//  parameter. Is there a better solution to this problem than what we are
-//  doing now?
-//
-//  NOTE: Chrome App Content Security Policy prohibits usage of new Function()
-
 /**
  * @final
  * @export
  */
 shaka.util.PlayerConfiguration = class {
-  /** @return {shaka.extern.PlayerConfiguration} */
+  /**
+   * @return {shaka.extern.PlayerConfiguration}
+   * @export
+   */
   static createDefault() {
     // This is a relatively safe default in the absence of clues from the
     // browser.  For slower connections, the default estimate may be too high.
@@ -72,7 +66,11 @@ shaka.util.PlayerConfiguration = class {
       clearKeys: {},  // key is arbitrary key system ID, value must be string
       advanced: {},    // key is arbitrary key system ID, value is a record type
       delayLicenseRequestUntilPlayed: false,
-      initDataTransform: shaka.media.DrmEngine.defaultInitDataTransform,
+      initDataTransform: (initData, initDataType, drmInfo) => {
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [initData, initDataType, drmInfo],
+            initData);
+      },
       logLicenseExchange: false,
       updateExpirationTime: 1,
       preferredKeySystems: [],
@@ -86,6 +84,7 @@ shaka.util.PlayerConfiguration = class {
       disableText: false,
       disableThumbnails: false,
       defaultPresentationDelay: 0,
+      segmentRelativeVttTiming: false,
       dash: {
         clockSyncUri: '',
         ignoreDrmInfo: false,
@@ -100,6 +99,8 @@ shaka.util.PlayerConfiguration = class {
         keySystemsByURI: {
           'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b':
             'org.w3.clearkey',
+          'urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e':
+            'org.w3.clearkey',
           'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
             'com.widevine.alpha',
           'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95':
@@ -109,19 +110,20 @@ shaka.util.PlayerConfiguration = class {
           'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb':
             'com.adobe.primetime',
         },
-        // Need some operation in the callback or else closure may remove calls
-        // to the function as it would be a no-op.  The operation can't just be
-        // a log message, because those are stripped in the compiled build.
         manifestPreprocessor: (element) => {
-          return element;
+          return shaka.util.ConfigUtils.referenceParametersAndReturn(
+              [element],
+              element);
         },
       },
       hls: {
         ignoreTextStreamFailures: false,
         ignoreImageStreamFailures: false,
-        useFullSegmentsForStartTime: false,
         defaultAudioCodec: 'mp4a.40.2',
         defaultVideoCodec: 'avc1.42E01E',
+        ignoreManifestProgramDateTime: false,
+        mediaPlaylistFullMimeType:
+            'video/mp2t; codecs="avc1.42E01E, mp4a.40.2"',
       },
     };
 
@@ -132,7 +134,9 @@ shaka.util.PlayerConfiguration = class {
       // log message, because those are stripped in the compiled build.
       failureCallback: (error) => {
         shaka.log.error('Unhandled streaming error', error);
-        return [error];
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [error],
+            undefined);
       },
       // When low latency streaming is enabled, rebufferingGoal will default to
       // 0.01 if not specified.
@@ -143,8 +147,6 @@ shaka.util.PlayerConfiguration = class {
       alwaysStreamText: false,
       startAtSegmentBoundary: false,
       gapDetectionThreshold: 0.1,
-      smallGapLimit: 0.5,
-      jumpLargeGaps: false,
       durationBackoff: 1,
       forceTransmuxTS: false,
       // Offset by 5 seconds since Chromecast takes a few seconds to start
@@ -210,7 +212,9 @@ shaka.util.PlayerConfiguration = class {
       // to the function as it would be a no-op.  The operation can't just be a
       // log message, because those are stripped in the compiled build.
       progressCallback: (content, progress) => {
-        return [content, progress];
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [content, progress],
+            undefined);
       },
 
       // By default we use persistent licenses as forces errors to surface if
@@ -218,6 +222,8 @@ shaka.util.PlayerConfiguration = class {
       // unexpected behaviours when someone tries to plays downloaded content
       // without a persistent license.
       usePersistentLicense: true,
+
+      numberOfParallelDownloads: 5,
     };
 
     const abr = {

package/lib/util/pssh.js

@@ -90,16 +90,21 @@ shaka.util.Pssh = class {
   }
 
   /**
-   * Creates a pssh blob from the given system ID and data.
+   * Creates a pssh blob from the given system ID, data, keyIds and version.
    *
    * @param {!Uint8Array} data
    * @param {!Uint8Array} systemId
+   * @param {!Set.<string>} keyIds
+   * @param {number} version
    * @return {!Uint8Array}
    */
-  static createPssh(data, systemId) {
+  static createPssh(data, systemId, keyIds, version) {
     goog.asserts.assert(systemId.byteLength == 16, 'Invalid system ID length');
     const dataLength = data.length;
-    const psshSize = 0x4 + 0x4 + 0x4 + systemId.length + 0x4 + dataLength;
+    let psshSize = 0x4 + 0x4 + 0x4 + systemId.length + 0x4 + dataLength;
+    if (version > 0) {
+      psshSize += 0x4 + (16 * keyIds.size);
+    }
 
     /** @type {!Uint8Array} */
     const psshBox = new Uint8Array(psshSize);
@@ -111,10 +116,24 @@ shaka.util.Pssh = class {
     byteCursor += 0x4;
     psshData.setUint32(byteCursor, 0x70737368);  // 'pssh'
     byteCursor += 0x4;
-    psshData.setUint32(byteCursor, 0);  // flags
+    (version < 1) ? psshData.setUint32(byteCursor, 0) :
+        psshData.setUint32(byteCursor, 0x01000000); // version + flags
     byteCursor += 0x4;
     psshBox.set(systemId, byteCursor);
     byteCursor += systemId.length;
+
+    // if version > 0, add KID count and kid values.
+    if (version > 0) {
+      psshData.setUint32(byteCursor, keyIds.size); // KID_count
+      byteCursor += 0x4;
+      const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+      for (const keyId of keyIds) {
+        const KID = Uint8ArrayUtils.fromHex(keyId);
+        psshBox.set(KID, byteCursor);
+        byteCursor += KID.length;
+      }
+    }
+
     psshData.setUint32(byteCursor, dataLength);
     byteCursor += 0x4;
     psshBox.set(data, byteCursor);

package/lib/util/stream_utils.js

@@ -283,12 +283,14 @@ shaka.util.StreamUtils = class {
     // both be considered the same codec: avc1.42c01e, avc1.4d401f
     let baseVideoCodec = '';
     if (variant.video) {
-      baseVideoCodec = shaka.util.MimeUtils.getCodecBase(variant.video.codecs);
+      baseVideoCodec =
+        shaka.util.MimeUtils.getNormalizedCodec(variant.video.codecs);
     }
 
     let baseAudioCodec = '';
     if (variant.audio) {
-      baseAudioCodec = shaka.util.MimeUtils.getCodecBase(variant.audio.codecs);
+      baseAudioCodec =
+        shaka.util.MimeUtils.getNormalizedCodec(variant.audio.codecs);
     }
 
     return baseVideoCodec + '-' + baseAudioCodec;
@@ -406,7 +408,7 @@ shaka.util.StreamUtils = class {
     shaka.util.StreamUtils.filterManifestByCurrentVariant(
         currentVariant, manifest);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
-    shaka.util.StreamUtils.filterImageStreams_(manifest);
+    await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
 
 
@@ -813,37 +815,57 @@ shaka.util.StreamUtils = class {
    * @param {shaka.extern.Manifest} manifest
    * @private
    */
-  static filterImageStreams_(manifest) {
-    // Filter image streams.
-    manifest.imageStreams = manifest.imageStreams.filter((stream) => {
-      // TODO: re-examine this and avoid allow-listing the MIME types we can
-      // accept.
-      const validMimeTypes = [
-        'image/svg+xml',
-        'image/png',
-        'image/jpeg',
-      ];
-      const Platform = shaka.util.Platform;
-      // Add webp support to popular platforms that support it.
-      const webpSupport = Platform.isWebOS() ||
-                          Platform.isTizen() ||
-                          Platform.isChromecast();
-      if (webpSupport) {
-        validMimeTypes.push('image/webp');
+  static async filterImageStreams_(manifest) {
+    const imageStreams = [];
+    for (const stream of manifest.imageStreams) {
+      const mimeType = stream.mimeType;
+      if (!shaka.util.StreamUtils.supportedImageMimeTypes_.has(mimeType)) {
+        const minImage = shaka.util.StreamUtils.minImage_.get(mimeType);
+        if (minImage) {
+          // eslint-disable-next-line no-await-in-loop
+          const res = await shaka.util.StreamUtils.isImageSupported_(minImage);
+          shaka.util.StreamUtils.supportedImageMimeTypes_.set(mimeType, res);
+        } else {
+          shaka.util.StreamUtils.supportedImageMimeTypes_.set(mimeType, false);
+        }
       }
-      // TODO: add support to image/webp and image/avif
-      const keep = validMimeTypes.includes(stream.mimeType);
+
+      const keep =
+          shaka.util.StreamUtils.supportedImageMimeTypes_.get(mimeType);
 
       if (!keep) {
         shaka.log.debug('Dropping image stream. Is not supported by the ' +
                         'platform.', stream);
+      } else {
+        imageStreams.push(stream);
       }
+    }
+    manifest.imageStreams = imageStreams;
+  }
 
-      return keep;
+  /**
+   * @param {string} minImage
+   * @return {!Promise.<boolean>}
+   * @private
+   */
+  static isImageSupported_(minImage) {
+    return new Promise((resolve) => {
+      const imageElement = /** @type {HTMLImageElement} */(new Image());
+      imageElement.src = minImage;
+      if ('decode' in imageElement) {
+        imageElement.decode().then(() => {
+          resolve(true);
+        }).catch(() => {
+          resolve(false);
+        });
+      } else {
+        imageElement.onload = imageElement.onerror = () => {
+          resolve(imageElement.height === 2);
+        };
+      }
     });
   }
 
-
   /**
    * @param {shaka.extern.Stream} s0
    * @param {shaka.extern.Stream} s1
@@ -878,6 +900,11 @@ shaka.util.StreamUtils = class {
     /** @type {?shaka.extern.Stream} */
     const video = variant.video;
 
+    /** @type {?string} */
+    const audioMimeType = audio ? audio.mimeType : null;
+    /** @type {?string} */
+    const videoMimeType = video ? video.mimeType : null;
+
     /** @type {?string} */
     const audioCodec = audio ? audio.codecs : null;
     /** @type {?string} */
@@ -942,6 +969,8 @@ shaka.util.StreamUtils = class {
       pixelAspectRatio: null,
       hdr: null,
       mimeType: mimeType,
+      audioMimeType: audioMimeType,
+      videoMimeType: videoMimeType,
       codecs: codecs.join(', '),
       audioCodec: audioCodec,
       videoCodec: videoCodec,
@@ -1009,6 +1038,8 @@ shaka.util.StreamUtils = class {
       pixelAspectRatio: null,
       hdr: null,
       mimeType: stream.mimeType,
+      audioMimeType: null,
+      videoMimeType: null,
       codecs: stream.codecs || null,
       audioCodec: null,
       videoCodec: null,
@@ -1081,6 +1112,8 @@ shaka.util.StreamUtils = class {
       pixelAspectRatio: null,
       hdr: null,
       mimeType: stream.mimeType,
+      audioMimeType: null,
+      videoMimeType: null,
       codecs: null,
       audioCodec: null,
       videoCodec: null,
@@ -1199,6 +1232,8 @@ shaka.util.StreamUtils = class {
       pixelAspectRatio: null,
       hdr: null,
       mimeType: null,
+      audioMimeType: null,
+      videoMimeType: null,
       codecs: null,
       audioCodec: null,
       videoCodec: null,
@@ -1503,3 +1538,40 @@ shaka.util.StreamUtils.DecodingAttributes = {
   POWER: 'powerEfficient',
   BANDWIDTH: 'bandwidth',
 };
+
+/**
+ * @private {!Map.<string, boolean>}
+ */
+shaka.util.StreamUtils.supportedImageMimeTypes_ = new Map()
+    .set('image/svg+xml', true)
+    .set('image/png', true)
+    .set('image/jpeg', true)
+    .set('image/jpg', true);
+
+/**
+ * @const {string}
+ * @private
+ */
+shaka.util.StreamUtils.minWebPImage_ = 'data:image/webp;base64,UklGRjoAAABXRU' +
+    'JQVlA4IC4AAACyAgCdASoCAAIALmk0mk0iIiIiIgBoSygABc6WWgAA/veff/0PP8bA//LwY' +
+    'AAA';
+
+/**
+ * @const {string}
+ * @private
+ */
+shaka.util.StreamUtils.minAvifImage_ = 'data:image/avif;base64,AAAAIGZ0eXBhdm' +
+    'lmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljd' +
+    'AAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEA' +
+    'AAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAA' +
+    'AamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAA' +
+    'xhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAA' +
+    'CVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=';
+
+/**
+ * @const {!Map.<string, string>}
+ * @private
+ */
+shaka.util.StreamUtils.minImage_ = new Map()
+    .set('image/webp', shaka.util.StreamUtils.minWebPImage_)
+    .set('image/avif', shaka.util.StreamUtils.minAvifImage_);

package/lib/util/uint8array_utils.js

@@ -6,7 +6,6 @@
 
 goog.provide('shaka.util.Uint8ArrayUtils');
 
-goog.require('shaka.Deprecate');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.StringUtils');
 
@@ -17,21 +16,6 @@ goog.require('shaka.util.StringUtils');
  * @export
  */
 shaka.util.Uint8ArrayUtils = class {
-  /**
-   * Compare two Uint8Arrays for equality.
-   * @param {Uint8Array} arr1
-   * @param {Uint8Array} arr2
-   * @return {boolean}
-   * @deprecated
-   * @export
-   */
-  static equal(arr1, arr2) {
-    shaka.Deprecate.deprecateFeature(4,
-        'shaka.util.Uint8ArrayUtils.equal',
-        'Please use shaka.util.BufferUtils.equal instead.');
-    return shaka.util.BufferUtils.equal(arr1, arr2);
-  }
-
   /**
    * Convert a buffer to a base64 string. The output will be standard
    * alphabet as opposed to base64url safe alphabet.

package/lib/util/xml_utils.js

@@ -199,7 +199,7 @@ shaka.util.XmlUtils = class {
     }
 
     const result = Date.parse(dateString);
-    return (!isNaN(result) ? Math.floor(result / 1000.0) : null);
+    return isNaN(result) ? null : (result / 1000.0);
   }
 
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "3.3.4",
+  "version": "4.0.1",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -97,5 +97,8 @@
   },
   "dependencies": {
     "eme-encryption-scheme-polyfill": "^2.0.3"
+  },
+  "engines": {
+    "node": ">=14"
   }
 }

package/roadmap.md

@@ -9,41 +9,41 @@ The goals of future milestones are fluid until we begin that development cycle,
 so the exact milestone for future features is not pre-determined.
 
 Priority features up next:
- - Support containerless formats
-   https://github.com/shaka-project/shaka-player/issues/2337
  - Preload API
    https://github.com/shaka-project/shaka-player/issues/880
- - Codec-switching and order preference
-   https://github.com/shaka-project/shaka-player/issues/1528
-   https://github.com/shaka-project/shaka-player/issues/2179
 
 Candidate features for future release cycles:
- - HLS interstitial support
-   https://github.com/shaka-project/shaka-player/issues/3364
- - Support ID3 tags in mp4
-   https://github.com/shaka-project/shaka-player/issues/3351
- - MSE support for FairPlay
-   https://github.com/shaka-project/shaka-player/issues/3346
- - Smaller, more modular binary
  - Official TypeScript defs, generated from source
    https://github.com/shaka-project/shaka-player/issues/1030
- - Shaka Analytics Component and an integration with BigQuery Analytics
-   https://github.com/shaka-project/shaka-player/issues/3359
- - Integration with Google Video ML/Cloud AI
-
-v3.3 - 2021 Q3 or Q4
+ - Codec-switching
+   https://github.com/shaka-project/shaka-player/issues/1528
  - Background fetch for offline storage
    https://github.com/shaka-project/shaka-player/issues/879
- - HLS performance improvements
-   https://github.com/shaka-project/shaka-player/issues/3363
+ - Support ID3 tags in mp4
+   https://github.com/shaka-project/shaka-player/issues/3351
+ - Smaller, more modular binary
+
+v3.4 - 2022 Q1 or Q2
+ - MSE support for FairPlay
+   https://github.com/shaka-project/shaka-player/issues/3346
+ - Support containerless formats
+   https://github.com/shaka-project/shaka-player/issues/2337
 
 =====
 
+v3.3 - 2022 Q1
+ - Common Media Client Data (CMCD) logging support
+   https://github.com/shaka-project/shaka-player/issues/3619
+ - Non-linear IMA CS ads
+   https://github.com/shaka-project/shaka-player/pull/3639
+
 v3.2 - 2021 Q3
  - MediaCapabilities to make performance-based decisions
    https://github.com/shaka-project/shaka-player/issues/1391
  - Configurable key-system priority
    https://github.com/shaka-project/shaka-player/issues/3002
+ - Codec order preferences
+   https://github.com/shaka-project/shaka-player/issues/2179
 
 v3.1 - 2021 Q2
  - Low-latency live (LL-HLS, LL-DASH)