shaka-player 4.2.5 → 4.3.1

package/lib/lcevc/lcevc_dil.js

@@ -0,0 +1,152 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.lcevc.Dil');
+goog.require('shaka.log');
+goog.require('shaka.util.IReleasable');
+
+/**
+ * @summary
+ *  lcevcDil - (MPEG-5 Part 2 LCEVC - Decoder Integration Layer) provides
+ *  all the operations related to the enhancement and rendering
+ *  of LCEVC enabled streams and on to a canvas.
+ * @implements {shaka.util.IReleasable}
+ * @export
+ */
+shaka.lcevc.Dil = class {
+  /**
+   * @param {HTMLVideoElement} media The video element that will be attached to
+   * LCEVC Dil for input.
+   * @param {HTMLCanvasElement} canvas The canvas element that will be attached
+   * to LCEVC Dil to render the enhanced frames.
+   * @param {shaka.extern.LcevcConfiguration} dilConfig The LCEVC DIL
+   * config object to initialize the LCEVC DIL.
+   */
+  constructor(media, canvas, dilConfig) {
+    /** @private {?LcevcDil.LcevcDIL} */
+    this.dil_ = null;
+
+    /** @private {number} */
+    this.variantId_ = -1;
+
+    /** @private {HTMLVideoElement} */
+    this.media_ = media;
+
+    /** @private {HTMLCanvasElement} */
+    this.canvas_ = canvas;
+
+    /** @private {shaka.extern.LcevcConfiguration} */
+    this.dilConfig_ = dilConfig;
+
+    this.create_();
+  }
+
+  /**
+   * Append data to the LCEVC Dil.
+   * @param {BufferSource} data
+   */
+  appendBuffer(data) {
+    if (this.dil_) {
+      this.dil_.appendBuffer(data, 'video', this.variantId_);
+    }
+  }
+
+  /**
+   * Hide the canvas specifically in the case of a DRM Content
+   */
+  hideCanvas() {
+    if (this.dil_) {
+      this.canvas_.classList.add('shaka-hidden');
+    }
+  }
+
+  /**
+   * Create LCEVC Dil.
+   * @private
+   */
+  create_() {
+    if (this.isSupported_() && !this.dil_) {
+      if (LcevcDil.SupportObject.webGLSupport(this.canvas_)) {
+        // Make sure the canvas is not hidden from a previous playback session.
+        this.canvas_.classList.remove('shaka-hidden');
+        this.dil_ = new LcevcDil.LcevcDil(
+            this.media_,
+            this.canvas_,
+            this.dilConfig_);
+      }
+    }
+  }
+
+  /**
+   * Close LCEVC Dil.
+   * @override
+   * @export
+   */
+  release() {
+    if (this.dil_) {
+      this.dil_.close();
+      this.dil_ = null;
+    }
+  }
+
+  /**
+   * Check if the LCEVC Dil lib is present and is supported by the browser.
+   * @return {boolean}
+   * @private
+   */
+  isSupported_() {
+    if (typeof libDPIModule === 'undefined') {
+      shaka.log.alwaysWarn(
+          'Could not Find LCEVC Library dependencies on this page');
+    }
+
+    if (typeof LcevcDil === 'undefined') {
+      shaka.log.alwaysWarn('Could not Find LCEVC Library on this page');
+    } else {
+      if (!LcevcDil.SupportObject.SupportStatus) {
+        shaka.log.alwaysWarn(LcevcDil.SupportObject.SupportError);
+      }
+    }
+
+    return typeof LcevcDil !== 'undefined' &&
+      typeof libDPIModule !== 'undefined' &&
+      this.canvas_ instanceof HTMLCanvasElement &&
+      LcevcDil.SupportObject.SupportStatus;
+  }
+
+  /**
+   * Update current active variant
+   * @param {shaka.extern.Track} track
+   */
+  updateVariant(track) {
+    let containerFormat = shaka.lcevc.Dil.ContainerFormat.MPEG2_TS;
+    switch (track.mimeType) {
+      case 'video/webm': {
+        containerFormat = shaka.lcevc.Dil.ContainerFormat.WEBM;
+        break;
+      }
+      case 'video/mp4': {
+        containerFormat = shaka.lcevc.Dil.ContainerFormat.MP4;
+        break;
+      }
+    }
+    if (this.dil_) {
+      this.variantId_ = track.id;
+      this.dil_.setLevelSwitching(track.id, true);
+      this.dil_.setContainerFormat(containerFormat);
+    }
+  }
+};
+
+/**
+ * Container Formats.
+ * @const @enum {number}
+ */
+shaka.lcevc.Dil.ContainerFormat = {
+  MPEG2_TS: 0,
+  WEBM: 1,
+  MP4: 2,
+};

