shaka-player 3.2.2 → 3.3.2

package/lib/util/fake_event_target.js

@@ -9,6 +9,7 @@ goog.provide('shaka.util.FakeEventTarget');
 goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.MultiMap');
 
 
@@ -18,13 +19,14 @@ goog.require('shaka.util.MultiMap');
  * to non-DOM classes.  Only FakeEvents should be dispatched.
  *
  * @implements {EventTarget}
+ * @implements {shaka.util.IReleasable}
  * @exportInterface
  */
 shaka.util.FakeEventTarget = class {
   /** */
   constructor() {
     /**
-     * @private {!shaka.util.MultiMap.<shaka.util.FakeEventTarget.ListenerType>}
+     * @private {shaka.util.MultiMap.<shaka.util.FakeEventTarget.ListenerType>}
      */
     this.listeners_ = new shaka.util.MultiMap();
 
@@ -46,6 +48,9 @@ shaka.util.FakeEventTarget = class {
    * @exportInterface
    */
   addEventListener(type, listener, options) {
+    if (!this.listeners_) {
+      return;
+    }
     this.listeners_.push(type, listener);
   }
 
@@ -73,6 +78,9 @@ shaka.util.FakeEventTarget = class {
    * @exportInterface
    */
   removeEventListener(type, listener, options) {
+    if (!this.listeners_) {
+      return;
+    }
     this.listeners_.remove(type, listener);
   }
 
@@ -90,6 +98,10 @@ shaka.util.FakeEventTarget = class {
     goog.asserts.assert(event instanceof shaka.util.FakeEvent,
         'FakeEventTarget can only dispatch FakeEvents!');
 
+    if (!this.listeners_) {
+      return true;
+    }
+
     let listeners = this.listeners_.get(event.type) || [];
     const universalListeners =
       this.listeners_.get(shaka.util.FakeEventTarget.ALL_EVENTS_);
@@ -129,6 +141,14 @@ shaka.util.FakeEventTarget = class {
 
     return event.defaultPrevented;
   }
+
+  /**
+   * @override
+   * @exportInterface
+   */
+  release() {
+    this.listeners_ = null;
+  }
 };
 
 /**

package/lib/util/language_utils.js

@@ -13,6 +13,7 @@ goog.require('shaka.util.ManifestParserUtils');
 /**
  * @summary A set of language utility functions.
  * @final
+ * @export
  */
 shaka.util.LanguageUtils = class {
   /**
@@ -32,6 +33,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLocaleCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -62,6 +64,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLanguageCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -102,6 +105,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} possibleParent
    * @param {string} possibleChild
    * @return {boolean}
+   * @export
    */
   static isParentOf(possibleParent, possibleChild) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -146,6 +150,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} localeA
    * @param {string} localeB
    * @return {boolean}
+   * @export
    */
   static isSiblingOf(localeA, localeB) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -181,6 +186,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} locale
    * @return {string}
+   * @export
    */
   static normalize(locale) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -217,6 +223,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} a
    * @param {string} b
    * @return {boolean}
+   * @export
    */
   static areSiblings(a, b) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -235,6 +242,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {string} candidate
    * @return {number}
+   * @export
    */
   static relatedness(target, candidate) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -271,6 +279,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} lang
    * @return {string}
+   * @export
    */
   static getBase(lang) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -300,6 +309,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Stream} stream
    * @return {string}
+   * @export
    */
   static getLocaleForText(stream) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -322,6 +332,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Variant} variant
    * @return {string}
+   * @export
    */
   static getLocaleForVariant(variant) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -356,6 +367,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {!Iterable.<string>} searchSpace
    * @return {?string}
