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.       periodCount: 1,
  98.       gapCount: 0,
  99.       isLowLatency: false,
  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.       emsgSchemeIdUris: null,
  211.       roles: streamDB.roles,
  212.       forced: streamDB.forced,
  213.       channelsCount: streamDB.channelsCount,
  214.       audioSamplingRate: streamDB.audioSamplingRate,
  215.       spatialAudio: streamDB.spatialAudio,
  216.       closedCaptions: streamDB.closedCaptions,
  217.       tilesLayout: streamDB.tilesLayout,
  218.       accessibilityPurpose: null,
  219.       external: streamDB.external,
  220.       fastSwitching: streamDB.fastSwitching,
  221.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  222.           streamDB.mimeType, streamDB.codecs)]),
  223.     };
  225.     return stream;
  226.   }
  228.   /**
  229.    * @param {number} index
  230.    * @param {shaka.extern.SegmentDB} segmentDB
  231.    * @param {shaka.extern.StreamDB} streamDB
  232.    * @return {!shaka.media.SegmentReference}
  233.    * @private
  234.    */
  235.   fromSegmentDB_(index, segmentDB, streamDB) {
  236.     /** @type {!shaka.offline.OfflineUri} */
  237.     const uri = shaka.offline.OfflineUri.segment(
  238.         this.mechanism_, this.cell_, segmentDB.dataKey);
  240.     const initSegmentReference = segmentDB.initSegmentKey != null ?
  241.         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
  243.     const ref = new shaka.media.SegmentReference(
  244.         segmentDB.startTime,
  245.         segmentDB.endTime,
  246.         () => [uri.toString()],
  247.         /* startByte= */ 0,
  248.         /* endByte= */ null,
  249.         initSegmentReference,
  250.         segmentDB.timestampOffset,
  251.         segmentDB.appendWindowStart,
  252.         segmentDB.appendWindowEnd,
  253.         /* partialReferences= */ [],
  254.         segmentDB.tilesLayout || '');
  255.     ref.mimeType = segmentDB.mimeType || streamDB.mimeType || '';
  256.     ref.codecs = segmentDB.codecs || streamDB.codecs || '';
  257.     return ref;
  258.   }
  260.   /**
  261.    * @param {number} key
  262.    * @return {!shaka.media.InitSegmentReference}
  263.    * @private
  264.    */
  265.   fromInitSegmentDB_(key) {
  266.     /** @type {!shaka.offline.OfflineUri} */
  267.     const uri = shaka.offline.OfflineUri.segment(
  268.         this.mechanism_, this.cell_, key);
  270.     return new shaka.media.InitSegmentReference(
  271.         () => [uri.toString()],
  272.         /* startBytes= */ 0,
  273.         /* endBytes= */ null );
  274.   }
  276.   /**
  277.    * @param {shaka.extern.StreamDB} streamDB
  278.    * @return {boolean}
  279.    * @private
  280.    */
  281.   isAudio_(streamDB) {
  282.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  283.     return streamDB.type == ContentType.AUDIO;
  284.   }
  286.   /**
  287.    * @param {shaka.extern.StreamDB} streamDB
  288.    * @return {boolean}
  289.    * @private
  290.    */
  291.   isVideo_(streamDB) {
  292.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  293.     return streamDB.type == ContentType.VIDEO;
  294.   }
  296.   /**
  297.    * @param {shaka.extern.StreamDB} streamDB
  298.    * @return {boolean}
  299.    * @private
  300.    */
  301.   isText_(streamDB) {
  302.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  303.     return streamDB.type == ContentType.TEXT;
  304.   }
  306.   /**
  307.    * @param {shaka.extern.StreamDB} streamDB
  308.    * @return {boolean}
  309.    * @private
  310.    */
  311.   isImage_(streamDB) {
  312.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  313.     return streamDB.type == ContentType.IMAGE;
  314.   }
  316.   /**
  317.    * Creates an empty Variant.
  318.    *
  319.    * @param {number} id
  320.    * @return {!shaka.extern.Variant}
  321.    * @private
  322.    */
  323.   createEmptyVariant_(id) {
  324.     return {
  325.       id: id,
  326.       language: '',
  327.       disabledUntilTime: 0,
  328.       primary: false,
  329.       audio: null,
  330.       video: null,
  331.       bandwidth: 0,
  332.       allowedByApplication: true,
  333.       allowedByKeySystem: true,
  334.       decodingInfos: [],
  335.     };
  336.   }
  337. };