Source: lib/offline/manifest_converter.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.offline.ManifestConverter');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.media.InitSegmentReference');
  22. goog.require('shaka.media.PresentationTimeline');
  23. goog.require('shaka.media.SegmentIndex');
  24. goog.require('shaka.media.SegmentReference');
  25. goog.require('shaka.offline.OfflineUri');
  26. goog.require('shaka.util.ManifestParserUtils');
  29. /**
  30.  * Utility class for converting database manifest objects back to normal
  31.  * player-ready objects. Used by the offline system to convert on-disk
  32.  * objects back to the in-memory objects.
  33.  */
  34. shaka.offline.ManifestConverter = class {
  35.   /**
  36.    * Create a new manifest converter. Need to know the mechanism and cell that
  37.    * the manifest is from so that all segments paths can be created.
  38.    *
  39.    * @param {string} mechanism
  40.    * @param {string} cell
  41.    */
  42.   constructor(mechanism, cell) {
  43.     /** @private {string} */
  44.     this.mechanism_ = mechanism;
  45.     /** @private {string} */
  46.     this.cell_ = cell;
  47.   }
  49.   /**
  50.    * Convert a |shaka.extern.ManifestDB| object to a |shaka.extern.Manifest|
  51.    * object.
  52.    *
  53.    * @param {shaka.extern.ManifestDB} manifestDB
  54.    * @return {shaka.extern.Manifest}
  55.    */
  56.   fromManifestDB(manifestDB) {
  57.     let timeline = new shaka.media.PresentationTimeline(null, 0);
  58.     timeline.setDuration(manifestDB.duration);
  60.     let periods = manifestDB.periods.map((period) =>
  61.         this.fromPeriodDB(period, timeline));
  63.     let drmInfos = manifestDB.drmInfo ? [manifestDB.drmInfo] : [];
  64.     if (manifestDB.drmInfo) {
  65.       periods.forEach((period) => {
  66.         period.variants.forEach((variant) => { variant.drmInfos = drmInfos; });
  67.       });
  68.     }
  70.     return {
  71.       presentationTimeline: timeline,
  72.       minBufferTime: 2,
  73.       offlineSessionIds: manifestDB.sessionIds,
  74.       periods: periods,
  75.     };
  76.   }
  78.   /**
  79.    * Create a period object from a database period.
  80.    *
  81.    * @param {shaka.extern.PeriodDB} period
  82.    * @param {shaka.media.PresentationTimeline} timeline
  83.    * @return {shaka.extern.Period}
  84.    */
  85.   fromPeriodDB(period, timeline) {
  86.     /** @type {!Array.<shaka.extern.StreamDB>} */
  87.     let audioStreams = period.streams.filter((stream) => this.isAudio_(stream));
  88.     /** @type {!Array.<shaka.extern.StreamDB>} */
  89.     let videoStreams = period.streams.filter((stream) => this.isVideo_(stream));
  91.     /** @type {!Map.<number, shaka.extern.Variant>} */
  92.     const variants = this.createVariants(audioStreams, videoStreams);
  94.     /** @type {!Array.<shaka.extern.Stream>} */
  95.     let textStreams = period.streams
  96.         .filter((stream) => this.isText_(stream))
  97.         .map((stream) => this.fromStreamDB_(stream));
  99.     period.streams.forEach((stream, i) => {
  100.       /** @type {!Array.<!shaka.media.SegmentReference>} */
  101.       let refs = stream.segments.map((segment, index) => {
  102.         return this.fromSegmentDB_(index, segment);
  103.       });
  105.       timeline.notifySegments(refs, period.startTime);
  106.     });
  108.     return {
  109.       startTime: period.startTime,
  110.       variants: Array.from(variants.values()),
  111.       textStreams: textStreams,
  112.     };
  113.   }
  115.   /**
  116.    * Recreates Variants from audio and video StreamDB collections.
  117.    *
  118.    * @param {!Array.<!shaka.extern.StreamDB>} audios
  119.    * @param {!Array.<!shaka.extern.StreamDB>} videos
  120.    * @return {!Map.<number, !shaka.extern.Variant>}
  121.    */
  122.   createVariants(audios, videos) {
  123.     // Get all the variant ids from all audio and video streams.
  124.     /** @type {!Set.<number>} */
  125.     const variantIds = new Set();
  126.     for (const stream of audios) {
  127.       for (const id of stream.variantIds) { variantIds.add(id); }
  128.     }
  129.     for (const stream of videos) {
  130.       for (const id of stream.variantIds) { variantIds.add(id); }
  131.     }
  133.     /** @type {!Map.<number, shaka.extern.Variant>} */
  134.     const variantMap = new Map();
  135.     for (const id of variantIds) {
  136.       variantMap.set(id, this.createEmptyVariant_(id));
  137.     }
  139.     // Assign each audio stream to its variants.
  140.     for (const audio of audios) {
  141.       /** @type {shaka.extern.Stream} */
  142.       const stream = this.fromStreamDB_(audio);
  144.       for (const variantId of audio.variantIds) {
  145.         const variant = variantMap.get(variantId);
  147.         goog.asserts.assert(
  148.             !variant.audio, 'A variant should only have one audio stream');
  150.         variant.language = stream.language;
  151.         variant.primary = variant.primary || stream.primary;
  152.         variant.audio = stream;
  153.       }
  154.     }
  156.     // Assign each video stream to its variants.
  157.     for (const video of videos) {
  158.       /** @type {shaka.extern.Stream} */
  159.       const stream = this.fromStreamDB_(video);
  161.       for (const variantId of video.variantIds) {
  162.         const variant = variantMap.get(variantId);
  164.         goog.asserts.assert(
  165.             !variant.video, 'A variant should only have one video stream');
  167.         variant.primary = variant.primary || stream.primary;
  168.         variant.video = stream;
  169.       }
  170.     }
  172.     return variantMap;
  173.   }
  175.   /**
  176.    * @param {shaka.extern.StreamDB} streamDB
  177.    * @return {shaka.extern.Stream}
  178.    * @private
  179.    */
  180.   fromStreamDB_(streamDB) {
  181.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  182.     let segments = streamDB.segments.map((segment, index) =>
  183.         this.fromSegmentDB_(index, segment));
  185.     /** @type {!shaka.media.SegmentIndex} */
  186.     let segmentIndex = new shaka.media.SegmentIndex(segments);
  188.     /** @type {shaka.extern.Stream} */
  189.     let stream = {
  190.       id: streamDB.id,
  191.       originalId: streamDB.originalId,
  192.       createSegmentIndex: () => Promise.resolve(),
  193.       findSegmentPosition: (index) => segmentIndex.find(index),
  194.       getSegmentReference: (index) => segmentIndex.get(index),
  195.       initSegmentReference: null,
  196.       presentationTimeOffset: streamDB.presentationTimeOffset,
  197.       mimeType: streamDB.mimeType,
  198.       codecs: streamDB.codecs,
  199.       width: streamDB.width || undefined,
  200.       height: streamDB.height || undefined,
  201.       frameRate: streamDB.frameRate || undefined,
  202.       kind: streamDB.kind,
  203.       encrypted: streamDB.encrypted,
  204.       keyId: streamDB.keyId,
  205.       language: streamDB.language,
  206.       label: streamDB.label || null,
  207.       type: streamDB.contentType,
  208.       primary: streamDB.primary,
  209.       trickModeVideo: null,
  210.       // TODO(modmaker): Store offline?
  211.       emsgSchemeIdUris: null,
  212.       roles: [],
  213.       channelsCount: null,
  214.       closedCaptions: null,
  215.     };
  217.     if (streamDB.initSegmentKey != null) {
  218.       stream.initSegmentReference =
  219.           this.fromInitSegmentDB_(streamDB.initSegmentKey);
  220.     }
  222.     return stream;
  223.   }
  225.   /**
  226.    * @param {number} index
  227.    * @param {shaka.extern.SegmentDB} segmentDB
  228.    * @return {!shaka.media.SegmentReference}
  229.    * @private
  230.    */
  231.   fromSegmentDB_(index, segmentDB) {
  232.     /** @type {!shaka.offline.OfflineUri} */
  233.     let uri = shaka.offline.OfflineUri.segment(
  234.         this.mechanism_, this.cell_, segmentDB.dataKey);
  236.     return new shaka.media.SegmentReference(
  237.         index,
  238.         segmentDB.startTime,
  239.         segmentDB.endTime,
  240.         () => [uri.toString()],
  241.         0 /* startByte */,
  242.         null /*  endByte */);
  243.   }
  245.   /**
  246.    * @param {number} key
  247.    * @return {!shaka.media.InitSegmentReference}
  248.    * @private
  249.    */
  250.   fromInitSegmentDB_(key) {
  251.     /** @type {!shaka.offline.OfflineUri} */
  252.     let uri = shaka.offline.OfflineUri.segment(
  253.         this.mechanism_, this.cell_, key);
  255.     return new shaka.media.InitSegmentReference(
  256.         () => [uri.toString()],
  257.         0 /* startBytes*/,
  258.         null /* endBytes */);
  259.   }
  261.   /**
  262.    * @param {shaka.extern.StreamDB} stream
  263.    * @return {boolean}
  264.    * @private
  265.    */
  266.   isAudio_(stream) {
  267.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  268.     return stream.contentType == ContentType.AUDIO;
  269.   }
  271.   /**
  272.    * @param {shaka.extern.StreamDB} stream
  273.    * @return {boolean}
  274.    * @private
  275.    */
  276.   isVideo_(stream) {
  277.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  278.     return stream.contentType == ContentType.VIDEO;
  279.   }
  281.   /**
  282.    * @param {shaka.extern.StreamDB} stream
  283.    * @return {boolean}
  284.    * @private
  285.    */
  286.   isText_(stream) {
  287.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  288.     return stream.contentType == ContentType.TEXT;
  289.   }
  291.   /**
  292.    * Creates an empty Variant.
  293.    *
  294.    * @param {number} id
  295.    * @return {!shaka.extern.Variant}
  296.    * @private
  297.    */
  298.   createEmptyVariant_(id) {
  299.     return {
  300.       id: id,
  301.       language: '',
  302.       primary: false,
  303.       audio: null,
  304.       video: null,
  305.       bandwidth: 0,
  306.       drmInfos: [],
  307.       allowedByApplication: true,
  308.       allowedByKeySystem: true,
  309.     };
  310.   }
  311. };