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.       videoLayout: undefined,
  162.       kind: old.kind,
  163.       language: old.language,
  164.       originalLanguage: old.language || null,
  165.       label: old.label,
  166.       width: old.width,
  167.       height: old.height,
  168.       initSegmentKey: initSegmentKey,
  169.       encrypted: old.encrypted,
  170.       keyIds: new Set([old.keyId]),
  171.       segments: old.segments.map((segment) => V1StorageCell.convertSegment_(
  172.           segment, initSegmentKey, appendWindowStart, appendWindowEnd,
  173.           timestampOffset)),
  174.       variantIds: old.variantIds,
  175.       roles: [],
  176.       forced: false,
  177.       audioSamplingRate: null,
  178.       channelsCount: null,
  179.       spatialAudio: false,
  180.       closedCaptions: null,
  181.       tilesLayout: undefined,
  182.       external: false,
  183.       fastSwitching: false,
  184.     };
  185.   }
  187.   /**
  188.    * @param {shaka.extern.SegmentDBV1} old
  189.    * @param {?number} initSegmentKey
  190.    * @param {number} appendWindowStart
  191.    * @param {number} appendWindowEnd
  192.    * @param {number} timestampOffset
  193.    * @return {shaka.extern.SegmentDB}
  194.    * @private
  195.    */
  196.   static convertSegment_(
  197.       old, initSegmentKey, appendWindowStart, appendWindowEnd,
  198.       timestampOffset) {
  199.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  201.     // Since we don't want to use the uri anymore, we need to parse the key
  202.     // from it.
  203.     const dataKey = V1StorageCell.getKeyFromSegmentUri_(old.uri);
  205.     return {
  206.       startTime: appendWindowStart + old.startTime,
  207.       endTime: appendWindowStart + old.endTime,
  208.       dataKey,
  209.       initSegmentKey,
  210.       appendWindowStart,
  211.       appendWindowEnd,
  212.       timestampOffset,
  213.       tilesLayout: '',
  214.     };
  215.   }
  217.   /**
  218.    * @override
  219.    * @param {shaka.extern.SegmentDataDBV1} old
  220.    * @return {shaka.extern.SegmentDataDB}
  221.    */
  222.   convertSegmentData(old) {
  223.     return {data: old.data};
  224.   }
  226.   /**
  227.    * @param {string} uri
  228.    * @return {number}
  229.    * @private
  230.    */
  231.   static getKeyFromSegmentUri_(uri) {
  232.     let parts = null;
  234.     // Try parsing the uri as the original Shaka Player 2.0 uri.
  235.     parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(uri);
  236.     if (parts) {
  237.       return Number(parts[1]);
  238.     }
  240.     // Just before Shaka Player 2.3 the uri format was changed to remove some
  241.     // of the un-used information from the uri and make the segment uri and
  242.     // manifest uri follow a similar format. However the old storage system
  243.     // was still in place, so it is possible for Storage V1 Cells to have
  244.     // Storage V2 uris.
  245.     parts = /^offline:segment\/([0-9]+)$/.exec(uri);
  246.     if (parts) {
  247.       return Number(parts[1]);
  248.     }
  250.     throw new shaka.util.Error(
  251.         shaka.util.Error.Severity.CRITICAL,
  252.         shaka.util.Error.Category.STORAGE,
  253.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  254.         'Could not parse uri ' + uri);
  255.   }
  257.   /**
  258.    * Take a period and check if the streams need to have variants generated.
  259.    * Before Shaka Player moved to its variants model, there were no variants.
  260.    * This will fill missing variants into the given object.
  261.    *
  262.    * @param {shaka.extern.PeriodDBV1} period
  263.    * @private
  264.    */
  265.   static fillMissingVariants_(period) {
  266.     const AUDIO = shaka.util.ManifestParserUtils.ContentType.AUDIO;
  267.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  269.     // There are three cases:
  270.     //  1. All streams' variant ids are null
  271.     //  2. All streams' variant ids are non-null
  272.     //  3. Some streams' variant ids are null and other are non-null
  273.     // Case 3 is invalid and should never happen in production.
  275.     const audio = period.streams.filter((s) => s.contentType == AUDIO);
  276.     const video = period.streams.filter((s) => s.contentType == VIDEO);
  278.     // Case 2 - There is nothing we need to do, so let's just get out of here.
  279.     if (audio.every((s) => s.variantIds) && video.every((s) => s.variantIds)) {
  280.       return;
  281.     }
  283.     // Case 3... We don't want to be in case three.
  284.     goog.asserts.assert(
  285.         audio.every((s) => !s.variantIds),
  286.         'Some audio streams have variant ids and some do not.');
  287.     goog.asserts.assert(
  288.         video.every((s) => !s.variantIds),
  289.         'Some video streams have variant ids and some do not.');
  291.     // Case 1 - Populate all the variant ids (putting us back to case 2).
  292.     // Since all the variant ids are null, we need to first make them into
  293.     // valid arrays.
  294.     for (const s of audio) {
  295.       s.variantIds = [];
  296.     }
  297.     for (const s of video) {
  298.       s.variantIds = [];
  299.     }
  301.     let nextId = 0;
  303.     // It is not possible in Shaka Player's pre-variant world to have audio-only
  304.     // and video-only content mixed in with audio-video content. So we can
  305.     // assume that there is only audio-only or video-only if one group is empty.
  307.     // Everything is video-only content - so each video stream gets to be its
  308.     // own variant.
  309.     if (video.length && !audio.length) {
  310.       shaka.log.debug('Found video-only content. Creating variants for video.');
  311.       const variantId = nextId++;
  312.       for (const s of video) {
  313.         s.variantIds.push(variantId);
  314.       }
  315.     }
  317.     // Everything is audio-only content - so each audio stream gets to be its
  318.     // own variant.
  319.     if (!video.length && audio.length) {
  320.       shaka.log.debug('Found audio-only content. Creating variants for audio.');
  321.       const variantId = nextId++;
  322.       for (const s of audio) {
  323.         s.variantIds.push(variantId);
  324.       }
  325.     }
  327.     // Everything is audio-video content.
  328.     if (video.length && audio.length) {
  329.       shaka.log.debug('Found audio-video content. Creating variants.');
  330.       for (const a of audio) {
  331.         for (const v of video) {
  332.           const variantId = nextId++;
  333.           a.variantIds.push(variantId);
  334.           v.variantIds.push(variantId);
  335.         }
  336.       }
  337.     }
  338.   }
  339. };