Source: lib/offline/manifest_converter.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.ManifestConverter');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.media.InitSegmentReference');
  11. goog.require('shaka.media.PresentationTimeline');
  12. goog.require('shaka.media.SegmentIndex');
  13. goog.require('shaka.media.SegmentReference');
  14. goog.require('shaka.offline.OfflineUri');
  15. goog.require('shaka.util.ManifestParserUtils');
  18. /**
  19.  * Utility class for converting database manifest objects back to normal
  20.  * player-ready objects. Used by the offline system to convert on-disk
  21.  * objects back to the in-memory objects.
  22.  */
  23. shaka.offline.ManifestConverter = class {
  24.   /**
  25.    * Create a new manifest converter. Need to know the mechanism and cell that
  26.    * the manifest is from so that all segments paths can be created.
  27.    *
  28.    * @param {string} mechanism
  29.    * @param {string} cell
  30.    */
  31.   constructor(mechanism, cell) {
  32.     /** @private {string} */
  33.     this.mechanism_ = mechanism;
  35.     /** @private {string} */
  36.     this.cell_ = cell;
  37.   }
  39.   /**
  40.    * Convert a |shaka.extern.ManifestDB| object to a |shaka.extern.Manifest|
  41.    * object.
  42.    *
  43.    * @param {shaka.extern.ManifestDB} manifestDB
  44.    * @return {shaka.extern.Manifest}
  45.    */
  46.   fromManifestDB(manifestDB) {
  47.     const timeline = new shaka.media.PresentationTimeline(null, 0);
  48.     timeline.setDuration(manifestDB.duration);
  50.     /** @type {!Array.<shaka.extern.StreamDB>} */
  51.     const audioStreams =
  52.         manifestDB.streams.filter((streamDB) => this.isAudio_(streamDB));
  54.     /** @type {!Array.<shaka.extern.StreamDB>} */
  55.     const videoStreams =
  56.         manifestDB.streams.filter((streamDB) => this.isVideo_(streamDB));
  58.     /** @type {!Map.<number, shaka.extern.Variant>} */
  59.     const variants = this.createVariants(audioStreams, videoStreams, timeline);
  61.     /** @type {!Array.<shaka.extern.Stream>} */
  62.     const textStreams =
  63.         manifestDB.streams.filter((streamDB) => this.isText_(streamDB))
  64.             .map((streamDB) => this.fromStreamDB_(streamDB, timeline));
  66.     /** @type {!Array.<shaka.extern.Stream>} */
  67.     const imageStreams =
  68.         manifestDB.streams.filter((streamDB) => this.isImage_(streamDB))
  69.             .map((streamDB) => this.fromStreamDB_(streamDB, timeline));
  71.     const drmInfos = manifestDB.drmInfo ? [manifestDB.drmInfo] : [];
  72.     if (manifestDB.drmInfo) {
  73.       for (const variant of variants.values()) {
  74.         if (variant.audio && variant.audio.encrypted) {
  75.           variant.audio.drmInfos = drmInfos;
  76.         }
  77.         if (variant.video && variant.video.encrypted) {
  78.           variant.video.drmInfos = drmInfos;
  79.         }
  80.       }
  81.     }
  83.     return {
  84.       presentationTimeline: timeline,
  85.       minBufferTime: 2,
  86.       offlineSessionIds: manifestDB.sessionIds,
  87.       variants: Array.from(variants.values()),
  88.       textStreams: textStreams,
  89.       imageStreams: imageStreams,
  90.     };
  91.   }
  93.   /**
  94.    * Recreates Variants from audio and video StreamDB collections.
  95.    *
  96.    * @param {!Array.<!shaka.extern.StreamDB>} audios
  97.    * @param {!Array.<!shaka.extern.StreamDB>} videos
  98.    * @param {shaka.media.PresentationTimeline} timeline
  99.    * @return {!Map.<number, !shaka.extern.Variant>}
  100.    */
  101.   createVariants(audios, videos, timeline) {
  102.     // Get all the variant ids from all audio and video streams.
  103.     /** @type {!Set.<number>} */
  104.     const variantIds = new Set();
  105.     for (const streamDB of audios) {
  106.       for (const id of streamDB.variantIds) {
  107.         variantIds.add(id);
  108.       }
  109.     }
  110.     for (const streamDB of videos) {
  111.       for (const id of streamDB.variantIds) {
  112.         variantIds.add(id);
  113.       }
  114.     }
  116.     /** @type {!Map.<number, shaka.extern.Variant>} */
  117.     const variantMap = new Map();
  118.     for (const id of variantIds) {
  119.       variantMap.set(id, this.createEmptyVariant_(id));
  120.     }
  122.     // Assign each audio stream to its variants.
  123.     for (const audio of audios) {
  124.       /** @type {shaka.extern.Stream} */
  125.       const stream = this.fromStreamDB_(audio, timeline);
  127.       for (const variantId of audio.variantIds) {
  128.         const variant = variantMap.get(variantId);
  130.         goog.asserts.assert(
  131.             !variant.audio, 'A variant should only have one audio stream');
  133.         variant.language = stream.language;
  134.         variant.primary = variant.primary || stream.primary;
  135.         variant.audio = stream;
  136.       }
  137.     }
  139.     // Assign each video stream to its variants.
  140.     for (const video of videos) {
  141.       /** @type {shaka.extern.Stream} */
  142.       const stream = this.fromStreamDB_(video, timeline);
  144.       for (const variantId of video.variantIds) {
  145.         const variant = variantMap.get(variantId);
  147.         goog.asserts.assert(
  148.             !variant.video, 'A variant should only have one video stream');
  150.         variant.primary = variant.primary || stream.primary;
  151.         variant.video = stream;
  152.       }
  153.     }
  155.     return variantMap;
  156.   }
  158.   /**
  159.    * @param {shaka.extern.StreamDB} streamDB
  160.    * @param {shaka.media.PresentationTimeline} timeline
  161.    * @return {shaka.extern.Stream}
  162.    * @private
  163.    */
  164.   fromStreamDB_(streamDB, timeline) {
  165.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  166.     const segments = streamDB.segments.map(
  167.         (segment, index) => this.fromSegmentDB_(index, segment));
  169.     timeline.notifySegments(segments);
  171.     /** @type {!shaka.media.SegmentIndex} */
  172.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  174.     /** @type {shaka.extern.Stream} */
  175.     const stream = {
  176.       id: streamDB.id,
  177.       originalId: streamDB.originalId,
  178.       createSegmentIndex: () => Promise.resolve(),
  179.       segmentIndex,
  180.       mimeType: streamDB.mimeType,
  181.       codecs: streamDB.codecs,
  182.       width: streamDB.width || undefined,
  183.       height: streamDB.height || undefined,
  184.       frameRate: streamDB.frameRate,
  185.       pixelAspectRatio: streamDB.pixelAspectRatio,
  186.       hdr: streamDB.hdr,
  187.       kind: streamDB.kind,
  188.       encrypted: streamDB.encrypted,
  189.       drmInfos: [],
  190.       keyIds: streamDB.keyIds,
  191.       language: streamDB.language,
  192.       label: streamDB.label,
  193.       type: streamDB.type,
  194.       primary: streamDB.primary,
  195.       trickModeVideo: null,
  196.       emsgSchemeIdUris: null,
  197.       roles: streamDB.roles,
  198.       forced: streamDB.forced,
  199.       channelsCount: streamDB.channelsCount,
  200.       audioSamplingRate: streamDB.audioSamplingRate,
  201.       spatialAudio: streamDB.spatialAudio,
  202.       closedCaptions: streamDB.closedCaptions,
  203.       tilesLayout: streamDB.tilesLayout,
  204.     };
  206.     return stream;
  207.   }
  209.   /**
  210.    * @param {number} index
  211.    * @param {shaka.extern.SegmentDB} segmentDB
  212.    * @return {!shaka.media.SegmentReference}
  213.    * @private
  214.    */
  215.   fromSegmentDB_(index, segmentDB) {
  216.     /** @type {!shaka.offline.OfflineUri} */
  217.     const uri = shaka.offline.OfflineUri.segment(
  218.         this.mechanism_, this.cell_, segmentDB.dataKey);
  220.     const initSegmentReference = segmentDB.initSegmentKey != null ?
  221.         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
  223.     return new shaka.media.SegmentReference(
  224.         segmentDB.startTime,
  225.         segmentDB.endTime,
  226.         () => [uri.toString()],
  227.         /* startByte= */ 0,
  228.         /* endByte= */ null,
  229.         initSegmentReference,
  230.         segmentDB.timestampOffset,
  231.         segmentDB.appendWindowStart,
  232.         segmentDB.appendWindowEnd);
  233.   }
  235.   /**
  236.    * @param {number} key
  237.    * @return {!shaka.media.InitSegmentReference}
  238.    * @private
  239.    */
  240.   fromInitSegmentDB_(key) {
  241.     /** @type {!shaka.offline.OfflineUri} */
  242.     const uri = shaka.offline.OfflineUri.segment(
  243.         this.mechanism_, this.cell_, key);
  245.     return new shaka.media.InitSegmentReference(
  246.         () => [uri.toString()],
  247.         /* startBytes= */ 0,
  248.         /* endBytes= */ null );
  249.   }
  251.   /**
  252.    * @param {shaka.extern.StreamDB} streamDB
  253.    * @return {boolean}
  254.    * @private
  255.    */
  256.   isAudio_(streamDB) {
  257.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  258.     return streamDB.type == ContentType.AUDIO;
  259.   }
  261.   /**
  262.    * @param {shaka.extern.StreamDB} streamDB
  263.    * @return {boolean}
  264.    * @private
  265.    */
  266.   isVideo_(streamDB) {
  267.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  268.     return streamDB.type == ContentType.VIDEO;
  269.   }
  271.   /**
  272.    * @param {shaka.extern.StreamDB} streamDB
  273.    * @return {boolean}
  274.    * @private
  275.    */
  276.   isText_(streamDB) {
  277.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  278.     return streamDB.type == ContentType.TEXT;
  279.   }
  281.   /**
  282.    * @param {shaka.extern.StreamDB} streamDB
  283.    * @return {boolean}
  284.    * @private
  285.    */
  286.   isImage_(streamDB) {
  287.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  288.     return streamDB.type == ContentType.IMAGE;
  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.       allowedByApplication: true,
  307.       allowedByKeySystem: true,
  308.       decodingInfos: [],
  309.     };
  310.   }
  311. };