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.       sequenceMode: false,
  103.     };
  104.   }
  106.   /**
  107.    * @param {shaka.extern.PeriodDBV1} old
  108.    * @param {number} periodDuration
  109.    * @return {!Array.<shaka.extern.StreamDB>}
  110.    * @private
  111.    */
  112.   static convertPeriod_(old, periodDuration) {
  113.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  115.     // In the case that this is really old (like really old, like dinosaurs
  116.     // roaming the Earth old) there may be no variants, so we need to add those.
  117.     V1StorageCell.fillMissingVariants_(old);
  119.     for (const stream of old.streams) {
  120.       const message = 'After filling in missing variants, ' +
  121.                       'each stream should have variant ids';
  122.       goog.asserts.assert(stream.variantIds, message);
  123.     }
  125.     return old.streams.map((stream) => V1StorageCell.convertStream_(
  126.         stream, old.startTime, periodDuration));
  127.   }
  129.   /**
  130.    * @param {shaka.extern.StreamDBV1} old
  131.    * @param {number} periodStart
  132.    * @param {number} periodDuration
  133.    * @return {shaka.extern.StreamDB}
  134.    * @private
  135.    */
  136.   static convertStream_(old, periodStart, periodDuration) {
  137.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  139.     const initSegmentKey = old.initSegmentUri ?
  140.         V1StorageCell.getKeyFromSegmentUri_(old.initSegmentUri) : null;
  142.     // timestampOffset in the new format is the inverse of
  143.     // presentationTimeOffset in the old format.  Also, PTO did not include the
  144.     // period start, while TO does.
  145.     const timestampOffset = periodStart + old.presentationTimeOffset;
  147.     const appendWindowStart = periodStart;
  148.     const appendWindowEnd = periodStart + periodDuration;
  150.     return {
  151.       id: old.id,
  152.       originalId: null,
  153.       groupId: null,
  154.       primary: old.primary,
  155.       type: old.contentType,
  156.       mimeType: old.mimeType,
  157.       codecs: old.codecs,
  158.       frameRate: old.frameRate,
  159.       pixelAspectRatio: undefined,
  160.       hdr: undefined,
  161.       colorGamut: undefined,
  162.       videoLayout: undefined,
  163.       kind: old.kind,
  164.       language: old.language,
  165.       originalLanguage: old.language || null,
  166.       label: old.label,
  167.       width: old.width,
  168.       height: old.height,
  169.       initSegmentKey: initSegmentKey,
  170.       encrypted: old.encrypted,
  171.       keyIds: new Set([old.keyId]),
  172.       segments: old.segments.map((segment) => V1StorageCell.convertSegment_(
  173.           segment, initSegmentKey, appendWindowStart, appendWindowEnd,
  174.           timestampOffset)),
  175.       variantIds: old.variantIds,
  176.       roles: [],
  177.       forced: false,
  178.       audioSamplingRate: null,
  179.       channelsCount: null,
  180.       spatialAudio: false,
  181.       closedCaptions: null,
  182.       tilesLayout: undefined,
  183.       external: false,
  184.       fastSwitching: false,
  185.     };
  186.   }
  188.   /**
  189.    * @param {shaka.extern.SegmentDBV1} old
  190.    * @param {?number} initSegmentKey
  191.    * @param {number} appendWindowStart
  192.    * @param {number} appendWindowEnd
  193.    * @param {number} timestampOffset
  194.    * @return {shaka.extern.SegmentDB}
  195.    * @private
  196.    */
  197.   static convertSegment_(
  198.       old, initSegmentKey, appendWindowStart, appendWindowEnd,
  199.       timestampOffset) {
  200.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  202.     // Since we don't want to use the uri anymore, we need to parse the key
  203.     // from it.
  204.     const dataKey = V1StorageCell.getKeyFromSegmentUri_(old.uri);
  206.     return {
  207.       startTime: appendWindowStart + old.startTime,
  208.       endTime: appendWindowStart + old.endTime,
  209.       dataKey,
  210.       initSegmentKey,
  211.       appendWindowStart,
  212.       appendWindowEnd,
  213.       timestampOffset,
  214.       tilesLayout: '',
  215.       mimeType: null,
  216.       codecs: null,
  217.     };
  218.   }
  220.   /**
  221.    * @override
  222.    * @param {shaka.extern.SegmentDataDBV1} old
  223.    * @return {shaka.extern.SegmentDataDB}
  224.    */
  225.   convertSegmentData(old) {
  226.     return {data: old.data};
  227.   }
  229.   /**
  230.    * @param {string} uri
  231.    * @return {number}
  232.    * @private
  233.    */
  234.   static getKeyFromSegmentUri_(uri) {
  235.     let parts = null;
  237.     // Try parsing the uri as the original Shaka Player 2.0 uri.
  238.     parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(uri);
  239.     if (parts) {
  240.       return Number(parts[1]);
  241.     }
  243.     // Just before Shaka Player 2.3 the uri format was changed to remove some
  244.     // of the un-used information from the uri and make the segment uri and
  245.     // manifest uri follow a similar format. However the old storage system
  246.     // was still in place, so it is possible for Storage V1 Cells to have
  247.     // Storage V2 uris.
  248.     parts = /^offline:segment\/([0-9]+)$/.exec(uri);
  249.     if (parts) {
  250.       return Number(parts[1]);
  251.     }
  253.     throw new shaka.util.Error(
  254.         shaka.util.Error.Severity.CRITICAL,
  255.         shaka.util.Error.Category.STORAGE,
  256.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  257.         'Could not parse uri ' + uri);
  258.   }
  260.   /**
  261.    * Take a period and check if the streams need to have variants generated.
  262.    * Before Shaka Player moved to its variants model, there were no variants.
  263.    * This will fill missing variants into the given object.
  264.    *
  265.    * @param {shaka.extern.PeriodDBV1} period
  266.    * @private
  267.    */
  268.   static fillMissingVariants_(period) {
  269.     const AUDIO = shaka.util.ManifestParserUtils.ContentType.AUDIO;
  270.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  272.     // There are three cases:
  273.     //  1. All streams' variant ids are null
  274.     //  2. All streams' variant ids are non-null
  275.     //  3. Some streams' variant ids are null and other are non-null
  276.     // Case 3 is invalid and should never happen in production.
  278.     const audio = period.streams.filter((s) => s.contentType == AUDIO);
  279.     const video = period.streams.filter((s) => s.contentType == VIDEO);
  281.     // Case 2 - There is nothing we need to do, so let's just get out of here.
  282.     if (audio.every((s) => s.variantIds) && video.every((s) => s.variantIds)) {
  283.       return;
  284.     }
  286.     // Case 3... We don't want to be in case three.
  287.     goog.asserts.assert(
  288.         audio.every((s) => !s.variantIds),
  289.         'Some audio streams have variant ids and some do not.');
  290.     goog.asserts.assert(
  291.         video.every((s) => !s.variantIds),
  292.         'Some video streams have variant ids and some do not.');
  294.     // Case 1 - Populate all the variant ids (putting us back to case 2).
  295.     // Since all the variant ids are null, we need to first make them into
  296.     // valid arrays.
  297.     for (const s of audio) {
  298.       s.variantIds = [];
  299.     }
  300.     for (const s of video) {
  301.       s.variantIds = [];
  302.     }
  304.     let nextId = 0;
  306.     // It is not possible in Shaka Player's pre-variant world to have audio-only
  307.     // and video-only content mixed in with audio-video content. So we can
  308.     // assume that there is only audio-only or video-only if one group is empty.
  310.     // Everything is video-only content - so each video stream gets to be its
  311.     // own variant.
  312.     if (video.length && !audio.length) {
  313.       shaka.log.debug('Found video-only content. Creating variants for video.');
  314.       const variantId = nextId++;
  315.       for (const s of video) {
  316.         s.variantIds.push(variantId);
  317.       }
  318.     }
  320.     // Everything is audio-only content - so each audio stream gets to be its
  321.     // own variant.
  322.     if (!video.length && audio.length) {
  323.       shaka.log.debug('Found audio-only content. Creating variants for audio.');
  324.       const variantId = nextId++;
  325.       for (const s of audio) {
  326.         s.variantIds.push(variantId);
  327.       }
  328.     }
  330.     // Everything is audio-video content.
  331.     if (video.length && audio.length) {
  332.       shaka.log.debug('Found audio-video content. Creating variants.');
  333.       for (const a of audio) {
  334.         for (const v of video) {
  335.           const variantId = nextId++;
  336.           a.variantIds.push(variantId);
  337.           v.variantIds.push(variantId);
  338.         }
  339.       }
  340.     }
  341.   }
  342. };