+   * @export
    */
   static findClosestLocale(target, searchSpace) {
     const LanguageUtils = shaka.util.LanguageUtils;

package/lib/util/mutex.js

@@ -0,0 +1,52 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.Mutex');
+
+
+/**
+ * @summary A simple mutex.
+ */
+shaka.util.Mutex = class {
+  /** Creates the mutex. */
+  constructor() {
+    /** @private {!Array.<function()>} */
+    this.waiting_ = [];
+
+    /** @private {number} */
+    this.nextMutexId_ = 0;
+
+    /** @private {number} */
+    this.acquiredMutexId_ = 0;
+  }
+
+  /** @return {!Promise.<number>} mutexId */
+  async acquire() {
+    const mutexId = ++this.nextMutexId_;
+    if (!this.acquiredMutexId_) {
+      this.acquiredMutexId_ = mutexId;
+    } else {
+      await (new Promise((resolve, reject) => {
+        this.waiting_.push(() => {
+          this.acquiredMutexId_ = mutexId;
+          resolve();
+        });
+      }));
+    }
+    return mutexId;
+  }
+
+  /** @param {number} mutexId */
+  release(mutexId) {
+    if (mutexId == this.acquiredMutexId_) {
+      this.acquiredMutexId_ = 0;
+      if (this.waiting_.length > 0) {
+        const callback = this.waiting_.shift();
+        callback();
+      }
+    }
+  }
+};

package/lib/util/periods.js

@@ -547,8 +547,7 @@ shaka.util.PeriodCombiner = class {
       for (const stream of unusedStreams) {
         // Create a new output stream which includes this input stream.
         const outputStream =
-            // eslint-disable-next-line no-await-in-loop
-            await shaka.util.PeriodCombiner.createNewOutputStream_(
+            shaka.util.PeriodCombiner.createNewOutputStream_(
                 stream, streamsPerPeriod, clone, concat,
                 unusedStreamsPerPeriod);
         if (outputStream) {
@@ -619,52 +618,69 @@ shaka.util.PeriodCombiner = class {
   static async extendExistingOutputStream_(
       outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
       unusedStreamsPerPeriod) {
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // We were unable to extend this output stream.
-      shaka.log.error('No matches extending output stream!',
-          outputStream, streamsPerPeriod);
-      return false;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream, and this should only ever be called
     // on Stream types.  StreamDB should not have pre-existing output streams.
     goog.asserts.assert(outputStream.createSegmentIndex,
         'outputStream should be a Stream type!');
 
+    if (!outputStream.matchedStreams) {
+      // We were unable to extend this output stream.
+      shaka.log.error('No matches extending output stream!',
+          outputStream, streamsPerPeriod);
+      return false;
+    }
     // We need to create all the per-period segment indexes and append them to
     // the output's MetaSegmentIndex.
-    await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
-
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
+    if (outputStream.segmentIndex) {
+      await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(outputStream,
+          firstNewPeriodIndex);
+    }
 
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, firstNewPeriodIndex, concat,
-        unusedStreamsPerPeriod);
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        firstNewPeriodIndex, concat, unusedStreamsPerPeriod);
     return true;
   }
 
   /**
-   * Creates all segment indexes for an array of streams.  Returns once every
-   * segment index is created.
+   * Creates the segment indexes for an array of input streams, and append them
+   * to the output stream's segment index.
    *
-   * @param {!Array.<!shaka.extern.Stream>} streams
-   * @return {!Promise}
+   * @param {shaka.extern.Stream} outputStream
+   * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
+   *   represents the first new period that hasn't been processed yet.
    * @private
    */
-  static createSegmentIndexes_(streams) {
+  static async extendOutputSegmentIndex_(outputStream, firstNewPeriodIndex) {
     const operations = [];
+    const streams = outputStream.matchedStreams;
+    goog.asserts.assert(streams, 'matched streams should be valid');
+
     for (const stream of streams) {
       operations.push(stream.createSegmentIndex());
       if (stream.trickModeVideo && !stream.trickModeVideo.segmentIndex) {
         operations.push(stream.trickModeVideo.createSegmentIndex());
       }
     }
-    return Promise.all(operations);
+    await Promise.all(operations);
+
+    // Concatenate the new matches onto the stream, starting at the first new
+    // period.
+    const Iterables = shaka.util.Iterables;
+    // Satisfy the compiler about the type.
+    // Also checks if the segmentIndex is still valid after the async
+    // operations, to make sure we stop if the active stream has changed.
+    if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
+      for (const {i, item: match} of Iterables.enumerate(streams)) {
+        if (match.segmentIndex && i >= firstNewPeriodIndex) {
+          goog.asserts.assert(match.segmentIndex,
+              'stream should have a segmentIndex.');
+          outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
+        }
+      }
+    }
   }
 
   /**
@@ -682,7 +698,7 @@ shaka.util.PeriodCombiner = class {
    * @param {!Array.<!Set.<T>>} unusedStreamsPerPeriod An array of sets of
    *   unused streams from each period.
    *
-   * @return {!Promise.<?T>} A newly-created output Stream, or null if matches
+   * @return {?T} A newly-created output Stream, or null if matches
    *   could not be found.`
    *
    * @template T
@@ -690,35 +706,36 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static async createNewOutputStream_(
+  static createNewOutputStream_(
       stream, streamsPerPeriod, clone, concat, unusedStreamsPerPeriod) {
     // Start by cloning the stream without segments, key IDs, etc.
     const outputStream = clone(stream);
 
     // Find best-matching streams in all periods.
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // This is not a stream we can build output from, but it may become part
-      // of another output based on another period's stream.
-      return null;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream.
     if (outputStream.createSegmentIndex) {
+      // Override the createSegmentIndex function of the outputStream.
+      outputStream.createSegmentIndex = async () => {
+        if (!outputStream.segmentIndex) {
+          outputStream.segmentIndex = new shaka.media.MetaSegmentIndex();
+          await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(
+              outputStream, /* firstNewPeriodIndex= */ 0);
+        }
+      };
       // For T == Stream, we need to create all the per-period segment indexes
       // in advance.  concat() will add them to the output's MetaSegmentIndex.
-      await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
     }
 
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
-
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, /* firstNewPeriodIndex= */ 0, concat,
-        unusedStreamsPerPeriod);
+    if (!outputStream.matchedStreams) {
+      // This is not a stream we can build output from, but it may become part
+      // of another output based on another period's stream.
+      return null;
+    }
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        /* firstNewPeriodIndex= */ 0, concat, unusedStreamsPerPeriod);
 
     return outputStream;
   }
