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.ManifestParser');
  12. goog.require('shaka.media.PresentationTimeline');
  13. goog.require('shaka.media.SegmentIndex');
  14. goog.require('shaka.media.SegmentReference');
  15. goog.require('shaka.offline.OfflineUri');
  16. goog.require('shaka.util.ManifestParserUtils');
  17. goog.require('shaka.util.MimeUtils');
  20. /**
  21.  * Utility class for converting database manifest objects back to normal
  22.  * player-ready objects. Used by the offline system to convert on-disk
  23.  * objects back to the in-memory objects.
  24.  */
  25. shaka.offline.ManifestConverter = class {
  26.   /**
  27.    * Create a new manifest converter. Need to know the mechanism and cell that
  28.    * the manifest is from so that all segments paths can be created.
  29.    *
  30.    * @param {string} mechanism
  31.    * @param {string} cell
  32.    */
  33.   constructor(mechanism, cell) {
  34.     /** @private {string} */
  35.     this.mechanism_ = mechanism;
  37.     /** @private {string} */
  38.     this.cell_ = cell;
  39.   }
  41.   /**
  42.    * Convert a |shaka.extern.ManifestDB| object to a |shaka.extern.Manifest|
  43.    * object.
  44.    *
  45.    * @param {shaka.extern.ManifestDB} manifestDB
  46.    * @return {shaka.extern.Manifest}
  47.    */
  48.   fromManifestDB(manifestDB) {
  49.     const timeline = new shaka.media.PresentationTimeline(null, 0);
  50.     timeline.setDuration(manifestDB.duration);
  52.     /** @type {!Array.<shaka.extern.StreamDB>} */
  53.     const audioStreams =
  54.         manifestDB.streams.filter((streamDB) => this.isAudio_(streamDB));
  56.     /** @type {!Array.<shaka.extern.StreamDB>} */
  57.     const videoStreams =
  58.         manifestDB.streams.filter((streamDB) => this.isVideo_(streamDB));
  60.     /** @type {!Map.<number, shaka.extern.Variant>} */
  61.     const variants = this.createVariants(audioStreams, videoStreams, timeline);
  63.     /** @type {!Array.<shaka.extern.Stream>} */
  64.     const textStreams =
  65.         manifestDB.streams.filter((streamDB) => this.isText_(streamDB))
  66.             .map((streamDB) => this.fromStreamDB_(streamDB, timeline));
  68.     /** @type {!Array.<shaka.extern.Stream>} */
  69.     const imageStreams =
  70.         manifestDB.streams.filter((streamDB) => this.isImage_(streamDB))
  71.             .map((streamDB) => this.fromStreamDB_(streamDB, timeline));
  73.     const drmInfos = manifestDB.drmInfo ? [manifestDB.drmInfo] : [];
  74.     if (manifestDB.drmInfo) {
  75.       for (const variant of variants.values()) {
  76.         if (variant.audio && variant.audio.encrypted) {
  77.           variant.audio.drmInfos = drmInfos;
  78.         }
  79.         if (variant.video && variant.video.encrypted) {
  80.           variant.video.drmInfos = drmInfos;
  81.         }
  82.       }
  83.     }
  85.     return {
  86.       presentationTimeline: timeline,
  87.       minBufferTime: 2,
  88.       offlineSessionIds: manifestDB.sessionIds,
  89.       variants: Array.from(variants.values()),
  90.       textStreams: textStreams,
  91.       imageStreams: imageStreams,
  92.       sequenceMode: manifestDB.sequenceMode || false,
  93.       ignoreManifestTimestampsInSegmentsMode: false,
  94.       type: manifestDB.type || shaka.media.ManifestParser.UNKNOWN,
  95.       serviceDescription: null,
  96.       nextUrl: null,
  97.     };
  98.   }
  100.   /**
  101.    * Recreates Variants from audio and video StreamDB collections.
  102.    *
  103.    * @param {!Array.<!shaka.extern.StreamDB>} audios
  104.    * @param {!Array.<!shaka.extern.StreamDB>} videos
  105.    * @param {shaka.media.PresentationTimeline} timeline
  106.    * @return {!Map.<number, !shaka.extern.Variant>}
  107.    */
  108.   createVariants(audios, videos, timeline) {
  109.     // Get all the variant ids from all audio and video streams.
  110.     /** @type {!Set.<number>} */
  111.     const variantIds = new Set();
  112.     for (const streamDB of audios) {
  113.       for (const id of streamDB.variantIds) {
  114.         variantIds.add(id);
  115.       }
  116.     }
  117.     for (const streamDB of videos) {
  118.       for (const id of streamDB.variantIds) {
  119.         variantIds.add(id);
  120.       }
  121.     }
  123.     /** @type {!Map.<number, shaka.extern.Variant>} */
  124.     const variantMap = new Map();
  125.     for (const id of variantIds) {
  126.       variantMap.set(id, this.createEmptyVariant_(id));
  127.     }
  129.     // Assign each audio stream to its variants.
  130.     for (const audio of audios) {
  131.       /** @type {shaka.extern.Stream} */
  132.       const stream = this.fromStreamDB_(audio, timeline);
  134.       for (const variantId of audio.variantIds) {
  135.         const variant = variantMap.get(variantId);
  137.         goog.asserts.assert(
  138.             !variant.audio, 'A variant should only have one audio stream');
  140.         variant.language = stream.language;
  141.         variant.primary = variant.primary || stream.primary;
  142.         variant.audio = stream;
  143.       }
  144.     }
  146.     // Assign each video stream to its variants.
  147.     for (const video of videos) {
  148.       /** @type {shaka.extern.Stream} */
  149.       const stream = this.fromStreamDB_(video, timeline);
  151.       for (const variantId of video.variantIds) {
  152.         const variant = variantMap.get(variantId);
  154.         goog.asserts.assert(
  155.             !variant.video, 'A variant should only have one video stream');
  157.         variant.primary = variant.primary || stream.primary;
  158.         variant.video = stream;
  159.       }
  160.     }
  162.     return variantMap;
  163.   }
  165.   /**
  166.    * @param {shaka.extern.StreamDB} streamDB
  167.    * @param {shaka.media.PresentationTimeline} timeline
  168.    * @return {shaka.extern.Stream}
  169.    * @private
  170.    */
  171.   fromStreamDB_(streamDB, timeline) {
  172.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  173.     const segments = streamDB.segments.map(
  174.         (segment, index) => this.fromSegmentDB_(index, segment, streamDB));
  176.     timeline.notifySegments(segments);
  178.     /** @type {!shaka.media.SegmentIndex} */
  179.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  181.     /** @type {shaka.extern.Stream} */
  182.     const stream = {
  183.       id: streamDB.id,
  184.       originalId: streamDB.originalId,
  185.       groupId: streamDB.groupId,
  186.       createSegmentIndex: () => Promise.resolve(),
  187.       segmentIndex,
  188.       mimeType: streamDB.mimeType,
  189.       codecs: streamDB.codecs,
  190.       width: streamDB.width || undefined,
  191.       height: streamDB.height || undefined,
  192.       frameRate: streamDB.frameRate,
  193.       pixelAspectRatio: streamDB.pixelAspectRatio,
  194.       hdr: streamDB.hdr,
  195.       colorGamut: streamDB.colorGamut,
  196.       videoLayout: streamDB.videoLayout,
  197.       kind: streamDB.kind,
  198.       encrypted: streamDB.encrypted,
  199.       drmInfos: [],
  200.       keyIds: streamDB.keyIds,
  201.       language: streamDB.language,
  202.       originalLanguage: streamDB.originalLanguage || null,
  203.       label: streamDB.label,
  204.       type: streamDB.type,
  205.       primary: streamDB.primary,
  206.       trickModeVideo: null,
  207.       emsgSchemeIdUris: null,
  208.       roles: streamDB.roles,
  209.       forced: streamDB.forced,
  210.       channelsCount: streamDB.channelsCount,
  211.       audioSamplingRate: streamDB.audioSamplingRate,
  212.       spatialAudio: streamDB.spatialAudio,
  213.       closedCaptions: streamDB.closedCaptions,
  214.       tilesLayout: streamDB.tilesLayout,
  215.       accessibilityPurpose: null,
  216.       external: streamDB.external,
  217.       fastSwitching: streamDB.fastSwitching,
  218.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  219.           streamDB.mimeType, streamDB.codecs)]),
  220.     };
  222.     return stream;
  223.   }
  225.   /**
  226.    * @param {number} index
  227.    * @param {shaka.extern.SegmentDB} segmentDB
  228.    * @param {shaka.extern.StreamDB} streamDB
  229.    * @return {!shaka.media.SegmentReference}
  230.    * @private
  231.    */
  232.   fromSegmentDB_(index, segmentDB, streamDB) {
  233.     /** @type {!shaka.offline.OfflineUri} */
  234.     const uri = shaka.offline.OfflineUri.segment(
  235.         this.mechanism_, this.cell_, segmentDB.dataKey);
  237.     const initSegmentReference = segmentDB.initSegmentKey != null ?
  238.         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
  240.     const ref = new shaka.media.SegmentReference(
  241.         segmentDB.startTime,
  242.         segmentDB.endTime,
  243.         () => [uri.toString()],
  244.         /* startByte= */ 0,
  245.         /* endByte= */ null,
  246.         initSegmentReference,
  247.         segmentDB.timestampOffset,
  248.         segmentDB.appendWindowStart,
  249.         segmentDB.appendWindowEnd,
  250.         /* partialReferences= */ [],
  251.         segmentDB.tilesLayout || '');
  252.     ref.mimeType = segmentDB.mimeType || streamDB.mimeType || '';
  253.     ref.codecs = segmentDB.codecs || streamDB.codecs || '';
  254.     return ref;
  255.   }
  257.   /**
  258.    * @param {number} key
  259.    * @return {!shaka.media.InitSegmentReference}
  260.    * @private
  261.    */
  262.   fromInitSegmentDB_(key) {
  263.     /** @type {!shaka.offline.OfflineUri} */
  264.     const uri = shaka.offline.OfflineUri.segment(
  265.         this.mechanism_, this.cell_, key);
  267.     return new shaka.media.InitSegmentReference(
  268.         () => [uri.toString()],
  269.         /* startBytes= */ 0,
  270.         /* endBytes= */ null );
  271.   }
  273.   /**
  274.    * @param {shaka.extern.StreamDB} streamDB
  275.    * @return {boolean}
  276.    * @private
  277.    */
  278.   isAudio_(streamDB) {
  279.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  280.     return streamDB.type == ContentType.AUDIO;
  281.   }
  283.   /**
  284.    * @param {shaka.extern.StreamDB} streamDB
  285.    * @return {boolean}
  286.    * @private
  287.    */
  288.   isVideo_(streamDB) {
  289.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  290.     return streamDB.type == ContentType.VIDEO;
  291.   }
  293.   /**
  294.    * @param {shaka.extern.StreamDB} streamDB
  295.    * @return {boolean}
  296.    * @private
  297.    */
  298.   isText_(streamDB) {
  299.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  300.     return streamDB.type == ContentType.TEXT;
  301.   }
  303.   /**
  304.    * @param {shaka.extern.StreamDB} streamDB
  305.    * @return {boolean}
  306.    * @private
  307.    */
  308.   isImage_(streamDB) {
  309.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  310.     return streamDB.type == ContentType.IMAGE;
  311.   }
  313.   /**
  314.    * Creates an empty Variant.
  315.    *
  316.    * @param {number} id
  317.    * @return {!shaka.extern.Variant}
  318.    * @private
  319.    */
  320.   createEmptyVariant_(id) {
  321.     return {
  322.       id: id,
  323.       language: '',
  324.       disabledUntilTime: 0,
  325.       primary: false,
  326.       audio: null,
  327.       video: null,
  328.       bandwidth: 0,
  329.       allowedByApplication: true,
  330.       allowedByKeySystem: true,
  331.       decodingInfos: [],
  332.     };
  333.   }
  334. };