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.       startTime: null,
  101.     };
  102.   }
  104.   /**
  105.    * Recreates Variants from audio and video StreamDB collections.
  106.    *
  107.    * @param {!Array.<!shaka.extern.StreamDB>} audios
  108.    * @param {!Array.<!shaka.extern.StreamDB>} videos
  109.    * @param {shaka.media.PresentationTimeline} timeline
  110.    * @return {!Map.<number, !shaka.extern.Variant>}
  111.    */
  112.   createVariants(audios, videos, timeline) {
  113.     // Get all the variant ids from all audio and video streams.
  114.     /** @type {!Set.<number>} */
  115.     const variantIds = new Set();
  116.     for (const streamDB of audios) {
  117.       for (const id of streamDB.variantIds) {
  118.         variantIds.add(id);
  119.       }
  120.     }
  121.     for (const streamDB of videos) {
  122.       for (const id of streamDB.variantIds) {
  123.         variantIds.add(id);
  124.       }
  125.     }
  127.     /** @type {!Map.<number, shaka.extern.Variant>} */
  128.     const variantMap = new Map();
  129.     for (const id of variantIds) {
  130.       variantMap.set(id, this.createEmptyVariant_(id));
  131.     }
  133.     // Assign each audio stream to its variants.
  134.     for (const audio of audios) {
  135.       /** @type {shaka.extern.Stream} */
  136.       const stream = this.fromStreamDB_(audio, timeline);
  138.       for (const variantId of audio.variantIds) {
  139.         const variant = variantMap.get(variantId);
  141.         goog.asserts.assert(
  142.             !variant.audio, 'A variant should only have one audio stream');
  144.         variant.language = stream.language;
  145.         variant.primary = variant.primary || stream.primary;
  146.         variant.audio = stream;
  147.       }
  148.     }
  150.     // Assign each video stream to its variants.
  151.     for (const video of videos) {
  152.       /** @type {shaka.extern.Stream} */
  153.       const stream = this.fromStreamDB_(video, timeline);
  155.       for (const variantId of video.variantIds) {
  156.         const variant = variantMap.get(variantId);
  158.         goog.asserts.assert(
  159.             !variant.video, 'A variant should only have one video stream');
  161.         variant.primary = variant.primary || stream.primary;
  162.         variant.video = stream;
  163.       }
  164.     }
  166.     return variantMap;
  167.   }
  169.   /**
  170.    * @param {shaka.extern.StreamDB} streamDB
  171.    * @param {shaka.media.PresentationTimeline} timeline
  172.    * @return {shaka.extern.Stream}
  173.    * @private
  174.    */
  175.   fromStreamDB_(streamDB, timeline) {
  176.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  177.     const segments = streamDB.segments.map(
  178.         (segment, index) => this.fromSegmentDB_(index, segment, streamDB));
  180.     timeline.notifySegments(segments);
  182.     /** @type {!shaka.media.SegmentIndex} */
  183.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  185.     /** @type {shaka.extern.Stream} */
  186.     const stream = {
  187.       id: streamDB.id,
  188.       originalId: streamDB.originalId,
  189.       groupId: streamDB.groupId,
  190.       createSegmentIndex: () => Promise.resolve(),
  191.       segmentIndex,
  192.       mimeType: streamDB.mimeType,
  193.       codecs: streamDB.codecs,
  194.       width: streamDB.width || undefined,
  195.       height: streamDB.height || undefined,
  196.       frameRate: streamDB.frameRate,
  197.       pixelAspectRatio: streamDB.pixelAspectRatio,
  198.       hdr: streamDB.hdr,
  199.       colorGamut: streamDB.colorGamut,
  200.       videoLayout: streamDB.videoLayout,
  201.       kind: streamDB.kind,
  202.       encrypted: streamDB.encrypted,
  203.       drmInfos: [],
  204.       keyIds: streamDB.keyIds,
  205.       language: streamDB.language,
  206.       originalLanguage: streamDB.originalLanguage || null,
  207.       label: streamDB.label,
  208.       type: streamDB.type,
  209.       primary: streamDB.primary,
  210.       trickModeVideo: 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.     };
  228.     return stream;
  229.   }
  231.   /**
  232.    * @param {number} index
  233.    * @param {shaka.extern.SegmentDB} segmentDB
  234.    * @param {shaka.extern.StreamDB} streamDB
  235.    * @return {!shaka.media.SegmentReference}
  236.    * @private
  237.    */
  238.   fromSegmentDB_(index, segmentDB, streamDB) {
  239.     /** @type {!shaka.offline.OfflineUri} */
  240.     const uri = shaka.offline.OfflineUri.segment(
  241.         this.mechanism_, this.cell_, segmentDB.dataKey);
  243.     const initSegmentReference = segmentDB.initSegmentKey != null ?
  244.         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
  246.     const ref = new shaka.media.SegmentReference(
  247.         segmentDB.startTime,
  248.         segmentDB.endTime,
  249.         () => [uri.toString()],
  250.         /* startByte= */ 0,
  251.         /* endByte= */ null,
  252.         initSegmentReference,
  253.         segmentDB.timestampOffset,
  254.         segmentDB.appendWindowStart,
  255.         segmentDB.appendWindowEnd,
  256.         /* partialReferences= */ [],
  257.         segmentDB.tilesLayout || '');
  258.     ref.mimeType = segmentDB.mimeType || streamDB.mimeType || '';
  259.     ref.codecs = segmentDB.codecs || streamDB.codecs || '';
  260.     if (segmentDB.thumbnailSprite) {
  261.       ref.setThumbnailSprite(segmentDB.thumbnailSprite);
  262.     }
  263.     return ref;
  264.   }
  266.   /**
  267.    * @param {number} key
  268.    * @return {!shaka.media.InitSegmentReference}
  269.    * @private
  270.    */
  271.   fromInitSegmentDB_(key) {
  272.     /** @type {!shaka.offline.OfflineUri} */
  273.     const uri = shaka.offline.OfflineUri.segment(
  274.         this.mechanism_, this.cell_, key);
  276.     return new shaka.media.InitSegmentReference(
  277.         () => [uri.toString()],
  278.         /* startBytes= */ 0,
  279.         /* endBytes= */ null );
  280.   }
  282.   /**
  283.    * @param {shaka.extern.StreamDB} streamDB
  284.    * @return {boolean}
  285.    * @private
  286.    */
  287.   isAudio_(streamDB) {
  288.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  289.     return streamDB.type == ContentType.AUDIO;
  290.   }
  292.   /**
  293.    * @param {shaka.extern.StreamDB} streamDB
  294.    * @return {boolean}
  295.    * @private
  296.    */
  297.   isVideo_(streamDB) {
  298.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  299.     return streamDB.type == ContentType.VIDEO;
  300.   }
  302.   /**
  303.    * @param {shaka.extern.StreamDB} streamDB
  304.    * @return {boolean}
  305.    * @private
  306.    */
  307.   isText_(streamDB) {
  308.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  309.     return streamDB.type == ContentType.TEXT;
  310.   }
  312.   /**
  313.    * @param {shaka.extern.StreamDB} streamDB
  314.    * @return {boolean}
  315.    * @private
  316.    */
  317.   isImage_(streamDB) {
  318.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  319.     return streamDB.type == ContentType.IMAGE;
  320.   }
  322.   /**
  323.    * Creates an empty Variant.
  324.    *
  325.    * @param {number} id
  326.    * @return {!shaka.extern.Variant}
  327.    * @private
  328.    */
  329.   createEmptyVariant_(id) {
  330.     return {
  331.       id: id,
  332.       language: '',
  333.       disabledUntilTime: 0,
  334.       primary: false,
  335.       audio: null,
  336.       video: null,
  337.       bandwidth: 0,
  338.       allowedByApplication: true,
  339.       allowedByKeySystem: true,
  340.       decodingInfos: [],
  341.     };
  342.   }
  343. };