package/lib/media/closed_caption_parser.js

@@ -8,6 +8,7 @@ goog.provide('shaka.media.ClosedCaptionParser');
 goog.provide('shaka.media.IClosedCaptionParser');
 
 goog.require('shaka.cea.CeaDecoder');
+goog.require('shaka.cea.DummyCeaParser');
 goog.require('shaka.cea.Mp4CeaParser');
 goog.require('shaka.util.BufferUtils');
 goog.requireType('shaka.cea.ICaptionDecoder');
@@ -54,12 +55,14 @@ shaka.media.IClosedCaptionParser = class {
  */
 shaka.media.ClosedCaptionParser = class {
   /** */
-  constructor() {
-    /**
-     * MP4 Parser to extract closed caption packets from H.264 video.
-     * @private {!shaka.cea.ICeaParser}
-     */
-    this.ceaParser_ = new shaka.cea.Mp4CeaParser();
+  constructor(mimeType) {
+    /** @private {!shaka.cea.ICeaParser} */
+    this.ceaParser_ = new shaka.cea.DummyCeaParser();
+
+    if (mimeType.includes('video/mp4')) {
+      // MP4 Parser to extract closed caption packets from H.264 video.
+      this.ceaParser_ = new shaka.cea.Mp4CeaParser();
+    }
 
     /**
      * Decoder for decoding CEA-X08 data from closed caption packets.

package/lib/media/drm_engine.js

@@ -845,7 +845,7 @@ shaka.media.DrmEngine = class {
     if (shaka.media.Transmuxer.isSupported(realMimeType)) {
       // This will be handled by the Transmuxer, so use the MIME type that the
       // Transmuxer will produce.
-      return shaka.media.Transmuxer.convertTsCodecs(stream.type, realMimeType);
+      return shaka.media.Transmuxer.convertCodecs(stream.type, realMimeType);
     }
     return realMimeType;
   }
@@ -1113,13 +1113,21 @@ shaka.media.DrmEngine = class {
     const keys = [];
     const keyIds = [];
 
-    clearKeys.forEach((keyHex, keyIdHex) => {
-      const keyId = Uint8ArrayUtils.fromHex(keyIdHex);
-      const key = Uint8ArrayUtils.fromHex(keyHex);
+    clearKeys.forEach((key, keyId) => {
+      let kid = keyId;
+      if (kid.length != 22) {
+        kid = Uint8ArrayUtils.toBase64(
+            Uint8ArrayUtils.fromHex(keyId), false);
+      }
+      let k = key;
+      if (k.length != 22) {
+        k = Uint8ArrayUtils.toBase64(
+            Uint8ArrayUtils.fromHex(key), false);
+      }
       const keyObj = {
         kty: 'oct',
-        kid: Uint8ArrayUtils.toBase64(keyId, false),
-        k: Uint8ArrayUtils.toBase64(key, false),
+        kid: kid,
+        k: k,
       };
 
       keys.push(keyObj);

package/lib/media/media_source_capabilities.js

@@ -0,0 +1,36 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.media.Capabilities');
+
+/**
+ * @summary
+ * This is for capturing all media source capabilities on current platform.
+ * And this is for static check and can not be constructed.
+ */
+shaka.media.Capabilities = class {
+  /**
+   * Cache browser engine call to improve performance on some poor platforms
+   *
+   * @param {string} type
+   * @return {boolean}
+   */
+  static isTypeSupported(type) {
+    const supportMap = shaka.media.Capabilities.MediaSourceTypeSupportMap;
+    if (supportMap.has(type)) {
+      return supportMap.get(type);
+    }
+    const currentSupport = MediaSource.isTypeSupported(type);
+    supportMap.set(type, currentSupport);
+    return currentSupport;
+  }
+};
+
+/**
+ * Public it for unit test, and developer could also check the support map.
+ * @type {!Map.<string, boolean>}
+ */
+shaka.media.Capabilities.MediaSourceTypeSupportMap = new Map();

package/lib/media/media_source_engine.js

@@ -8,21 +8,27 @@ goog.provide('shaka.media.MediaSourceEngine');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.media.ContentWorkarounds');
+goog.require('shaka.media.ClosedCaptionParser');
 goog.require('shaka.media.IClosedCaptionParser');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.media.Transmuxer');
 goog.require('shaka.text.TextEngine');
+goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
+goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PublicPromise');
+goog.require('shaka.util.TsParser');
+goog.require('shaka.lcevc.Dil');
 
 
 /**
@@ -38,21 +44,22 @@ shaka.media.MediaSourceEngine = class {
   /**
    * @param {HTMLMediaElement} video The video element, whose source is tied to
    *   MediaSource during the lifetime of the MediaSourceEngine.
-   * @param {!shaka.media.IClosedCaptionParser} closedCaptionParser
-   *    The closed caption parser that should be used to parser closed captions
-   *    from the video stream. MediaSourceEngine takes ownership of the parser.
-   *    When MediaSourceEngine is destroyed, it will destroy the parser.
    * @param {!shaka.extern.TextDisplayer} textDisplayer
    *    The text displayer that will be used with the text engine.
    *    MediaSourceEngine takes ownership of the displayer. When
    *    MediaSourceEngine is destroyed, it will destroy the displayer.
    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
    *    onMetadata
+   * @param {?shaka.lcevc.Dil} [lcevcDil] Optional -  LCEVC Dil Object
+   *
    */
-  constructor(video, closedCaptionParser, textDisplayer, onMetadata) {
+  constructor(video, textDisplayer, onMetadata, lcevcDil) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
+    /** @private {?shaka.extern.MediaSourceConfiguration} */
+    this.config_ = null;
+
     /** @private {shaka.extern.TextDisplayer} */
     this.textDisplayer_ = textDisplayer;
 
@@ -81,6 +88,9 @@ shaka.media.MediaSourceEngine = class {
                     number, ?number)} */
     this.onMetadata_ = onMetadata || onMetadataNoOp;
 
+    /** @private {?shaka.lcevc.Dil} */
+    this.lcevcDil_ = lcevcDil || null;
+
     /**
      * @private {!Object.<string,
      *                    !Array.<shaka.media.MediaSourceEngine.Operation>>}
@@ -93,8 +103,8 @@ shaka.media.MediaSourceEngine = class {
     /** @private {!Object.<string, !shaka.media.Transmuxer>} */
     this.transmuxers_ = {};
 
-    /** @private {shaka.media.IClosedCaptionParser} */
-    this.captionParser_ = closedCaptionParser;
+    /** @private {?shaka.media.IClosedCaptionParser} */
+    this.captionParser_ = null;
 
     /** @private {!shaka.util.PublicPromise} */
     this.mediaSourceOpen_ = new shaka.util.PublicPromise();
@@ -166,7 +176,7 @@ shaka.media.MediaSourceEngine = class {
         stream.mimeType, stream.codecs);
     const extendedMimeType = shaka.util.MimeUtils.getExtendedType(stream);
     return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
-        MediaSource.isTypeSupported(extendedMimeType) ||
+        shaka.media.Capabilities.isTypeSupported(extendedMimeType) ||
         shaka.media.Transmuxer.isSupported(fullMimeType, stream.type);
   }
 
@@ -222,7 +232,7 @@ shaka.media.MediaSourceEngine = class {
         if (shaka.text.TextEngine.isTypeSupported(type)) {
           support[type] = true;
         } else {
-          support[type] = MediaSource.isTypeSupported(type) ||
+          support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
                           shaka.media.Transmuxer.isSupported(type);
         }
       } else {
@@ -291,6 +301,7 @@ shaka.media.MediaSourceEngine = class {
       this.video_ = null;
     }
 
+    this.config_ = null;
     this.mediaSource_ = null;
     this.textEngine_ = null;
     this.textDisplayer_ = null;
@@ -305,6 +316,9 @@ shaka.media.MediaSourceEngine = class {
       }
     }
     this.queues_ = {};
+
+    // This object is owned by Player
+    this.lcevcDil_ = null;
   }
 
   /**
@@ -325,15 +339,16 @@ shaka.media.MediaSourceEngine = class {
    *               shaka.extern.Stream>} streamsByType
    *   A map of content types to streams.  All streams must be supported
    *   according to MediaSourceEngine.isStreamSupported.
-   * @param {boolean} forceTransmuxTS
-   *   If true, this will transmux TS content even if it is natively supported.
+   * @param {boolean} forceTransmux
+   *   If true, this will transmux AAC and TS content even if it is natively
+   *   supported.
    * @param {boolean=} sequenceMode
    *   If true, the media segments are appended to the SourceBuffer in strict
    *   sequence.
    *
    * @return {!Promise}
    */
-  async init(streamsByType, forceTransmuxTS, sequenceMode=false) {
+  async init(streamsByType, forceTransmux, sequenceMode=false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     await this.mediaSourceOpen_;
@@ -351,14 +366,16 @@ shaka.media.MediaSourceEngine = class {
       if (contentType == ContentType.TEXT) {
         this.reinitText(mimeType, sequenceMode);
       } else {
-        if ((forceTransmuxTS || !MediaSource.isTypeSupported(mimeType)) &&
+        if ((forceTransmux ||
+            !shaka.media.Capabilities.isTypeSupported(mimeType)) &&
             shaka.media.Transmuxer.isSupported(mimeType, contentType)) {
-          this.transmuxers_[contentType] = new shaka.media.Transmuxer();
+          this.transmuxers_[contentType] =
+              new shaka.media.Transmuxer(mimeType);
           mimeType =
-              shaka.media.Transmuxer.convertTsCodecs(contentType, mimeType);
+              shaka.media.Transmuxer.convertCodecs(contentType, mimeType);
         }
-
-        const sourceBuffer = this.mediaSource_.addSourceBuffer(mimeType);
+        const type = mimeType + this.config_.sourceBufferExtraFeatures;
+        const sourceBuffer = this.mediaSource_.addSourceBuffer(type);
 
         this.eventManager_.listen(
             sourceBuffer, 'error',
@@ -374,6 +391,16 @@ shaka.media.MediaSourceEngine = class {
     }
   }
 
+  /**
+   * Called by the Player to provide an updated configuration any time it
+   * changes. Must be called at least once before init().
+   *
+   * @param {shaka.extern.MediaSourceConfiguration} config
+   */
+  configure(config) {
+    this.config_ = config;
+  }
+
   /**
    * Reinitialize the TextEngine for a new text type.
    * @param {string} mimeType
@@ -509,6 +536,17 @@ shaka.media.MediaSourceEngine = class {
     }
   }
 
+  /**
+   * Create a new closed caption parser. This will ONLY be replaced by tests as
+   * a way to inject fake closed caption parser instances.
+   *
+   * @param {string} mimeType
+   * @return {!shaka.media.IClosedCaptionParser}
+   */
+  getCaptionParser(mimeType) {
+    return new shaka.media.ClosedCaptionParser(mimeType);
+  }
+
   /**
    * Enqueue an operation to append data to the SourceBuffer.
    * Start and end times are needed for TextEngine, but not for MediaSource.
@@ -544,6 +582,40 @@ shaka.media.MediaSourceEngine = class {
       return;
     }
 
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+    let mimeType = this.sourceBufferTypes_[contentType];
+    if (this.transmuxers_[contentType]) {
+      mimeType = this.transmuxers_[contentType].getOrginalMimeType();
+    }
+    if (shaka.util.TsParser.probe(uint8ArrayData)) {
+      const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
+      // The SourceBuffer timestampOffset may or may not be set yet, so this is
+      // the timestamp offset that would eventually compute for this segment
+      // either way.
+      const timestampOffset =
+          reference.startTime - (tsParser.getStartTime()[contentType] || 0);
+      const metadata = tsParser.getMetadata();
+      if (metadata.length) {
+        this.onMetadata_(metadata, timestampOffset,
+            reference ? reference.endTime : null);
+      }
+    } else {
+      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(mimeType)) {
+        const frames = shaka.util.Id3Utils.getID3Frames(uint8ArrayData);
+        if (frames.length && reference) {
+          /** @private {shaka.extern.ID3Metadata} */
+          const metadata = {
+            cueTime: reference.startTime,
+            data: uint8ArrayData,
+            frames: frames,
+            dts: reference.startTime,
+            pts: reference.startTime,
+          };
+          this.onMetadata_([metadata], /* offset= */ 0, reference.endTime);
+        }
+      }
+    }
+
     if (this.transmuxers_[contentType]) {
       // When seeked we should reset the transmuxer captionstreams
       // so it does not ignores the captions from previous segments
@@ -558,15 +630,6 @@ shaka.media.MediaSourceEngine = class {
       if (!this.textEngine_) {
         this.reinitText('text/vtt', this.sequenceMode_);
       }
-
-      if (transmuxedData.metadata) {
-        const timestampOffset =
-            this.sourceBuffers_[contentType].timestampOffset;
-        this.onMetadata_(
-            transmuxedData.metadata,
-            timestampOffset,
-            reference ? reference.endTime : null);
-      }
       // This doesn't work for native TS support (ex. Edge/Chromecast),
       // since no transmuxing is needed for native TS.
       if (transmuxedData.captions && transmuxedData.captions.length) {
@@ -582,10 +645,13 @@ shaka.media.MediaSourceEngine = class {
       }
 
       data = transmuxedData.data;
-    } else if (hasClosedCaptions) {
+    } else if (hasClosedCaptions && contentType == ContentType.VIDEO) {
       if (!this.textEngine_) {
         this.reinitText('text/vtt', this.sequenceMode_);
       }
+      if (!this.captionParser_) {
+        this.captionParser_ = this.getCaptionParser(mimeType);
+      }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
       if (!reference) {
@@ -779,7 +845,9 @@ shaka.media.MediaSourceEngine = class {
    * Fully reset the state of the caption parser owned by MediaSourceEngine.
    */
   resetCaptionParser() {
-    this.captionParser_.reset();
+    if (this.captionParser_) {
+      this.captionParser_.reset();
+    }
   }
 
   /**
@@ -918,6 +986,15 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   append_(contentType, data) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
+    // Append only video data to the LCEVC Dil.
+    if (contentType == ContentType.VIDEO && this.lcevcDil_) {
+      // Append video buffers to the LCEVC Dil for parsing and storing
+      // of LCEVC data.
+      this.lcevcDil_.appendBuffer(data);
+    }
+
     // This will trigger an 'updateend' event.
     this.sourceBuffers_[contentType].appendBuffer(data);
   }
@@ -1283,6 +1360,14 @@ shaka.media.MediaSourceEngine = class {
 
     return segment;
   }
+
+  /**
+   * Update LCEVC DIL object when ready for LCEVC Decodes
+   * @param {?shaka.lcevc.Dil} lcevcDil
+   */
+  updateLcevcDil(lcevcDil) {
+    this.lcevcDil_ = lcevcDil;
+  }
 };
 
 

package/lib/media/presentation_timeline.js

@@ -118,6 +118,20 @@ shaka.media.PresentationTimeline = class {
   }
 
 
+  /**
+   * Sets the presentation's start time.
+   *
+   * @param {number} presentationStartTime The wall-clock time, in seconds,
+   *   when the presentation started or will start. Only required for live.
+   * @export
+   */
+  setPresentationStartTime(presentationStartTime) {
+    goog.asserts.assert(presentationStartTime >= 0,
+        'presentationStartTime must be >= 0');
+    this.presentationStartTime_ = presentationStartTime;
+  }
+
+
   /**
    * Sets the presentation's duration.
    *
@@ -207,10 +221,10 @@ shaka.media.PresentationTimeline = class {
 
 
   /**
-   * Gives PresentationTimeline a Stream's segments so it can size and position
+   * Gives PresentationTimeline an array of segments so it can size and position
    * the segment availability window, and account for missing segment
-   * information.  This function should be called once for each Stream (no more,
-   * no less).
+   * information.  These segments do not necessarily need to all be from the
+   * same stream.
    *
    * @param {!Array.<!shaka.media.SegmentReference>} references
    * @export
@@ -220,15 +234,16 @@ shaka.media.PresentationTimeline = class {
       return;
     }
 
-    const firstReferenceStartTime = references[0].startTime;
-    const lastReferenceEndTime = references[references.length - 1].endTime;
-
+    let firstReferenceStartTime = references[0].startTime;
+    let lastReferenceEndTime = references[0].endTime;
+    for (const reference of references) {
+      firstReferenceStartTime = Math.min(
+          firstReferenceStartTime, reference.startTime);
+      lastReferenceEndTime = Math.max(lastReferenceEndTime, reference.endTime);
+      this.maxSegmentDuration_ = Math.max(
+          this.maxSegmentDuration_, reference.endTime - reference.startTime);
+    }
     this.notifyMinSegmentStartTime(firstReferenceStartTime);
-
-    this.maxSegmentDuration_ = references.reduce(
-        (max, r) => { return Math.max(max, r.endTime - r.startTime); },
-        this.maxSegmentDuration_);
-
     this.maxSegmentEndTime_ =
         Math.max(this.maxSegmentEndTime_, lastReferenceEndTime);
 

package/lib/media/segment_reference.js

@@ -28,8 +28,9 @@ shaka.media.InitSegmentReference = class {
    *   segment extends to the end of the resource.
    * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
    *   the quality of the media associated with this init segment.
+   * @param {number=} timescale
    */
-  constructor(uris, startByte, endByte, mediaQuality = null) {
+  constructor(uris, startByte, endByte, mediaQuality = null, timescale) {
     /** @type {function():!Array.<string>} */
     this.getUris = uris;
 
@@ -41,6 +42,9 @@ shaka.media.InitSegmentReference = class {
 
     /** @const {shaka.extern.MediaQualityInfo|null} */
     this.mediaQuality = mediaQuality;
+
+    /** @type {number|undefined} */
+    this.timescale = timescale;
   }
 
   /**
@@ -239,6 +243,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?shaka.extern.HlsAes128Key} */
     this.hlsAes128Key = hlsAes128Key;
+
+    /** @type {?shaka.media.SegmentReference.ThumbnailSprite} */
+    this.thumbnailSprite = null;
   }
 
   /**
@@ -353,6 +360,26 @@ shaka.media.SegmentReference = class {
   markAsUnavailable() {
     this.status = shaka.media.SegmentReference.Status.UNAVAILABLE;
   }
+
+  /**
+   * Set the segment's thumbnail sprite.
+   *
+   * @param {shaka.media.SegmentReference.ThumbnailSprite} thumbnailSprite
+   * @export
+   */
+  setThumbnailSprite(thumbnailSprite) {
+    this.thumbnailSprite = thumbnailSprite;
+  }
+
+  /**
+   * Returns the segment's thumbnail sprite.
+   *
+   * @return {?shaka.media.SegmentReference.ThumbnailSprite}
+   * @export
+   */
+  getThumbnailSprite() {
+    return this.thumbnailSprite;
+  }
 };
 
 
@@ -376,3 +403,24 @@ shaka.media.SegmentReference.Status = {
  * @typedef {shaka.media.InitSegmentReference|shaka.media.SegmentReference}
  */
 shaka.media.AnySegmentReference;
+
+
+/**
+ * @typedef {{
+ *   height: number,
+ *   positionX: number,
+ *   positionY: number,
+ *   width: number
+ * }}
+ *
+ * @property {number} height
+ *    The thumbnail height in px.
+ * @property {number} positionX
+ *    The thumbnail left position in px.
+ * @property {number} positionY
+ *    The thumbnail top position in px.
+ * @property {number} width
+ *    The thumbnail width in px.
+ * @export
+ */
+shaka.media.SegmentReference.ThumbnailSprite;