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.       offlineSessionIds: manifestDB.sessionIds,
  88.       variants: Array.from(variants.values()),
  89.       textStreams: textStreams,
  90.       imageStreams: imageStreams,
  91.       sequenceMode: manifestDB.sequenceMode || false,
  92.       ignoreManifestTimestampsInSegmentsMode: false,
  93.       type: manifestDB.type || shaka.media.ManifestParser.UNKNOWN,
  94.       serviceDescription: null,
  95.       nextUrl: null,
  96.       periodCount: 1,
  97.       gapCount: 0,
  98.       isLowLatency: false,
  99.       startTime: null,
  100.     };
  101.   }
  103.   /**
  104.    * Recreates Variants from audio and video StreamDB collections.
  105.    *
  106.    * @param {!Array<!shaka.extern.StreamDB>} audios
  107.    * @param {!Array<!shaka.extern.StreamDB>} videos
  108.    * @param {shaka.media.PresentationTimeline} timeline
  109.    * @return {!Map<number, !shaka.extern.Variant>}
  110.    */
  111.   createVariants(audios, videos, timeline) {
  112.     // Get all the variant ids from all audio and video streams.
  113.     /** @type {!Set<number>} */
  114.     const variantIds = new Set();
  115.     for (const streamDB of audios) {
  116.       for (const id of streamDB.variantIds) {
  117.         variantIds.add(id);
  118.       }
  119.     }
  120.     for (const streamDB of videos) {
  121.       for (const id of streamDB.variantIds) {
  122.         variantIds.add(id);
  123.       }
  124.     }
  126.     /** @type {!Map<number, shaka.extern.Variant>} */
  127.     const variantMap = new Map();
  128.     for (const id of variantIds) {
  129.       variantMap.set(id, this.createEmptyVariant_(id));
  130.     }
  132.     // Assign each audio stream to its variants.
  133.     for (const audio of audios) {
  134.       /** @type {shaka.extern.Stream} */
  135.       const stream = this.fromStreamDB_(audio, timeline);
  137.       for (const variantId of audio.variantIds) {
  138.         const variant = variantMap.get(variantId);
  140.         goog.asserts.assert(
  141.             !variant.audio, 'A variant should only have one audio stream');
  143.         variant.language = stream.language;
  144.         variant.primary = variant.primary || stream.primary;
  145.         variant.audio = stream;
  146.       }
  147.     }
  149.     // Assign each video stream to its variants.
  150.     for (const video of videos) {
  151.       /** @type {shaka.extern.Stream} */
  152.       const stream = this.fromStreamDB_(video, timeline);
  154.       for (const variantId of video.variantIds) {
  155.         const variant = variantMap.get(variantId);
  157.         goog.asserts.assert(
  158.             !variant.video, 'A variant should only have one video stream');
  160.         variant.primary = variant.primary || stream.primary;
  161.         variant.video = stream;
  162.       }
  163.     }
  165.     return variantMap;
  166.   }
  168.   /**
  169.    * @param {shaka.extern.StreamDB} streamDB
  170.    * @param {shaka.media.PresentationTimeline} timeline
  171.    * @return {shaka.extern.Stream}
  172.    * @private
  173.    */
  174.   fromStreamDB_(streamDB, timeline) {
  175.     /** @type {!Array<!shaka.media.SegmentReference>} */
  176.     const segments = streamDB.segments.map(
  177.         (segment, index) => this.fromSegmentDB_(index, segment, streamDB));
  179.     timeline.notifySegments(segments);
  181.     /** @type {!shaka.media.SegmentIndex} */
  182.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  184.     /** @type {shaka.extern.Stream} */
  185.     const stream = {
  186.       id: streamDB.id,
  187.       originalId: streamDB.originalId,
  188.       groupId: streamDB.groupId,
  189.       createSegmentIndex: () => Promise.resolve(),
  190.       segmentIndex,
  191.       mimeType: streamDB.mimeType,
  192.       codecs: streamDB.codecs,
  193.       width: streamDB.width || undefined,
  194.       height: streamDB.height || undefined,
  195.       frameRate: streamDB.frameRate,
  196.       pixelAspectRatio: streamDB.pixelAspectRatio,
  197.       hdr: streamDB.hdr,
  198.       colorGamut: streamDB.colorGamut,
  199.       videoLayout: streamDB.videoLayout,
  200.       kind: streamDB.kind,
  201.       encrypted: streamDB.encrypted,
  202.       drmInfos: [],
  203.       keyIds: streamDB.keyIds,
  204.       language: streamDB.language,
  205.       originalLanguage: streamDB.originalLanguage || null,
  206.       label: streamDB.label,
  207.       type: streamDB.type,
  208.       primary: streamDB.primary,
  209.       trickModeVideo: null,
  210.       dependencyStream: null,
  211.       emsgSchemeIdUris: null,
  212.       roles: streamDB.roles,
  213.       forced: streamDB.forced,
  214.       channelsCount: streamDB.channelsCount,
  215.       audioSamplingRate: streamDB.audioSamplingRate,
  216.       spatialAudio: streamDB.spatialAudio,
  217.       closedCaptions: streamDB.closedCaptions,
  218.       tilesLayout: streamDB.tilesLayout,
  219.       mssPrivateData: streamDB.mssPrivateData,
  220.       accessibilityPurpose: null,
  221.       external: streamDB.external,
  222.       fastSwitching: streamDB.fastSwitching,
  223.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  224.           streamDB.mimeType, streamDB.codecs)]),
  225.       isAudioMuxedInVideo: false,
  226.       baseOriginalId: null,
  227.     };
  229.     return stream;
  230.   }
  232.   /**
  233.    * @param {number} index
  234.    * @param {shaka.extern.SegmentDB} segmentDB
  235.    * @param {shaka.extern.StreamDB} streamDB
  236.    * @return {!shaka.media.SegmentReference}
  237.    * @private
  238.    */
  239.   fromSegmentDB_(index, segmentDB, streamDB) {
  240.     /** @type {!shaka.offline.OfflineUri} */
  241.     const uri = shaka.offline.OfflineUri.segment(
  242.         this.mechanism_, this.cell_, segmentDB.dataKey);
  244.     const initSegmentReference = segmentDB.initSegmentKey != null ?
  245.         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
  247.     const ref = new shaka.media.SegmentReference(
  248.         segmentDB.startTime,
  249.         segmentDB.endTime,
  250.         () => [uri.toString()],
  251.         /* startByte= */ 0,
  252.         /* endByte= */ null,
  253.         initSegmentReference,
  254.         segmentDB.timestampOffset,
  255.         segmentDB.appendWindowStart,
  256.         segmentDB.appendWindowEnd,
  257.         /* partialReferences= */ [],
  258.         segmentDB.tilesLayout || '');
  259.     ref.mimeType = segmentDB.mimeType || streamDB.mimeType || '';
  260.     ref.codecs = segmentDB.codecs || streamDB.codecs || '';
  261.     if (segmentDB.thumbnailSprite) {
  262.       ref.setThumbnailSprite(segmentDB.thumbnailSprite);
  263.     }
  264.     return ref;
  265.   }
  267.   /**
  268.    * @param {number} key
  269.    * @return {!shaka.media.InitSegmentReference}
  270.    * @private
  271.    */
  272.   fromInitSegmentDB_(key) {
  273.     /** @type {!shaka.offline.OfflineUri} */
  274.     const uri = shaka.offline.OfflineUri.segment(
  275.         this.mechanism_, this.cell_, key);
  277.     return new shaka.media.InitSegmentReference(
  278.         () => [uri.toString()],
  279.         /* startBytes= */ 0,
  280.         /* endBytes= */ null );
  281.   }
  283.   /**
  284.    * @param {shaka.extern.StreamDB} streamDB
  285.    * @return {boolean}
  286.    * @private
  287.    */
  288.   isAudio_(streamDB) {
  289.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  290.     return streamDB.type == ContentType.AUDIO;
  291.   }
  293.   /**
  294.    * @param {shaka.extern.StreamDB} streamDB
  295.    * @return {boolean}
  296.    * @private
  297.    */
  298.   isVideo_(streamDB) {
  299.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  300.     return streamDB.type == ContentType.VIDEO;
  301.   }
  303.   /**
  304.    * @param {shaka.extern.StreamDB} streamDB
  305.    * @return {boolean}
  306.    * @private
  307.    */
  308.   isText_(streamDB) {
  309.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  310.     return streamDB.type == ContentType.TEXT;
  311.   }
  313.   /**
  314.    * @param {shaka.extern.StreamDB} streamDB
  315.    * @return {boolean}
  316.    * @private
  317.    */
  318.   isImage_(streamDB) {
  319.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  320.     return streamDB.type == ContentType.IMAGE;
  321.   }
  323.   /**
  324.    * Creates an empty Variant.
  325.    *
  326.    * @param {number} id
  327.    * @return {!shaka.extern.Variant}
  328.    * @private
  329.    */
  330.   createEmptyVariant_(id) {
  331.     return {
  332.       id: id,
  333.       language: '',
  334.       disabledUntilTime: 0,
  335.       primary: false,
  336.       audio: null,
  337.       video: null,
  338.       bandwidth: 0,
  339.       allowedByApplication: true,
  340.       allowedByKeySystem: true,
  341.       decodingInfos: [],
  342.     };
  343.   }
  344. };