@@ -726,7 +743,6 @@ shaka.util.PeriodCombiner = class {
   /**
    * @param {T} outputStream An existing output stream which needs to be
    *   extended into new periods.
-   * @param {!Array.<T>} matches A list of matching Streams from each period.
    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
    *   represents the first new period that hasn't been processed yet.
    * @param {function(T, T)} concat Concatenate the second stream onto the end
@@ -740,10 +756,15 @@ shaka.util.PeriodCombiner = class {
    * @private
    */
   static extendOutputStream_(
-      outputStream, matches, firstNewPeriodIndex, concat,
-      unusedStreamsPerPeriod) {
+      outputStream, firstNewPeriodIndex, concat, unusedStreamsPerPeriod) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const LanguageUtils = shaka.util.LanguageUtils;
+    const matches = outputStream.matchedStreams;
+
+    // Assure the compiler that matches didn't become null during the async
+    // operation before.
+    goog.asserts.assert(outputStream.matchedStreams,
+        'matchedStreams should be non-null');
 
     // Concatenate the new matches onto the stream, starting at the first new
     // period.
@@ -787,7 +808,23 @@ shaka.util.PeriodCombiner = class {
     // streams that match this output.
     clone.originalId = null;
     clone.createSegmentIndex = () => Promise.resolve();
-    clone.segmentIndex = new shaka.media.MetaSegmentIndex();
+    clone.closeSegmentIndex = () => {
+      if (clone.segmentIndex) {
+        clone.segmentIndex.release();
+        clone.segmentIndex = null;
+      }
+      // Close the segment index of the matched streams.
+      if (clone.matchedStreams) {
+        for (const match of clone.matchedStreams) {
+          if (match.segmentIndex) {
+            match.segmentIndex.release();
+            match.segmentIndex = null;
+          }
+        }
+      }
+    };
+
+    clone.segmentIndex = null;
     clone.emsgSchemeIdUris = [];
     clone.keyIds = new Set();
     clone.closedCaptions = null;
@@ -873,26 +910,24 @@ shaka.util.PeriodCombiner = class {
       }
     }
 
-    // Satisfy the compiler about the type.
-    goog.asserts.assert(
-        output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
-        'Output streams should have a MetaSegmentIndex!');
-    // Satisfy the compiler that the input index has been created.
-    goog.asserts.assert(
-        input.segmentIndex,
-        'Input segment index should have been created by now!');
-
-    output.segmentIndex.appendSegmentIndex(input.segmentIndex);
-
     // Combine trick-play video streams, if present.
     if (input.trickModeVideo) {
       if (!output.trickModeVideo) {
         // Create a fresh output stream for trick-mode playback.
         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
             input.trickModeVideo);
-        // Start it with whatever non-trick-mode Streams are in the output so
-        // far.
-        output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+        // TODO: fix the createSegmentIndex function for trickModeVideo.
+        // The trick-mode tracks in multi-period content should have trick-mode
+        // segment indexes whenever available, rather than only regular-mode
+        // segment indexes.
+        output.trickModeVideo.createSegmentIndex = () => {
+          // Satisfy the compiler about the type.
+          goog.asserts.assert(
+              output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
+              'The stream should have a MetaSegmentIndex.');
+          output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+          return Promise.resolve();
+        };
       }
 
       // Concatenate the trick mode input onto the trick mode output.
@@ -943,7 +978,6 @@ shaka.util.PeriodCombiner = class {
    *
    * @param {!Array.<!Array.<T>>} streamsPerPeriod
    * @param {T} outputStream
-   * @return {Array.<T>}
    *
    * @template T
    * Accepts either a StreamDB or Stream type.
@@ -956,11 +990,11 @@ shaka.util.PeriodCombiner = class {
       const match = shaka.util.PeriodCombiner.findBestMatchInPeriod_(
           streams, outputStream);
       if (!match) {
-        return null;
+        return;
       }
       matches.push(match);
     }
-    return matches;
+    outputStream.matchedStreams = matches;
   }
 
   /**

package/lib/util/player_configuration.js

@@ -120,6 +120,8 @@ shaka.util.PlayerConfiguration = class {
         ignoreTextStreamFailures: false,
         ignoreImageStreamFailures: false,
         useFullSegmentsForStartTime: false,
+        defaultAudioCodec: 'mp4a.40.2',
+        defaultVideoCodec: 'avc1.42E01E',
       },
     };
 
@@ -163,6 +165,8 @@ shaka.util.PlayerConfiguration = class {
       forceHTTPS: false,
       preferNativeHls: false,
       updateIntervalSeconds: 1,
+      dispatchAllEmsgBoxes: false,
+      observeQualityChanges: false,
     };
 
     // Some browsers will stop earlier than others before a gap (e.g., Edge
@@ -235,6 +239,19 @@ shaka.util.PlayerConfiguration = class {
         minBandwidth: 0,
         maxBandwidth: Infinity,
       },
+      advanced: {
+        minTotalBytes: 128e3,
+        minBytes: 16e3,
+        fastHalfLife: 2,
+        slowHalfLife: 5,
+      },
+    };
+
+    const cmcd = {
+      enabled: false,
+      sessionId: '',
+      contentId: '',
+      useHeaders: false,
     };
 
     /** @type {shaka.extern.PlayerConfiguration} */
@@ -269,6 +286,7 @@ shaka.util.PlayerConfiguration = class {
       playRangeStart: 0,
       playRangeEnd: Infinity,
       textDisplayFactory: () => null,
+      cmcd: cmcd,
     };
 
     // Add this callback so that we can reference the preferred audio language

package/lib/util/stream_utils.js

@@ -419,13 +419,48 @@ shaka.util.StreamUtils = class {
    */
   static async filterManifestByMediaCapabilities(
       manifest, usePersistentLicenses) {
-    goog.asserts.assert(window.shakaMediaCapabilities,
+    goog.asserts.assert(navigator.mediaCapabilities,
         'MediaCapabilities should be valid.');
 
     await shaka.util.StreamUtils.getDecodingInfosForVariants(
         manifest.variants, usePersistentLicenses, /* srcEquals= */ false);
     manifest.variants = manifest.variants.filter((variant) => {
+      // See: https://github.com/google/shaka-player/issues/3860
       const video = variant.video;
+      const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      if (video) {
+        let videoCodecs = shaka.util.StreamUtils.patchVp9(video.codecs);
+        // For multiplexed streams. Here we must check the audio of the
+        // stream to see if it is compatible.
+        if (video.codecs.includes(',')) {
+          const allCodecs = video.codecs.split(',');
+          videoCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+              ContentType.VIDEO, allCodecs);
+          const audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+              ContentType.AUDIO, allCodecs);
+          const audioFullType = shaka.util.MimeUtils.getFullOrConvertedType(
+              video.mimeType, audioCodecs, ContentType.AUDIO);
+          if (!MediaSource.isTypeSupported(audioFullType)) {
+            return false;
+          }
+        }
+        const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
+            video.mimeType, videoCodecs, ContentType.VIDEO);
+        if (!MediaSource.isTypeSupported(fullType)) {
+          return false;
+        }
+      }
+      const audio = variant.audio;
+      if (audio) {
+        const codecs =
+            shaka.util.StreamUtils.getCorrectAudioCodecs_(audio.codecs);
+        const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
+            audio.mimeType, codecs, ContentType.AUDIO);
+        if (!MediaSource.isTypeSupported(fullType)) {
+          return false;
+        }
+      }
+
       // See: https://github.com/google/shaka-player/issues/3380
       if (shaka.util.Platform.isXboxOne() && video &&
           ((video.width && video.width > 1920) ||
@@ -468,7 +503,7 @@ shaka.util.StreamUtils = class {
       return;
     }
 
-    const mediaCapabilities = window.shakaMediaCapabilities;
+    const mediaCapabilities = navigator.mediaCapabilities;
 
     const operations = [];
     const getVariantDecodingInfos = (async (variant, decodingConfig) => {
@@ -562,12 +597,8 @@ shaka.util.StreamUtils = class {
       }
     }
     if (audio) {
-      // Some Tizen devices seem to misreport AC-3 support, but correctly
-      // report EC-3 support.  So query EC-3 as a fallback for AC-3.
-      // See https://github.com/google/shaka-player/issues/2989 for details.
       const codecs =
-          (audio.codecs.toLowerCase() == 'ac-3' &&
-          shaka.util.Platform.isTizen()) ? 'ec-3' : audio.codecs;
+          shaka.util.StreamUtils.getCorrectAudioCodecs_(audio.codecs);
       const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
           audio.mimeType, codecs, ContentType.AUDIO);
 
@@ -678,6 +709,26 @@ shaka.util.StreamUtils = class {
     return configs;
   }
 
+
+  /**
+   * Generates the correct audio codec for MediaDecodingConfiguration and
+   * for MediaSource.isTypeSupported.
+   * @param {string} codecs
+   * @return {string}
+   * @private
+   */
+  static getCorrectAudioCodecs_(codecs) {
+    // Some Tizen devices seem to misreport AC-3 support, but correctly
+    // report EC-3 support.  So query EC-3 as a fallback for AC-3.
+    // See https://github.com/google/shaka-player/issues/2989 for details.
+    if (shaka.util.Platform.isTizen()) {
+      return codecs.toLowerCase() == 'ac-3' ? 'ec-3' : codecs;
+    } else {
+      return codecs;
+    }
+  }
+
+
   /**
    * MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate vp9
    * codec strings into 'vp09...', to allow such content to play with
@@ -989,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,
@@ -998,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,
@@ -1016,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,