Source: lib/offline/indexeddb/v1_storage_cell.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.indexeddb.V1StorageCell');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.offline.indexeddb.BaseStorageCell');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.ManifestParserUtils');
  14. goog.require('shaka.util.PeriodCombiner');
  15. goog.require('shaka.util.PublicPromise');
  18. /**
  19.  * The V1StorageCell is for all stores that follow the shaka.externs V1 offline
  20.  * types, introduced in Shaka Player v2.0 and deprecated in v2.3.
  21.  *
  22.  * @implements {shaka.extern.StorageCell}
  23.  */
  24. shaka.offline.indexeddb.V1StorageCell = class
  25.   extends shaka.offline.indexeddb.BaseStorageCell {
  26.   /** @override */
  27.   async updateManifestExpiration(key, newExpiration) {
  28.     const op = this.connection_.startReadWriteOperation(this.manifestStore_);
  30.     /** @type {IDBObjectStore} */
  31.     const store = op.store();
  33.     /** @type {!shaka.util.PublicPromise} */
  34.     const p = new shaka.util.PublicPromise();
  36.     store.get(key).onsuccess = (event) => {
  37.       // Make sure a defined value was found. Indexeddb treats "no value found"
  38.       // as a success with an undefined result.
  39.       const manifest = /** @type {shaka.extern.ManifestDBV1} */(
  40.         event.target.result);
  42.       // Indexeddb does not fail when you get a value that is not in the
  43.       // database. It will return an undefined value. However, we expect
  44.       // the value to never be null, so something is wrong if we get a
  45.       // falsey value.
  46.       if (manifest) {
  47.         // Since this store's scheme uses in-line keys, we don't specify the key
  48.         // with |put|.  This difference is why we must override the base class.
  49.         goog.asserts.assert(
  50.             manifest.key == key,
  51.             'With in-line keys, the keys should match');
  53.         manifest.expiration = newExpiration;
  54.         store.put(manifest);
  56.         p.resolve();
  57.       } else {
  58.         p.reject(new shaka.util.Error(
  59.             shaka.util.Error.Severity.CRITICAL,
  60.             shaka.util.Error.Category.STORAGE,
  61.             shaka.util.Error.Code.KEY_NOT_FOUND,
  62.             'Could not find values for ' + key));
  63.       }
  64.     };
  66.     await Promise.all([op.promise(), p]);
  67.   }
  69.   /**
  70.    * @override
  71.    * @param {shaka.extern.ManifestDBV1} old
  72.    * @return {!Promise.<shaka.extern.ManifestDB>}
  73.    */
  74.   async convertManifest(old) {
  75.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  77.     const streamsPerPeriod = [];
  79.     for (let i = 0; i < old.periods.length; ++i) {
  80.       // The last period ends at the end of the presentation.
  81.       const periodEnd = i == old.periods.length - 1 ?
  82.           old.duration : old.periods[i + 1].startTime;
  83.       const duration = periodEnd - old.periods[i].startTime;
  84.       const streams = V1StorageCell.convertPeriod_(old.periods[i], duration);
  86.       streamsPerPeriod.push(streams);
  87.     }
  89.     const streams = await shaka.util.PeriodCombiner.combineDbStreams(
  90.         streamsPerPeriod);
  92.     return {
  93.       creationTime: 0,
  94.       originalManifestUri: old.originalManifestUri,
  95.       duration: old.duration,
  96.       size: old.size,
  97.       expiration: old.expiration == null ? Infinity : old.expiration,
  98.       streams,
  99.       sessionIds: old.sessionIds,
  100.       drmInfo: old.drmInfo,
  101.       appMetadata: old.appMetadata,
  102.     };
  103.   }
  105.   /**
  106.    * @param {shaka.extern.PeriodDBV1} old
  107.    * @param {number} periodDuration
  108.    * @return {!Array.<shaka.extern.StreamDB>}
  109.    * @private
  110.    */
  111.   static convertPeriod_(old, periodDuration) {
  112.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  114.     // In the case that this is really old (like really old, like dinosaurs
  115.     // roaming the Earth old) there may be no variants, so we need to add those.
  116.     V1StorageCell.fillMissingVariants_(old);
  118.     for (const stream of old.streams) {
  119.       const message = 'After filling in missing variants, ' +
  120.                       'each stream should have variant ids';
  121.       goog.asserts.assert(stream.variantIds, message);
  122.     }
  124.     return old.streams.map((stream) => V1StorageCell.convertStream_(
  125.         stream, old.startTime, periodDuration));
  126.   }
  128.   /**
  129.    * @param {shaka.extern.StreamDBV1} old
  130.    * @param {number} periodStart
  131.    * @param {number} periodDuration
  132.    * @return {shaka.extern.StreamDB}
  133.    * @private
  134.    */
  135.   static convertStream_(old, periodStart, periodDuration) {
  136.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  138.     const initSegmentKey = old.initSegmentUri ?
  139.         V1StorageCell.getKeyFromSegmentUri_(old.initSegmentUri) : null;
  141.     // timestampOffset in the new format is the inverse of
  142.     // presentationTimeOffset in the old format.  Also, PTO did not include the
  143.     // period start, while TO does.
  144.     const timestampOffset = periodStart + old.presentationTimeOffset;
  146.     const appendWindowStart = periodStart;
  147.     const appendWindowEnd = periodStart + periodDuration;
  149.     return {
  150.       id: old.id,
  151.       originalId: null,
  152.       primary: old.primary,
  153.       type: old.contentType,
  154.       mimeType: old.mimeType,
  155.       codecs: old.codecs,
  156.       frameRate: old.frameRate,
  157.       pixelAspectRatio: undefined,
  158.       hdr: undefined,
  159.       kind: old.kind,
  160.       language: old.language,
  161.       label: old.label,
  162.       width: old.width,
  163.       height: old.height,
  164.       initSegmentKey: initSegmentKey,
  165.       encrypted: old.encrypted,
  166.       keyIds: new Set([old.keyId]),
  167.       segments: old.segments.map((segment) => V1StorageCell.convertSegment_(
  168.           segment, initSegmentKey, appendWindowStart, appendWindowEnd,
  169.           timestampOffset)),
  170.       variantIds: old.variantIds,
  171.       roles: [],
  172.       forced: false,
  173.       audioSamplingRate: null,
  174.       channelsCount: null,
  175.       spatialAudio: false,
  176.       closedCaptions: null,
  177.       tilesLayout: undefined,
  178.     };
  179.   }
  181.   /**
  182.    * @param {shaka.extern.SegmentDBV1} old
  183.    * @param {?number} initSegmentKey
  184.    * @param {number} appendWindowStart
  185.    * @param {number} appendWindowEnd
  186.    * @param {number} timestampOffset
  187.    * @return {shaka.extern.SegmentDB}
  188.    * @private
  189.    */
  190.   static convertSegment_(
  191.       old, initSegmentKey, appendWindowStart, appendWindowEnd,
  192.       timestampOffset) {
  193.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  195.     // Since we don't want to use the uri anymore, we need to parse the key
  196.     // from it.
  197.     const dataKey = V1StorageCell.getKeyFromSegmentUri_(old.uri);
  199.     return {
  200.       startTime: appendWindowStart + old.startTime,
  201.       endTime: appendWindowStart + old.endTime,
  202.       dataKey,
  203.       initSegmentKey,
  204.       appendWindowStart,
  205.       appendWindowEnd,
  206.       timestampOffset,
  207.       tilesLayout: '',
  208.     };
  209.   }
  211.   /**
  212.    * @override
  213.    * @param {shaka.extern.SegmentDataDBV1} old
  214.    * @return {shaka.extern.SegmentDataDB}
  215.    */
  216.   convertSegmentData(old) {
  217.     return {data: old.data};
  218.   }
  220.   /**
  221.    * @param {string} uri
  222.    * @return {number}
  223.    * @private
  224.    */
  225.   static getKeyFromSegmentUri_(uri) {
  226.     let parts = null;
  228.     // Try parsing the uri as the original Shaka Player 2.0 uri.
  229.     parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(uri);
  230.     if (parts) {
  231.       return Number(parts[1]);
  232.     }
  234.     // Just before Shaka Player 2.3 the uri format was changed to remove some
  235.     // of the un-used information from the uri and make the segment uri and
  236.     // manifest uri follow a similar format. However the old storage system
  237.     // was still in place, so it is possible for Storage V1 Cells to have
  238.     // Storage V2 uris.
  239.     parts = /^offline:segment\/([0-9]+)$/.exec(uri);
  240.     if (parts) {
  241.       return Number(parts[1]);
  242.     }
  244.     throw new shaka.util.Error(
  245.         shaka.util.Error.Severity.CRITICAL,
  246.         shaka.util.Error.Category.STORAGE,
  247.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  248.         'Could not parse uri ' + uri);
  249.   }
  251.   /**
  252.    * Take a period and check if the streams need to have variants generated.
  253.    * Before Shaka Player moved to its variants model, there were no variants.
  254.    * This will fill missing variants into the given object.
  255.    *
  256.    * @param {shaka.extern.PeriodDBV1} period
  257.    * @private
  258.    */
  259.   static fillMissingVariants_(period) {
  260.     const AUDIO = shaka.util.ManifestParserUtils.ContentType.AUDIO;
  261.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  263.     // There are three cases:
  264.     //  1. All streams' variant ids are null
  265.     //  2. All streams' variant ids are non-null
  266.     //  3. Some streams' variant ids are null and other are non-null
  267.     // Case 3 is invalid and should never happen in production.
  269.     const audio = period.streams.filter((s) => s.contentType == AUDIO);
  270.     const video = period.streams.filter((s) => s.contentType == VIDEO);
  272.     // Case 2 - There is nothing we need to do, so let's just get out of here.
  273.     if (audio.every((s) => s.variantIds) && video.every((s) => s.variantIds)) {
  274.       return;
  275.     }
  277.     // Case 3... We don't want to be in case three.
  278.     goog.asserts.assert(
  279.         audio.every((s) => !s.variantIds),
  280.         'Some audio streams have variant ids and some do not.');
  281.     goog.asserts.assert(
  282.         video.every((s) => !s.variantIds),
  283.         'Some video streams have variant ids and some do not.');
  285.     // Case 1 - Populate all the variant ids (putting us back to case 2).
  286.     // Since all the variant ids are null, we need to first make them into
  287.     // valid arrays.
  288.     for (const s of audio) {
  289.       s.variantIds = [];
  290.     }
  291.     for (const s of video) {
  292.       s.variantIds = [];
  293.     }
  295.     let nextId = 0;
  297.     // It is not possible in Shaka Player's pre-variant world to have audio-only
  298.     // and video-only content mixed in with audio-video content. So we can
  299.     // assume that there is only audio-only or video-only if one group is empty.
  301.     // Everything is video-only content - so each video stream gets to be its
  302.     // own variant.
  303.     if (video.length && !audio.length) {
  304.       shaka.log.debug('Found video-only content. Creating variants for video.');
  305.       const variantId = nextId++;
  306.       for (const s of video) {
  307.         s.variantIds.push(variantId);
  308.       }
  309.     }
  311.     // Everything is audio-only content - so each audio stream gets to be its
  312.     // own variant.
  313.     if (!video.length && audio.length) {
  314.       shaka.log.debug('Found audio-only content. Creating variants for audio.');
  315.       const variantId = nextId++;
  316.       for (const s of audio) {
  317.         s.variantIds.push(variantId);
  318.       }
  319.     }
  321.     // Everything is audio-video content.
  322.     if (video.length && audio.length) {
  323.       shaka.log.debug('Found audio-video content. Creating variants.');
  324.       for (const a of audio) {
  325.         for (const v of video) {
  326.           const variantId = nextId++;
  327.           a.variantIds.push(variantId);
  328.           v.variantIds.push(variantId);
  329.         }
  330.       }
  331.     }
  332.   }
  333. };