Source: lib/offline/stored_content_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.StoredContentUtils');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.offline.ManifestConverter');
  11. goog.require('shaka.offline.OfflineUri');
  12. goog.require('shaka.util.StreamUtils');
  15. /**
  16.  * A utility class used to create |shaka.extern.StoredContent| from different
  17.  * types of input.
  18.  */
  19. shaka.offline.StoredContentUtils = class {
  20.   /**
  21.    * @param {string} originalUri
  22.    * @param {shaka.extern.Manifest} manifest
  23.    * @param {number} size
  24.    * @param {!Object} metadata
  25.    * @return {shaka.extern.StoredContent}
  26.    */
  27.   static fromManifest(originalUri, manifest, size, metadata) {
  28.     goog.asserts.assert(
  29.         manifest.variants.length,
  30.         'Cannot create stored content from manifest with no variants.');
  32.     /** @type {number} */
  33.     const duration = manifest.presentationTimeline.getDuration();
  35.     /** @type {!Array.<shaka.extern.Track>} */
  36.     const tracks = shaka.offline.StoredContentUtils.getTracks_(manifest);
  38.     /** @type {shaka.extern.StoredContent} */
  39.     const content = {
  40.       offlineUri: null,
  41.       originalManifestUri: originalUri,
  42.       duration: duration,
  43.       size: size,
  44.       // This expiration value is temporary and will be used in progress reports
  45.       // during the storage process.  The real value would have to come from
  46.       // DrmEngine.
  47.       expiration: Infinity,
  48.       tracks: tracks,
  49.       appMetadata: metadata,
  50.     };
  52.     return content;
  53.   }
  55.   /**
  56.    * @param {!shaka.offline.OfflineUri} offlineUri
  57.    * @param {shaka.extern.ManifestDB} manifestDB
  58.    * @return {shaka.extern.StoredContent}
  59.    */
  60.   static fromManifestDB(offlineUri, manifestDB) {
  61.     goog.asserts.assert(
  62.         manifestDB.streams.length,
  63.         'Cannot create stored content from manifestDB with no streams.');
  65.     const converter = new shaka.offline.ManifestConverter(
  66.         offlineUri.mechanism(), offlineUri.cell());
  68.     /** @type {shaka.extern.Manifest} */
  69.     const manifest = converter.fromManifestDB(manifestDB);
  71.     /** @type {!Object} */
  72.     const metadata = manifestDB.appMetadata || {};
  74.     /** @type {!Array.<shaka.extern.Track>} */
  75.     const tracks = shaka.offline.StoredContentUtils.getTracks_(manifest);
  77.     goog.asserts.assert(
  78.         manifestDB.expiration != null,
  79.         'Manifest expiration must be set by now!');
  81.     /** @type {shaka.extern.StoredContent} */
  82.     const content = {
  83.       offlineUri: offlineUri.toString(),
  84.       originalManifestUri: manifestDB.originalManifestUri,
  85.       duration: manifestDB.duration,
  86.       size: manifestDB.size,
  87.       expiration: manifestDB.expiration,
  88.       tracks: tracks,
  89.       appMetadata: metadata,
  90.     };
  92.     return content;
  93.   }
  95.   /**
  96.    * Gets track representations of all playable variants and all text streams.
  97.    *
  98.    * @param {shaka.extern.Manifest} manifest
  99.    * @return {!Array.<shaka.extern.Track>}
  100.    * @private
  101.    */
  102.   static getTracks_(manifest) {
  103.     const StreamUtils = shaka.util.StreamUtils;
  105.     const tracks = [];
  107.     const variants = StreamUtils.getPlayableVariants(manifest.variants);
  108.     for (const variant of variants) {
  109.       tracks.push(StreamUtils.variantToTrack(variant));
  110.     }
  112.     const textStreams = manifest.textStreams;
  113.     for (const stream of textStreams) {
  114.       tracks.push(StreamUtils.textStreamToTrack(stream));
  115.     }
  117.     return tracks;
  118.   }
  119. };