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');
  27. goog.require('shaka.util.MapUtils');
  30. /**
  31.  * Utility class for converting database manifest objects back to normal
  32.  * player-ready objects. Used by the offline system to convert on-disk
  33.  * objects back to the in-memory objects.
  34.  */
  35. shaka.offline.ManifestConverter = class {
  37.   /**
  38.    * Create a new manifest converter. Need to know the mechanism and cell that
  39.    * the manifest is from so that all segments paths can be created.
  40.    *
  41.    * @param {string} mechanism
  42.    * @param {string} cell
  43.    */
  44.   constructor(mechanism, cell) {
  45.     /** @private {string} */
  46.     this.mechanism_ = mechanism;
  47.     /** @private {string} */
  48.     this.cell_ = cell;
  49.   }
  51.   /**
  52.    * Convert a |shakaExtern.ManifestDB| object to a |shakaExtern.Manifest|
  53.    * object.
  54.    *
  55.    * @param {shakaExtern.ManifestDB} manifestDB
  56.    * @return {shakaExtern.Manifest}
  57.    */
  58.   fromManifestDB(manifestDB) {
  59.     let timeline = new shaka.media.PresentationTimeline(null, 0);
  60.     timeline.setDuration(manifestDB.duration);
  62.     let periods = manifestDB.periods.map((period) =>
  63.         this.fromPeriodDB(period, timeline));
  65.     let drmInfos = manifestDB.drmInfo ? [manifestDB.drmInfo] : [];
  66.     if (manifestDB.drmInfo) {
  67.       periods.forEach((period) => {
  68.         period.variants.forEach((variant) => { variant.drmInfos = drmInfos; });
  69.       });
  70.     }
  72.     return {
  73.       presentationTimeline: timeline,
  74.       minBufferTime: 2,
  75.       offlineSessionIds: manifestDB.sessionIds,
  76.       periods: periods
  77.     };
  78.   }
  80.   /**
  81.    * Create a period object from a database period.
  82.    *
  83.    * @param {shakaExtern.PeriodDB} period
  84.    * @param {shaka.media.PresentationTimeline} timeline
  85.    * @return {shakaExtern.Period}
  86.    */
  87.   fromPeriodDB(period, timeline) {
  88.     /** @type {!Array.<shakaExtern.StreamDB>} */
  89.     let audioStreams = period.streams.filter((stream) => this.isAudio_(stream));
  90.     /** @type {!Array.<shakaExtern.StreamDB>} */
  91.     let videoStreams = period.streams.filter((stream) => this.isVideo_(stream));
  93.     /** @type {!Array.<shakaExtern.Variant>} */
  94.     let variants = this.createVariants(audioStreams, videoStreams);
  96.     /** @type {!Array.<shakaExtern.Stream>} */
  97.     let textStreams = period.streams
  98.         .filter((stream) => this.isText_(stream))
  99.         .map((stream) => this.fromStreamDB_(stream));
  101.     period.streams.forEach((stream, i) => {
  102.       /** @type {!Array.<!shaka.media.SegmentReference>} */
  103.       let refs = stream.segments.map((segment, index) => {
  104.         return this.fromSegmentDB_(index, segment);
  105.       });
  107.       timeline.notifySegments(refs, i == 0);
  108.     });
  110.     return {
  111.       startTime: period.startTime,
  112.       variants: variants,
  113.       textStreams: textStreams
  114.     };
  115.   }
  117.   /**
  118.    * Recreates Variants from audio and video StreamDB collections.
  119.    *
  120.    * @param {!Array.<!shakaExtern.StreamDB>} audios
  121.    * @param {!Array.<!shakaExtern.StreamDB>} videos
  122.    * @return {!Array.<!shakaExtern.Variant>}
  123.    */
  124.   createVariants(audios, videos) {
  125.     const MapUtils = shaka.util.MapUtils;
  127.     // Create a variant for each variant id.
  128.     /** @type {!Object.<number, shakaExtern.Variant>} */
  129.     let variantMap = {};
  131.     let allStreams = [];
  132.     allStreams.push.apply(allStreams, audios);
  133.     allStreams.push.apply(allStreams, videos);
  135.     // Create a variant for each variant id across all the streams.
  136.     allStreams.forEach((stream) => {
  137.       stream.variantIds.forEach((id) => {
  138.         variantMap[id] = variantMap[id] || this.createEmptyVariant_(id);
  139.       });
  140.     });
  142.     // Assign each audio stream to its variants.
  143.     audios.forEach((audio) => {
  144.       /** @type {shakaExtern.Stream} */
  145.       let stream = this.fromStreamDB_(audio);
  147.       audio.variantIds.forEach((id) => {
  148.         let variant = variantMap[id];
  150.         goog.asserts.assert(
  151.             !variant.audio, 'A variant should only have one audio stream');
  153.         variant.language = stream.language;
  154.         variant.primary = variant.primary || stream.primary;
  155.         variant.audio = stream;
  156.       });
  157.     });
  159.     // Assign each video stream to its variants.
  160.     videos.forEach((video) => {
  161.       /** @type {shakaExtern.Stream} */
  162.       let stream = this.fromStreamDB_(video);
  164.       video.variantIds.forEach((id) => {
  165.         let variant = variantMap[id];
  167.         goog.asserts.assert(
  168.             !variant.video, 'A variant should only have one video stream');
  170.         variant.primary = variant.primary || stream.primary;
  171.         variant.video = stream;
  172.       });
  173.     });
  175.     return MapUtils.values(variantMap);
  176.   }
  178.   /**
  179.    * @param {shakaExtern.StreamDB} streamDB
  180.    * @return {shakaExtern.Stream}
  181.    * @private
  182.    */
  183.   fromStreamDB_(streamDB) {
  184.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  185.     let segments = streamDB.segments.map((segment, index) =>
  186.         this.fromSegmentDB_(index, segment));
  188.     /** @type {!shaka.media.SegmentIndex} */
  189.     let segmentIndex = new shaka.media.SegmentIndex(segments);
  191.     /** @type {shakaExtern.Stream} */
  192.     let stream = {
  193.       id: streamDB.id,
  194.       createSegmentIndex: () => Promise.resolve(),
  195.       findSegmentPosition: (index) => segmentIndex.find(index),
  196.       getSegmentReference: (index) => segmentIndex.get(index),
  197.       initSegmentReference: null,
  198.       presentationTimeOffset: streamDB.presentationTimeOffset,
  199.       mimeType: streamDB.mimeType,
  200.       codecs: streamDB.codecs,
  201.       width: streamDB.width || undefined,
  202.       height: streamDB.height || undefined,
  203.       frameRate: streamDB.frameRate || undefined,
  204.       kind: streamDB.kind,
  205.       encrypted: streamDB.encrypted,
  206.       keyId: streamDB.keyId,
  207.       language: streamDB.language,
  208.       label: streamDB.label || null,
  209.       type: streamDB.contentType,
  210.       primary: streamDB.primary,
  211.       trickModeVideo: null,
  212.       // TODO(modmaker): Store offline?
  213.       containsEmsgBoxes: false,
  214.       roles: [],
  215.       channelsCount: null
  216.     };
  218.     if (streamDB.initSegmentKey != null) {
  219.       stream.initSegmentReference =
  220.           this.fromInitSegmentDB_(streamDB.initSegmentKey);
  221.     }
  223.     return stream;
  224.   }
  226.   /**
  227.    * @param {number} index
  228.    * @param {shakaExtern.SegmentDB} segmentDB
  229.    * @return {!shaka.media.SegmentReference}
  230.    * @private
  231.    */
  232.   fromSegmentDB_(index, segmentDB) {
  233.     /** @type {!shaka.offline.OfflineUri} */
  234.     let uri = shaka.offline.OfflineUri.segment(
  235.         this.mechanism_, this.cell_, segmentDB.dataKey);
  237.     return new shaka.media.SegmentReference(
  238.         index,
  239.         segmentDB.startTime,
  240.         segmentDB.endTime,
  241.         () => [uri.toString()],
  242.         0 /* startByte */,
  243.         null /*  endByte */);
  244.   }
  246.   /**
  247.    * @param {number} key
  248.    * @return {!shaka.media.InitSegmentReference}
  249.    * @private
  250.    */
  251.   fromInitSegmentDB_(key) {
  252.     /** @type {!shaka.offline.OfflineUri} */
  253.     let uri = shaka.offline.OfflineUri.segment(
  254.         this.mechanism_, this.cell_, key);
  256.     return new shaka.media.InitSegmentReference(
  257.         () => [uri.toString()],
  258.         0 /* startBytes*/,
  259.         null /* endBytes */);
  260.   }
  262.   /**
  263.    * @param {shakaExtern.StreamDB} stream
  264.    * @return {boolean}
  265.    * @private
  266.    */
  267.   isAudio_(stream) {
  268.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  269.     return stream.contentType == ContentType.AUDIO;
  270.   }
  272.   /**
  273.    * @param {shakaExtern.StreamDB} stream
  274.    * @return {boolean}
  275.    * @private
  276.    */
  277.   isVideo_(stream) {
  278.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  279.     return stream.contentType == ContentType.VIDEO;
  280.   }
  282.   /**
  283.    * @param {shakaExtern.StreamDB} stream
  284.    * @return {boolean}
  285.    * @private
  286.    */
  287.   isText_(stream) {
  288.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  289.     return stream.contentType == ContentType.TEXT;
  290.   }
  292.   /**
  293.    * Creates an empty Variant.
  294.    *
  295.    * @param {number} id
  296.    * @return {!shakaExtern.Variant}
  297.    * @private
  298.    */
  299.   createEmptyVariant_(id) {
  300.     return {
  301.       id: id,
  302.       language: '',
  303.       primary: false,
  304.       audio: null,
  305.       video: null,
  306.       bandwidth: 0,
  307.       drmInfos: [],
  308.       allowedByApplication: true,
  309.       allowedByKeySystem: true
  310.     };
  311.   }
  312. };