Source: lib/offline/indexeddb/v2_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.V2StorageCell');
  9. goog.require('shaka.offline.indexeddb.BaseStorageCell');
  10. goog.require('shaka.util.PeriodCombiner');
  13. /**
  14.  * The V2StorageCell is for all stores that follow the shaka.externs V2 and V3
  15.  * offline types.  V2 was introduced in Shaka Player v2.3.0 and quickly
  16.  * replaced with V3 in Shaka Player v2.3.2.  V3 was then deprecated in v3.0.
  17.  *
  18.  * Upgrading from V1 to V2 initially broke the database in a way that prevented
  19.  * adding new records.  The problem was with the upgrade process, not with the
  20.  * database format.  Once database upgrades were removed, we increased the
  21.  * database version to V3 and marked V2 as read-only.  Therefore, V2 and V3
  22.  * databases can both be read by this cell.
  23.  *
  24.  * The manifest and segment stores didn't change in database V4, but a separate
  25.  * table for session IDs was added.  So this cell also covers DB V4.
  26.  *
  27.  * @implements {shaka.extern.StorageCell}
  28.  */
  29. shaka.offline.indexeddb.V2StorageCell = class
  30.   extends shaka.offline.indexeddb.BaseStorageCell {
  31.   /**
  32.    * @override
  33.    * @param {shaka.extern.ManifestDBV2} old
  34.    * @return {!Promise.<shaka.extern.ManifestDB>}
  35.    */
  36.   async convertManifest(old) {
  37.     const streamsPerPeriod = [];
  39.     for (let i = 0; i < old.periods.length; ++i) {
  40.       // The last period ends at the end of the presentation.
  41.       const periodEnd = i == old.periods.length - 1 ?
  42.           old.duration : old.periods[i + 1].startTime;
  43.       const duration = periodEnd - old.periods[i].startTime;
  44.       const streams = this.convertPeriod_(old.periods[i], duration);
  46.       streamsPerPeriod.push(streams);
  47.     }
  49.     const streams = await shaka.util.PeriodCombiner.combineDbStreams(
  50.         streamsPerPeriod);
  52.     return {
  53.       appMetadata: old.appMetadata,
  54.       creationTime: 0,
  55.       drmInfo: old.drmInfo,
  56.       duration: old.duration,
  57.       // JSON serialization turns Infinity into null, so turn it back now.
  58.       expiration: old.expiration == null ? Infinity : old.expiration,
  59.       originalManifestUri: old.originalManifestUri,
  60.       sessionIds: old.sessionIds,
  61.       size: old.size,
  62.       streams,
  63.     };
  64.   }
  66.   /**
  67.    * @param {shaka.extern.PeriodDBV2} period
  68.    * @param {number} periodDuration
  69.    * @return {!Array.<shaka.extern.StreamDB>}
  70.    * @private
  71.    */
  72.   convertPeriod_(period, periodDuration) {
  73.     const streams = [];
  74.     for (const stream of period.streams) {
  75.       // The v4 version of the database as written by v2.5.0 - v2.5.9 might have
  76.       // been corrupted slightly.  A bug caused the stream metadata from all
  77.       // periods to be written to each period.  This was corrected in v2.5.10.
  78.       // To fix this, we can identify the extra streams by their lack of
  79.       // variantIds and skip them.
  80.       if (stream.variantIds.length == 0) {
  81.         continue;
  82.       }
  84.       streams.push(this.convertStream_(
  85.           stream, period.startTime, period.startTime + periodDuration));
  86.     }
  87.     return streams;
  88.   }
  90.   /**
  91.    * @param {shaka.extern.StreamDBV2} old
  92.    * @param {number} periodStart
  93.    * @param {number} periodEnd
  94.    * @return {shaka.extern.StreamDB}
  95.    * @private
  96.    */
  97.   convertStream_(old, periodStart, periodEnd) {
  98.     return {
  99.       id: old.id,
  100.       originalId: old.originalId,
  101.       primary: old.primary,
  102.       type: old.contentType,
  103.       mimeType: old.mimeType,
  104.       codecs: old.codecs,
  105.       frameRate: old.frameRate,
  106.       pixelAspectRatio: old.pixelAspectRatio,
  107.       hdr: undefined,
  108.       kind: old.kind,
  109.       language: old.language,
  110.       label: old.label,
  111.       width: old.width,
  112.       height: old.height,
  113.       encrypted: old.encrypted,
  114.       keyIds: new Set([old.keyId]),
  115.       segments: old.segments.map((segment) =>
  116.         this.convertSegment_(
  117.             segment, old.initSegmentKey, periodStart, periodEnd,
  118.             old.presentationTimeOffset)),
  119.       variantIds: old.variantIds,
  120.       roles: [],
  121.       forced: false,
  122.       audioSamplingRate: null,
  123.       channelsCount: null,
  124.       spatialAudio: false,
  125.       closedCaptions: null,
  126.       tilesLayout: undefined,
  127.     };
  128.   }
  130.   /**
  131.    * @param {shaka.extern.SegmentDBV2} old
  132.    * @param {?number} initSegmentKey
  133.    * @param {number} periodStart
  134.    * @param {number} periodEnd
  135.    * @param {number} presentationTimeOffset
  136.    * @return {shaka.extern.SegmentDB}
  137.    * @private
  138.    */
  139.   convertSegment_(
  140.       old, initSegmentKey, periodStart, periodEnd, presentationTimeOffset) {
  141.     const timestampOffset = periodStart - presentationTimeOffset;
  143.     return {
  144.       startTime: periodStart + old.startTime,
  145.       endTime: periodStart + old.endTime,
  146.       initSegmentKey,
  147.       appendWindowStart: periodStart,
  148.       appendWindowEnd: periodEnd,
  149.       timestampOffset,
  150.       dataKey: old.dataKey,
  151.     };
  152.   }
  153. };