Source: lib/hls/hls_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  8. goog.provide('shaka.hls.HlsParser');
  10. goog.require('goog.Uri');
  11. goog.require('goog.asserts');
  12. goog.require('shaka.abr.Ewma');
  13. goog.require('shaka.hls.ManifestTextParser');
  14. goog.require('shaka.hls.Playlist');
  15. goog.require('shaka.hls.PlaylistType');
  16. goog.require('shaka.hls.Tag');
  17. goog.require('shaka.hls.Utils');
  18. goog.require('shaka.log');
  19. goog.require('shaka.media.DrmEngine');
  20. goog.require('shaka.media.InitSegmentReference');
  21. goog.require('shaka.media.ManifestParser');
  22. goog.require('shaka.media.PresentationTimeline');
  23. goog.require('shaka.media.SegmentIndex');
  24. goog.require('shaka.media.SegmentReference');
  25. goog.require('shaka.net.DataUriPlugin');
  26. goog.require('shaka.net.NetworkingEngine');
  27. goog.require('shaka.util.ArrayUtils');
  28. goog.require('shaka.util.BufferUtils');
  29. goog.require('shaka.util.ContentSteeringManager');
  30. goog.require('shaka.util.Error');
  31. goog.require('shaka.util.FakeEvent');
  32. goog.require('shaka.util.LanguageUtils');
  33. goog.require('shaka.util.ManifestParserUtils');
  34. goog.require('shaka.util.MimeUtils');
  35. goog.require('shaka.util.Networking');
  36. goog.require('shaka.util.OperationManager');
  37. goog.require('shaka.util.Pssh');
  38. goog.require('shaka.media.SegmentUtils');
  39. goog.require('shaka.util.Timer');
  40. goog.require('shaka.util.TXml');
  41. goog.require('shaka.util.Platform');
  42. goog.require('shaka.util.Uint8ArrayUtils');
  43. goog.requireType('shaka.hls.Segment');
  46. /**
  47.  * HLS parser.
  48.  *
  49.  * @implements {shaka.extern.ManifestParser}
  50.  * @export
  51.  */
  52. shaka.hls.HlsParser = class {
  53.   /**
  54.    * Creates an Hls Parser object.
  55.    */
  56.   constructor() {
  57.     /** @private {?shaka.extern.ManifestParser.PlayerInterface} */
  58.     this.playerInterface_ = null;
  60.     /** @private {?shaka.extern.ManifestConfiguration} */
  61.     this.config_ = null;
  63.     /** @private {number} */
  64.     this.globalId_ = 1;
  66.     /** @private {!Map.<string, string>} */
  67.     this.globalVariables_ = new Map();
  69.     /**
  70.      * A map from group id to stream infos created from the media tags.
  71.      * @private {!Map.<string, !Array.<?shaka.hls.HlsParser.StreamInfo>>}
  72.      */
  73.     this.groupIdToStreamInfosMap_ = new Map();
  75.     /**
  76.      * For media playlist lazy-loading to work in livestreams, we have to assume
  77.      * that each stream of a type (video, audio, etc) has the same mappings of
  78.      * sequence number to start time.
  79.      * This map stores those relationships.
  80.      * Only used during livestreams; we do not assume that VOD content is
  81.      * aligned in that way.
  82.      * @private {!Map.<string, !Map.<number, number>>}
  83.      */
  84.     this.mediaSequenceToStartTimeByType_ = new Map();
  86.     // Set initial maps.
  87.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  88.     this.mediaSequenceToStartTimeByType_.set(ContentType.VIDEO, new Map());
  89.     this.mediaSequenceToStartTimeByType_.set(ContentType.AUDIO, new Map());
  90.     this.mediaSequenceToStartTimeByType_.set(ContentType.TEXT, new Map());
  91.     this.mediaSequenceToStartTimeByType_.set(ContentType.IMAGE, new Map());
  93.     /**
  94.      * The values are strings of the form "<VIDEO URI> - <AUDIO URI>",
  95.      * where the URIs are the verbatim media playlist URIs as they appeared in
  96.      * the master playlist.
  97.      *
  98.      * Used to avoid duplicates that vary only in their text stream.
  99.      *
  100.      * @private {!Set.<string>}
  101.      */
  102.     this.variantUriSet_ = new Set();
  104.     /**
  105.      * A map from (verbatim) media playlist URI to stream infos representing the
  106.      * playlists.
  107.      *
  108.      * On update, used to iterate through and update from media playlists.
  109.      *
  110.      * On initial parse, used to iterate through and determine minimum
  111.      * timestamps, offsets, and to handle TS rollover.
  112.      *
  113.      * During parsing, used to avoid duplicates in the async methods
  114.      * createStreamInfoFromMediaTags_, createStreamInfoFromImageTag_ and
  115.      * createStreamInfoFromVariantTags_.
  116.      *
  117.      * @private {!Map.<string, shaka.hls.HlsParser.StreamInfo>}
  118.      */
  119.     this.uriToStreamInfosMap_ = new Map();
  121.     /** @private {?shaka.media.PresentationTimeline} */
  122.     this.presentationTimeline_ = null;
  124.     /**
  125.      * The master playlist URI, after redirects.
  126.      *
  127.      * @private {string}
  128.      */
  129.     this.masterPlaylistUri_ = '';
  131.     /** @private {shaka.hls.ManifestTextParser} */
  132.     this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
  134.     /**
  135.      * The minimum sequence number for generated segments, when ignoring
  136.      * EXT-X-PROGRAM-DATE-TIME.
  137.      *
  138.      * @private {number}
  139.      */
  140.     this.minSequenceNumber_ = -1;
  142.     /**
  143.      * The lowest time value for any of the streams, as defined by the
  144.      * EXT-X-PROGRAM-DATE-TIME value. Measured in seconds since January 1, 1970.
  145.      *
  146.      * @private {number}
  147.      */
  148.     this.lowestSyncTime_ = Infinity;
  150.     /**
  151.      * Whether the streams have previously been "finalized"; that is to say,
  152.      * whether we have loaded enough streams to know information about the asset
  153.      * such as timing information, live status, etc.
  154.      *
  155.      * @private {boolean}
  156.      */
  157.     this.streamsFinalized_ = false;
  159.     /**
  160.      * Whether the manifest informs about the codec to use.
  161.      *
  162.      * @private
  163.      */
  164.     this.codecInfoInManifest_ = false;
  166.     /**
  167.      * This timer is used to trigger the start of a manifest update. A manifest
  168.      * update is async. Once the update is finished, the timer will be restarted
  169.      * to trigger the next update. The timer will only be started if the content
  170.      * is live content.
  171.      *
  172.      * @private {shaka.util.Timer}
  173.      */
  174.     this.updatePlaylistTimer_ = new shaka.util.Timer(() => {
  175.       this.onUpdate_();
  176.     });
  178.     /** @private {shaka.hls.HlsParser.PresentationType_} */
  179.     this.presentationType_ = shaka.hls.HlsParser.PresentationType_.VOD;
  181.     /** @private {?shaka.extern.Manifest} */
  182.     this.manifest_ = null;
  184.     /** @private {number} */
  185.     this.maxTargetDuration_ = 0;
  187.     /** @private {number} */
  188.     this.lastTargetDuration_ = Infinity;
  190.     /** Partial segments target duration.
  191.      * @private {number}
  192.      */
  193.     this.partialTargetDuration_ = 0;
  195.     /** @private {number} */
  196.     this.presentationDelay_ = 0;
  198.     /** @private {number} */
  199.     this.lowLatencyPresentationDelay_ = 0;
  201.     /** @private {shaka.util.OperationManager} */
  202.     this.operationManager_ = new shaka.util.OperationManager();
  204.     /** A map from closed captions' group id, to a map of closed captions info.
  205.      * {group id -> {closed captions channel id -> language}}
  206.      * @private {Map.<string, Map.<string, string>>}
  207.      */
  208.     this.groupIdToClosedCaptionsMap_ = new Map();
  210.     /** @private {Map.<string, string>} */
  211.     this.groupIdToCodecsMap_ = new Map();
  213.     /** A cache mapping EXT-X-MAP tag info to the InitSegmentReference created
  214.      * from the tag.
  215.      * The key is a string combining the EXT-X-MAP tag's absolute uri, and
  216.      * its BYTERANGE if available.
  217.      * {!Map.<string, !shaka.media.InitSegmentReference>} */
  218.     this.mapTagToInitSegmentRefMap_ = new Map();
  220.     /** @private {Map.<string, !shaka.extern.aesKey>} */
  221.     this.aesKeyInfoMap_ = new Map();
  223.     /** @private {Map.<string, !Promise.<shaka.extern.Response>>} */
  224.     this.aesKeyMap_ = new Map();
  226.     /** @private {Map.<string, !Promise.<shaka.extern.Response>>} */
  227.     this.identityKeyMap_ = new Map();
  229.     /** @private {Map.<!shaka.media.InitSegmentReference, ?string>} */
  230.     this.identityKidMap_ = new Map();
  232.     /** @private {boolean} */
  233.     this.lowLatencyMode_ = false;
  235.     /** @private {boolean} */
  236.     this.lowLatencyByterangeOptimization_ = false;
  238.     /**
  239.      * An ewma that tracks how long updates take.
  240.      * This is to mitigate issues caused by slow parsing on embedded devices.
  241.      * @private {!shaka.abr.Ewma}
  242.      */
  243.     this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
  245.     /** @private {?shaka.util.ContentSteeringManager} */
  246.     this.contentSteeringManager_ = null;
  247.   }
  250.   /**
  251.    * @override
  252.    * @exportInterface
  253.    */
  254.   configure(config) {
  255.     this.config_ = config;
  257.     if (this.contentSteeringManager_) {
  258.       this.contentSteeringManager_.configure(this.config_);
  259.     }
  260.   }
  262.   /**
  263.    * @override
  264.    * @exportInterface
  265.    */
  266.   async start(uri, playerInterface) {
  267.     goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  268.     this.playerInterface_ = playerInterface;
  269.     this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
  271.     const response = await this.requestManifest_([uri]);
  273.     // Record the master playlist URI after redirects.
  274.     this.masterPlaylistUri_ = response.uri;
  276.     goog.asserts.assert(response.data, 'Response data should be non-null!');
  277.     await this.parseManifest_(response.data, uri);
  279.     goog.asserts.assert(this.manifest_, 'Manifest should be non-null');
  280.     return this.manifest_;
  281.   }
  283.   /**
  284.    * @override
  285.    * @exportInterface
  286.    */
  287.   stop() {
  288.     // Make sure we don't update the manifest again. Even if the timer is not
  289.     // running, this is safe to call.
  290.     if (this.updatePlaylistTimer_) {
  291.       this.updatePlaylistTimer_.stop();
  292.       this.updatePlaylistTimer_ = null;
  293.     }
  295.     /** @type {!Array.<!Promise>} */
  296.     const pending = [];
  298.     if (this.operationManager_) {
  299.       pending.push(this.operationManager_.destroy());
  300.       this.operationManager_ = null;
  301.     }
  303.     this.playerInterface_ = null;
  304.     this.config_ = null;
  305.     this.variantUriSet_.clear();
  306.     this.manifest_ = null;
  307.     this.uriToStreamInfosMap_.clear();
  308.     this.groupIdToStreamInfosMap_.clear();
  309.     this.groupIdToCodecsMap_.clear();
  310.     this.globalVariables_.clear();
  311.     this.mapTagToInitSegmentRefMap_.clear();
  312.     this.aesKeyInfoMap_.clear();
  313.     this.aesKeyMap_.clear();
  314.     this.identityKeyMap_.clear();
  315.     this.identityKidMap_.clear();
  317.     if (this.contentSteeringManager_) {
  318.       this.contentSteeringManager_.destroy();
  319.     }
  321.     return Promise.all(pending);
  322.   }
  324.   /**
  325.    * @override
  326.    * @exportInterface
  327.    */
  328.   async update() {
  329.     if (!this.isLive_()) {
  330.       return;
  331.     }
  333.     /** @type {!Array.<!Promise>} */
  334.     const updates = [];
  335.     const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  337.     // This is necessary to calculate correctly the update time.
  338.     this.lastTargetDuration_ = Infinity;
  340.     // Only update active streams.
  341.     const activeStreamInfos = streamInfos.filter((s) => s.stream.segmentIndex);
  342.     for (const streamInfo of activeStreamInfos) {
  343.       updates.push(this.updateStream_(streamInfo));
  344.     }
  345.     await Promise.all(updates);
  347.     // Now that streams have been updated, notify the presentation timeline.
  348.     this.notifySegmentsForStreams_(activeStreamInfos.map((s) => s.stream));
  350.     // If any hasEndList is false, the stream is still live.
  351.     const stillLive = activeStreamInfos.some((s) => s.hasEndList == false);
  352.     if (activeStreamInfos.length && !stillLive) {
  353.       // Convert the presentation to VOD and set the duration.
  354.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  355.       this.setPresentationType_(PresentationType.VOD);
  357.       // The duration is the minimum of the end times of all active streams.
  358.       // Non-active streams are not guaranteed to have useful maxTimestamp
  359.       // values, due to the lazy-loading system, so they are ignored.
  360.       const maxTimestamps = activeStreamInfos.map((s) => s.maxTimestamp);
  361.       // The duration is the minimum of the end times of all streams.
  362.       this.presentationTimeline_.setDuration(Math.min(...maxTimestamps));
  363.       this.playerInterface_.updateDuration();
  364.     }
  365.     if (stillLive) {
  366.       this.determineDuration_();
  367.     }
  368.   }
  370.   /**
  371.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  372.    * @return {!Map.<number, number>}
  373.    * @private
  374.    */
  375.   getMediaSequenceToStartTimeFor_(streamInfo) {
  376.     if (this.isLive_()) {
  377.       return this.mediaSequenceToStartTimeByType_.get(streamInfo.type);
  378.     } else {
  379.       return streamInfo.mediaSequenceToStartTime;
  380.     }
  381.   }
  383.   /**
  384.    * Updates a stream.
  385.    *
  386.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  387.    * @return {!Promise}
  388.    * @private
  389.    */
  390.   async updateStream_(streamInfo) {
  391.     const manifestUris = [];
  392.     for (const uri of streamInfo.getUris()) {
  393.       const uriObj = new goog.Uri(uri);
  394.       const queryData = uriObj.getQueryData();
  395.       if (streamInfo.canBlockReload) {
  396.         if (streamInfo.nextMediaSequence >= 0) {
  397.           // Indicates that the server must hold the request until a Playlist
  398.           // contains a Media Segment with Media Sequence
  399.           queryData.add('_HLS_msn', String(streamInfo.nextMediaSequence));
  400.         }
  401.         if (streamInfo.nextPart >= 0) {
  402.           // Indicates, in combination with _HLS_msn, that the server must hold
  403.           // the request until a Playlist contains Partial Segment N of Media
  404.           // Sequence Number M or later.
  405.           queryData.add('_HLS_part', String(streamInfo.nextPart));
  406.         }
  407.       }
  408.       if (streamInfo.canSkipSegments) {
  409.         // Enable delta updates. This will replace older segments with
  410.         // 'EXT-X-SKIP' tag in the media playlist.
  411.         queryData.add('_HLS_skip', 'YES');
  412.       }
  413.       if (queryData.getCount()) {
  414.         uriObj.setQueryData(queryData);
  415.       }
  416.       manifestUris.push(uriObj.toString());
  417.     }
  418.     const response =
  419.         await this.requestManifest_(manifestUris, /* isPlaylist= */ true);
  420.     if (!streamInfo.stream.segmentIndex) {
  421.       // The stream was closed since the update was first requested.
  422.       return;
  423.     }
  425.     /** @type {shaka.hls.Playlist} */
  426.     const playlist = this.manifestTextParser_.parsePlaylist(response.data);
  428.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  429.       throw new shaka.util.Error(
  430.           shaka.util.Error.Severity.CRITICAL,
  431.           shaka.util.Error.Category.MANIFEST,
  432.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  433.     }
  435.     // Record the final URI after redirects.
  436.     const responseUri = response.uri;
  437.     if (responseUri != response.originalUri &&
  438.         !streamInfo.getUris().includes(responseUri)) {
  439.       streamInfo.redirectUris.push(responseUri);
  440.     }
  442.     /** @type {!Array.<!shaka.hls.Tag>} */
  443.     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  444.         'EXT-X-DEFINE');
  446.     const mediaVariables = this.parseMediaVariables_(
  447.         variablesTags, responseUri);
  449.     const stream = streamInfo.stream;
  451.     const mediaSequenceToStartTime =
  452.         this.getMediaSequenceToStartTimeFor_(streamInfo);
  453.     const {keyIds, drmInfos} = await this.parseDrmInfo_(
  454.         playlist, stream.mimeType, streamInfo.getUris, mediaVariables);
  456.     const keysAreEqual =
  457.       (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
  459.     if (!keysAreEqual(stream.keyIds, keyIds)) {
  460.       stream.keyIds = keyIds;
  461.       stream.drmInfos = drmInfos;
  462.       this.playerInterface_.newDrmInfo(stream);
  463.     }
  465.     const {segments, bandwidth} = this.createSegments_(
  466.         playlist, stream, mediaSequenceToStartTime, mediaVariables,
  467.         streamInfo.getUris, streamInfo.type);
  468.     if (bandwidth) {
  469.       stream.bandwidth = bandwidth;
  470.     }
  472.     stream.segmentIndex.mergeAndEvict(
  473.         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
  474.     if (segments.length) {
  475.       const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  476.           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  477.       const skipTag = shaka.hls.Utils.getFirstTagWithName(
  478.           playlist.tags, 'EXT-X-SKIP');
  479.       const skippedSegments =
  480.           skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
  481.       const {nextMediaSequence, nextPart} =
  482.           this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
  483.       streamInfo.nextMediaSequence = nextMediaSequence + skippedSegments;
  484.       streamInfo.nextPart = nextPart;
  485.       const playlistStartTime = mediaSequenceToStartTime.get(
  486.           mediaSequenceNumber);
  487.       stream.segmentIndex.evict(playlistStartTime);
  488.     }
  489.     const oldSegment = stream.segmentIndex.earliestReference();
  490.     goog.asserts.assert(oldSegment, 'Should have segments!');
  492.     streamInfo.minTimestamp = oldSegment.startTime;
  494.     const newestSegment = segments[segments.length - 1];
  495.     goog.asserts.assert(newestSegment, 'Should have segments!');
  497.     streamInfo.maxTimestamp = newestSegment.endTime;
  499.     // Once the last segment has been added to the playlist,
  500.     // #EXT-X-ENDLIST tag will be appended.
  501.     // If that happened, treat the rest of the EVENT presentation as VOD.
  502.     const endListTag =
  503.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  505.     if (endListTag) {
  506.       // Flag this for later.  We don't convert the whole presentation into VOD
  507.       // until we've seen the ENDLIST tag for all active playlists.
  508.       streamInfo.hasEndList = true;
  509.     }
  511.     this.determineLastTargetDuration_(playlist);
  512.   }
  515.   /**
  516.    * @override
  517.    * @exportInterface
  518.    */
  519.   onExpirationUpdated(sessionId, expiration) {
  520.     // No-op
  521.   }
  523.   /**
  524.    * @override
  525.    * @exportInterface
  526.    */
  527.   onInitialVariantChosen(variant) {
  528.     // No-op
  529.   }
  531.   /**
  532.    * @override
  533.    * @exportInterface
  534.    */
  535.   banLocation(uri) {
  536.     if (this.contentSteeringManager_) {
  537.       this.contentSteeringManager_.banLocation(uri);
  538.     }
  539.   }
  541.   /**
  542.    * Align the streams by sequence number by dropping early segments.  Then
  543.    * offset the streams to begin at presentation time 0.
  544.    * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  545.    * @private
  546.    */
  547.   syncStreamsWithSequenceNumber_(streamInfos) {
  548.     // We assume that, when this is first called, we have enough info to
  549.     // determine how to use the program date times (e.g. we have both a video
  550.     // and an audio, and all other videos and audios match those).
  551.     // Thus, we only need to calculate this once.
  552.     const updateMinSequenceNumber = this.minSequenceNumber_ == -1;
  553.     // Sync using media sequence number.  Find the highest starting sequence
  554.     // number among all streams.  Later, we will drop any references to
  555.     // earlier segments in other streams, then offset everything back to 0.
  556.     for (const streamInfo of streamInfos) {
  557.       const segmentIndex = streamInfo.stream.segmentIndex;
  558.       goog.asserts.assert(segmentIndex,
  559.           'Only loaded streams should be synced');
  560.       const mediaSequenceToStartTime =
  561.           this.getMediaSequenceToStartTimeFor_(streamInfo);
  562.       const segment0 = segmentIndex.earliestReference();
  563.       if (segment0) {
  564.         // This looks inefficient, but iteration order is insertion order.
  565.         // So the very first entry should be the one we want.
  566.         // We assert that this holds true so that we are alerted by debug
  567.         // builds and tests if it changes.  We still do a loop, though, so
  568.         // that the code functions correctly in production no matter what.
  569.         if (goog.DEBUG) {
  570.           const firstSequenceStartTime =
  571.               mediaSequenceToStartTime.values().next().value;
  572.           shaka.log.warning(
  573.               firstSequenceStartTime == segment0.startTime,
  574.               'Sequence number map is not ordered as expected!');
  575.         }
  576.         for (const [sequence, start] of mediaSequenceToStartTime) {
  577.           if (start == segment0.startTime) {
  578.             if (updateMinSequenceNumber) {
  579.               this.minSequenceNumber_ = Math.max(
  580.                   this.minSequenceNumber_, sequence);
  581.             }
  582.             // Even if we already have decided on a value for
  583.             // |this.minSequenceNumber_|, we still need to determine the first
  584.             // sequence number for the stream, to offset it in the code below.
  585.             streamInfo.firstSequenceNumber = sequence;
  586.             break;
  587.           }
  588.         }
  589.       }
  590.     }
  592.     if (this.minSequenceNumber_ < 0) {
  593.       // Nothing to sync.
  594.       return;
  595.     }
  597.     shaka.log.debug('Syncing HLS streams against base sequence number:',
  598.         this.minSequenceNumber_);
  600.     for (const streamInfo of streamInfos) {
  601.       if (!this.ignoreManifestProgramDateTimeFor_(streamInfo.type)) {
  602.         continue;
  603.       }
  604.       const segmentIndex = streamInfo.stream.segmentIndex;
  605.       if (segmentIndex) {
  606.         // Drop any earlier references.
  607.         const numSegmentsToDrop =
  608.             this.minSequenceNumber_ - streamInfo.firstSequenceNumber;
  609.         if (numSegmentsToDrop > 0) {
  610.           segmentIndex.dropFirstReferences(numSegmentsToDrop);
  612.           // Now adjust timestamps back to begin at 0.
  613.           const segmentN = segmentIndex.earliestReference();
  614.           if (segmentN) {
  615.             const streamOffset = -segmentN.startTime;
  616.             // Modify all SegmentReferences equally.
  617.             streamInfo.stream.segmentIndex.offset(streamOffset);
  618.             // Update other parts of streamInfo the same way.
  619.             this.offsetStreamInfo_(streamInfo, streamOffset);
  620.           }
  621.         }
  622.       }
  623.     }
  624.   }
  626.   /**
  627.    * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
  628.    * segments.  Also normalizes segment times so that the earliest segment in
  629.    * any stream is at time 0.
  630.    * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  631.    * @private
  632.    */
  633.   syncStreamsWithProgramDateTime_(streamInfos) {
  634.     // We assume that, when this is first called, we have enough info to
  635.     // determine how to use the program date times (e.g. we have both a video
  636.     // and an audio, and all other videos and audios match those).
  637.     // Thus, we only need to calculate this once.
  638.     if (this.lowestSyncTime_ == Infinity) {
  639.       for (const streamInfo of streamInfos) {
  640.         const segmentIndex = streamInfo.stream.segmentIndex;
  641.         goog.asserts.assert(segmentIndex,
  642.             'Only loaded streams should be synced');
  643.         const segment0 = segmentIndex.earliestReference();
  644.         if (segment0 != null && segment0.syncTime != null) {
  645.           this.lowestSyncTime_ =
  646.               Math.min(this.lowestSyncTime_, segment0.syncTime);
  647.         }
  648.       }
  649.     }
  651.     const lowestSyncTime = this.lowestSyncTime_;
  652.     if (lowestSyncTime == Infinity) {
  653.       // Nothing to sync.
  654.       return;
  655.     }
  657.     shaka.log.debug('Syncing HLS streams against base time:', lowestSyncTime);
  659.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  660.       if (this.ignoreManifestProgramDateTimeFor_(streamInfo.type)) {
  661.         continue;
  662.       }
  663.       const segmentIndex = streamInfo.stream.segmentIndex;
  664.       if (segmentIndex != null) {
  665.         // A segment's startTime should be based on its syncTime vs the lowest
  666.         // syncTime across all streams.  The earliest segment sync time from
  667.         // any stream will become presentation time 0.  If two streams start
  668.         // e.g. 6 seconds apart in syncTime, then their first segments will
  669.         // also start 6 seconds apart in presentation time.
  671.         const segment0 = segmentIndex.earliestReference();
  672.         if (segment0.syncTime == null) {
  673.           shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
  674.               streamInfo.getUris(),
  675.               'Expect AV sync issues!');
  676.         } else {
  677.           // Stream metadata are offset by a fixed amount based on the
  678.           // first segment.
  679.           const segment0TargetTime = segment0.syncTime - lowestSyncTime;
  680.           const streamOffset = segment0TargetTime - segment0.startTime;
  681.           this.offsetStreamInfo_(streamInfo, streamOffset);
  683.           // This is computed across all segments separately to manage
  684.           // accumulated drift in durations.
  685.           for (const segment of segmentIndex) {
  686.             segment.syncAgainst(lowestSyncTime);
  687.           }
  688.         }
  689.       }
  690.     }
  691.   }
  693.   /**
  694.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  695.    * @param {number} offset
  696.    * @private
  697.    */
  698.   offsetStreamInfo_(streamInfo, offset) {
  699.     // Adjust our accounting of the minimum timestamp.
  700.     streamInfo.minTimestamp += offset;
  702.     // Adjust our accounting of the maximum timestamp.
  703.     streamInfo.maxTimestamp += offset;
  704.     goog.asserts.assert(streamInfo.maxTimestamp >= 0,
  705.         'Negative maxTimestamp after adjustment!');
  707.     // Update our map from sequence number to start time.
  708.     const mediaSequenceToStartTime =
  709.         this.getMediaSequenceToStartTimeFor_(streamInfo);
  710.     for (const [key, value] of mediaSequenceToStartTime) {
  711.       mediaSequenceToStartTime.set(key, value + offset);
  712.     }
  714.     shaka.log.debug('Offset', offset, 'applied to',
  715.         streamInfo.getUris());
  716.   }
  718.   /**
  719.    * Parses the manifest.
  720.    *
  721.    * @param {BufferSource} data
  722.    * @param {string} uri
  723.    * @return {!Promise}
  724.    * @private
  725.    */
  726.   async parseManifest_(data, uri) {
  727.     const Utils = shaka.hls.Utils;
  729.     goog.asserts.assert(this.masterPlaylistUri_,
  730.         'Master playlist URI must be set before calling parseManifest_!');
  732.     const playlist = this.manifestTextParser_.parsePlaylist(data);
  734.     /** @type {!Array.<!shaka.hls.Tag>} */
  735.     const variablesTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-DEFINE');
  737.     /** @type {!Array.<!shaka.extern.Variant>} */
  738.     let variants = [];
  739.     /** @type {!Array.<!shaka.extern.Stream>} */
  740.     let textStreams = [];
  741.     /** @type {!Array.<!shaka.extern.Stream>} */
  742.     let imageStreams = [];
  744.     // This assert is our own sanity check.
  745.     goog.asserts.assert(this.presentationTimeline_ == null,
  746.         'Presentation timeline created early!');
  747.     // We don't know if the presentation is VOD or live until we parse at least
  748.     // one media playlist, so make a VOD-style presentation timeline for now
  749.     // and change the type later if we discover this is live.
  750.     // Since the player will load the first variant chosen early in the process,
  751.     // there isn't a window during playback where the live-ness is unknown.
  752.     this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  753.         /* presentationStartTime= */ null, /* delay= */ 0);
  754.     this.presentationTimeline_.setStatic(true);
  756.     const getUris = () => {
  757.       return [uri];
  758.     };
  760.     // Parsing a media playlist results in a single-variant stream.
  761.     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
  762.       // Get necessary info for this stream. These are things we would normally
  763.       // find from the master playlist (e.g. from values on EXT-X-MEDIA tags).
  764.       const basicInfo =
  765.           await this.getMediaPlaylistBasicInfo_(playlist, getUris);
  766.       const type = basicInfo.type;
  767.       const mimeType = basicInfo.mimeType;
  768.       const codecs = basicInfo.codecs;
  769.       const languageValue = basicInfo.language;
  770.       const height = basicInfo.height;
  771.       const width = basicInfo.width;
  772.       const channelsCount = basicInfo.channelCount;
  773.       const sampleRate = basicInfo.sampleRate;
  774.       const closedCaptions = basicInfo.closedCaptions;
  775.       const videoRange = basicInfo.videoRange;
  777.       // Some values we cannot figure out, and aren't important enough to ask
  778.       // the user to provide through config values. A lot of these are only
  779.       // relevant to ABR, which isn't necessary if there's only one variant.
  780.       // So these unknowns should be set to false or null, largely.
  781.       const spatialAudio = false;
  782.       const characteristics = null;
  783.       const forced = false; // Only relevant for text.
  784.       const primary = true; // This is the only stream!
  785.       const name = 'Media Playlist';
  787.       // Make the stream info, with those values.
  788.       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
  789.           this.globalId_++, playlist, getUris, uri, codecs, type,
  790.           languageValue, primary, name, channelsCount, closedCaptions,
  791.           characteristics, forced, sampleRate, spatialAudio, mimeType);
  792.       this.uriToStreamInfosMap_.set(uri, streamInfo);
  794.       if (type == 'video') {
  795.         this.addVideoAttributes_(streamInfo.stream, width, height,
  796.             /* frameRate= */ null, videoRange, /* videoLayout= */ null);
  797.       }
  799.       // Wrap the stream from that stream info with a variant.
  800.       variants.push({
  801.         id: 0,
  802.         language: this.getLanguage_(languageValue),
  803.         disabledUntilTime: 0,
  804.         primary: true,
  805.         audio: type == 'audio' ? streamInfo.stream : null,
  806.         video: type == 'video' ? streamInfo.stream : null,
  807.         bandwidth: streamInfo.stream.bandwidth || 0,
  808.         allowedByApplication: true,
  809.         allowedByKeySystem: true,
  810.         decodingInfos: [],
  811.       });
  812.     } else {
  813.       this.parseMasterVariables_(variablesTags);
  815.       /** @type {!Array.<!shaka.hls.Tag>} */
  816.       const mediaTags = Utils.filterTagsByName(
  817.           playlist.tags, 'EXT-X-MEDIA');
  818.       /** @type {!Array.<!shaka.hls.Tag>} */
  819.       const variantTags = Utils.filterTagsByName(
  820.           playlist.tags, 'EXT-X-STREAM-INF');
  821.       /** @type {!Array.<!shaka.hls.Tag>} */
  822.       const imageTags = Utils.filterTagsByName(
  823.           playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
  824.       /** @type {!Array.<!shaka.hls.Tag>} */
  825.       const iFrameTags = Utils.filterTagsByName(
  826.           playlist.tags, 'EXT-X-I-FRAME-STREAM-INF');
  827.       /** @type {!Array.<!shaka.hls.Tag>} */
  828.       const sessionKeyTags = Utils.filterTagsByName(
  829.           playlist.tags, 'EXT-X-SESSION-KEY');
  830.       /** @type {!Array.<!shaka.hls.Tag>} */
  831.       const sessionDataTags = Utils.filterTagsByName(
  832.           playlist.tags, 'EXT-X-SESSION-DATA');
  833.       /** @type {!Array.<!shaka.hls.Tag>} */
  834.       const contentSteeringTags = Utils.filterTagsByName(
  835.           playlist.tags, 'EXT-X-CONTENT-STEERING');
  837.       this.processSessionData_(sessionDataTags);
  838.       await this.processContentSteering_(contentSteeringTags);
  840.       this.parseCodecs_(variantTags);
  842.       this.parseClosedCaptions_(mediaTags);
  843.       variants = await this.createVariantsForTags_(
  844.           variantTags, sessionKeyTags, mediaTags, getUris,
  845.           this.globalVariables_);
  846.       textStreams = this.parseTexts_(mediaTags);
  847.       imageStreams = await this.parseImages_(imageTags, iFrameTags);
  848.     }
  850.     // Make sure that the parser has not been destroyed.
  851.     if (!this.playerInterface_) {
  852.       throw new shaka.util.Error(
  853.           shaka.util.Error.Severity.CRITICAL,
  854.           shaka.util.Error.Category.PLAYER,
  855.           shaka.util.Error.Code.OPERATION_ABORTED);
  856.     }
  858.     // Single-variant streams aren't lazy-loaded, so for them we already have
  859.     // enough info here to determine the presentation type and duration.
  860.     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
  861.       if (this.isLive_()) {
  862.         this.changePresentationTimelineToLive_(playlist);
  863.         const delay = this.getUpdatePlaylistDelay_();
  864.         this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
  865.       }
  866.       const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  867.       this.finalizeStreams_(streamInfos);
  868.       this.determineDuration_();
  869.     }
  871.     this.manifest_ = {
  872.       presentationTimeline: this.presentationTimeline_,
  873.       variants,
  874.       textStreams,
  875.       imageStreams,
  876.       offlineSessionIds: [],
  877.       minBufferTime: 0,
  878.       sequenceMode: this.config_.hls.sequenceMode,
  879.       ignoreManifestTimestampsInSegmentsMode:
  880.         this.config_.hls.ignoreManifestTimestampsInSegmentsMode,
  881.       type: shaka.media.ManifestParser.HLS,
  882.       serviceDescription: null,
  883.     };
  885.     // If there is no 'CODECS' attribute in the manifest and codec guessing is
  886.     // disabled, we need to create the segment indexes now so that missing info
  887.     // can be parsed from the media data and added to the stream objects.
  888.     if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
  889.       const createIndexes = [];
  890.       for (const variant of this.manifest_.variants) {
  891.         if (variant.audio && variant.audio.codecs === '') {
  892.           createIndexes.push(variant.audio.createSegmentIndex());
  893.         }
  894.         if (variant.video && variant.video.codecs === '') {
  895.           createIndexes.push(variant.video.createSegmentIndex());
  896.         }
  897.       }
  899.       await Promise.all(createIndexes);
  900.     }
  902.     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
  904.     if (variants.length == 1) {
  905.       const createSegmentIndexPromises = [];
  906.       const variant = variants[0];
  907.       for (const stream of [variant.video, variant.audio]) {
  908.         if (stream && !stream.segmentIndex) {
  909.           createSegmentIndexPromises.push(stream.createSegmentIndex());
  910.         }
  911.       }
  912.       if (createSegmentIndexPromises.length > 0) {
  913.         await Promise.all(createSegmentIndexPromises);
  914.       }
  915.     }
  916.   }
  918.   /**
  919.    * @param {shaka.hls.Playlist} playlist
  920.    * @param {function():!Array.<string>} getUris
  921.    * @return {!Promise.<shaka.media.SegmentUtils.BasicInfo>}
  922.    * @private
  923.    */
  924.   async getMediaPlaylistBasicInfo_(playlist, getUris) {
  925.     const HlsParser = shaka.hls.HlsParser;
  926.     const defaultBasicInfo = shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  927.         this.config_.hls.mediaPlaylistFullMimeType);
  928.     if (!playlist.segments.length) {
  929.       return defaultBasicInfo;
  930.     }
  931.     const firstSegment = playlist.segments[0];
  932.     const firstSegmentUris = shaka.hls.Utils.constructSegmentUris(
  933.         getUris(),
  934.         firstSegment.verbatimSegmentUri);
  935.     const firstSegmentUri = firstSegmentUris[0];
  936.     const parsedUri = new goog.Uri(firstSegmentUri);
  937.     const extension = parsedUri.getPath().split('.').pop();
  938.     const rawMimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
  939.     if (rawMimeType) {
  940.       return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  941.           rawMimeType);
  942.     }
  944.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  946.     let initData = null;
  947.     const initSegmentRef = this.getInitSegmentReference_(
  948.         playlist, firstSegment.tags, getUris);
  949.     this.mapTagToInitSegmentRefMap_.clear();
  950.     if (initSegmentRef) {
  951.       const initSegmentRequest = shaka.util.Networking.createSegmentRequest(
  952.           initSegmentRef.getUris(),
  953.           initSegmentRef.getStartByte(),
  954.           initSegmentRef.getEndByte(),
  955.           this.config_.retryParameters);
  956.       const initType =
  957.           shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
  958.       const initResponse = await this.makeNetworkRequest_(
  959.           initSegmentRequest, requestType, {type: initType});
  960.       initData = initResponse.data;
  961.     }
  963.     let startByte = 0;
  964.     let endByte = null;
  965.     const byterangeTag = shaka.hls.Utils.getFirstTagWithName(
  966.         firstSegment.tags, 'EXT-X-BYTERANGE');
  967.     if (byterangeTag) {
  968.       [startByte, endByte] = this.parseByteRange_(
  969.           /* previousReference= */ null, byterangeTag.value);
  970.     }
  972.     const segmentRequest = shaka.util.Networking.createSegmentRequest(
  973.         firstSegmentUris, startByte, endByte, this.config_.retryParameters);
  974.     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
  975.     const response = await this.makeNetworkRequest_(
  976.         segmentRequest, requestType, {type});
  978.     let contentMimeType = response.headers['content-type'];
  979.     if (contentMimeType) {
  980.       // Split the MIME type in case the server sent additional parameters.
  981.       contentMimeType = contentMimeType.split(';')[0].toLowerCase();
  982.     }
  984.     if (extension == 'ts' || contentMimeType == 'video/mp2t') {
  985.       const basicInfo =
  986.           shaka.media.SegmentUtils.getBasicInfoFromTs(response.data);
  987.       if (basicInfo) {
  988.         return basicInfo;
  989.       }
  990.     } else if (extension == 'mp4' || extension == 'cmfv' ||
  991.         extension == 'm4s' || extension == 'fmp4' ||
  992.         contentMimeType == 'video/mp4' ||
  993.         contentMimeType == 'audio/mp4' ||
  994.         contentMimeType == 'video/iso.segment') {
  995.       const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromMp4(
  996.           initData, response.data);
  997.       if (basicInfo) {
  998.         return basicInfo;
  999.       }
  1000.     }
  1001.     return defaultBasicInfo;
  1002.   }
  1004.   /** @private */
  1005.   determineDuration_() {
  1006.     goog.asserts.assert(this.presentationTimeline_,
  1007.         'Presentation timeline not created!');
  1009.     if (this.isLive_()) {
  1010.       // The spec says nothing much about seeking in live content, but Safari's
  1011.       // built-in HLS implementation does not allow it.  Therefore we will set
  1012.       // the availability window equal to the presentation delay.  The player
  1013.       // will be able to buffer ahead three segments, but the seek window will
  1014.       // be zero-sized.
  1015.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  1017.       if (this.presentationType_ == PresentationType.LIVE) {
  1018.         let segmentAvailabilityDuration = this.getLiveDuration_();
  1020.         // This defaults to the presentation delay, which has the effect of
  1021.         // making the live stream unseekable.  This is consistent with Apple's
  1022.         // HLS implementation.
  1023.         if (this.config_.hls.useSafariBehaviorForLive) {
  1024.           segmentAvailabilityDuration = this.presentationTimeline_.getDelay();
  1025.         }
  1027.         // The app can override that with a longer duration, to allow seeking.
  1028.         if (!isNaN(this.config_.availabilityWindowOverride)) {
  1029.           segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
  1030.         }
  1032.         this.presentationTimeline_.setSegmentAvailabilityDuration(
  1033.             segmentAvailabilityDuration);
  1034.       }
  1035.     } else {
  1036.       // Use the minimum duration as the presentation duration.
  1037.       this.presentationTimeline_.setDuration(this.getMinDuration_());
  1038.     }
  1040.     if (!this.presentationTimeline_.isStartTimeLocked()) {
  1041.       for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  1042.         if (!streamInfo.stream.segmentIndex) {
  1043.           continue; // Not active.
  1044.         }
  1045.         if (streamInfo.type != 'audio' && streamInfo.type != 'video') {
  1046.           continue;
  1047.         }
  1048.         const firstReference = streamInfo.stream.segmentIndex.get(0);
  1049.         if (firstReference && firstReference.syncTime) {
  1050.           const syncTime = firstReference.syncTime;
  1051.           this.presentationTimeline_.setInitialProgramDateTime(syncTime);
  1052.         }
  1053.       }
  1054.     }
  1056.     // This is the first point where we have a meaningful presentation start
  1057.     // time, and we need to tell PresentationTimeline that so that it can
  1058.     // maintain consistency from here on.
  1059.     this.presentationTimeline_.lockStartTime();
  1061.     // This asserts that the live edge is being calculated from segment times.
  1062.     // For VOD and event streams, this check should still pass.
  1063.     goog.asserts.assert(
  1064.         !this.presentationTimeline_.usingPresentationStartTime(),
  1065.         'We should not be using the presentation start time in HLS!');
  1066.   }
  1068.   /**
  1069.    * Get the variables of each variant tag, and store in a map.
  1070.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1071.    * @private
  1072.    */
  1073.   parseMasterVariables_(tags) {
  1074.     const queryParams = new goog.Uri(this.masterPlaylistUri_).getQueryData();
  1075.     for (const variableTag of tags) {
  1076.       const name = variableTag.getAttributeValue('NAME');
  1077.       const value = variableTag.getAttributeValue('VALUE');
  1078.       const queryParam = variableTag.getAttributeValue('QUERYPARAM');
  1079.       if (name && value) {
  1080.         if (!this.globalVariables_.has(name)) {
  1081.           this.globalVariables_.set(name, value);
  1082.         }
  1083.       }
  1084.       if (queryParam) {
  1085.         const queryParamValue = queryParams.get(queryParam)[0];
  1086.         if (queryParamValue && !this.globalVariables_.has(queryParamValue)) {
  1087.           this.globalVariables_.set(queryParam, queryParamValue);
  1088.         }
  1089.       }
  1090.     }
  1091.   }
  1093.   /**
  1094.    * Get the variables of each variant tag, and store in a map.
  1095.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1096.    * @param {string} uri Media playlist URI.
  1097.    * @return {!Map.<string, string>}
  1098.    * @private
  1099.    */
  1100.   parseMediaVariables_(tags, uri) {
  1101.     const queryParams = new goog.Uri(uri).getQueryData();
  1102.     const mediaVariables = new Map();
  1103.     for (const variableTag of tags) {
  1104.       const name = variableTag.getAttributeValue('NAME');
  1105.       const value = variableTag.getAttributeValue('VALUE');
  1106.       const queryParam = variableTag.getAttributeValue('QUERYPARAM');
  1107.       const mediaImport = variableTag.getAttributeValue('IMPORT');
  1108.       if (name && value) {
  1109.         if (!mediaVariables.has(name)) {
  1110.           mediaVariables.set(name, value);
  1111.         }
  1112.       }
  1113.       if (queryParam) {
  1114.         const queryParamValue = queryParams.get(queryParam)[0];
  1115.         if (queryParamValue && !mediaVariables.has(queryParamValue)) {
  1116.           mediaVariables.set(queryParam, queryParamValue);
  1117.         }
  1118.       }
  1119.       if (mediaImport) {
  1120.         const globalValue = this.globalVariables_.get(mediaImport);
  1121.         if (globalValue) {
  1122.           mediaVariables.set(mediaImport, globalValue);
  1123.         }
  1124.       }
  1125.     }
  1126.     return mediaVariables;
  1127.   }
  1129.   /**
  1130.    * Get the codecs of each variant tag, and store in a map from
  1131.    * audio/video/subtitle group id to the codecs arraylist.
  1132.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1133.    * @private
  1134.    */
  1135.   parseCodecs_(tags) {
  1136.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1138.     for (const variantTag of tags) {
  1139.       const audioGroupId = variantTag.getAttributeValue('AUDIO');
  1140.       const videoGroupId = variantTag.getAttributeValue('VIDEO');
  1141.       const subGroupId = variantTag.getAttributeValue('SUBTITLES');
  1142.       const allCodecs = this.getCodecsForVariantTag_(variantTag);
  1144.       if (subGroupId) {
  1145.         const textCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1146.             ContentType.TEXT, allCodecs);
  1147.         goog.asserts.assert(textCodecs != null, 'Text codecs should be valid.');
  1148.         this.groupIdToCodecsMap_.set(subGroupId, textCodecs);
  1149.         shaka.util.ArrayUtils.remove(allCodecs, textCodecs);
  1150.       }
  1151.       if (audioGroupId) {
  1152.         let codecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1153.             ContentType.AUDIO, allCodecs);
  1154.         if (!codecs) {
  1155.           codecs = this.config_.hls.defaultAudioCodec;
  1156.         }
  1157.         this.groupIdToCodecsMap_.set(audioGroupId, codecs);
  1158.       }
  1159.       if (videoGroupId) {
  1160.         let codecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1161.             ContentType.VIDEO, allCodecs);
  1162.         if (!codecs) {
  1163.           codecs = this.config_.hls.defaultVideoCodec;
  1164.         }
  1165.         this.groupIdToCodecsMap_.set(videoGroupId, codecs);
  1166.       }
  1167.     }
  1168.   }
  1170.   /**
  1171.    * Process EXT-X-SESSION-DATA tags.
  1172.    *
  1173.    * @param {!Array.<!shaka.hls.Tag>} tags
  1174.    * @private
  1175.    */
  1176.   processSessionData_(tags) {
  1177.     for (const tag of tags) {
  1178.       const id = tag.getAttributeValue('DATA-ID');
  1179.       const uri = tag.getAttributeValue('URI');
  1180.       const language = tag.getAttributeValue('LANGUAGE');
  1181.       const value = tag.getAttributeValue('VALUE');
  1182.       const data = (new Map()).set('id', id);
  1183.       if (uri) {
  1184.         data.set('uri', shaka.hls.Utils.constructSegmentUris(
  1185.             [this.masterPlaylistUri_], uri, this.globalVariables_)[0]);
  1186.       }
  1187.       if (language) {
  1188.         data.set('language', language);
  1189.       }
  1190.       if (value) {
  1191.         data.set('value', value);
  1192.       }
  1193.       const event = new shaka.util.FakeEvent('sessiondata', data);
  1194.       if (this.playerInterface_) {
  1195.         this.playerInterface_.onEvent(event);
  1196.       }
  1197.     }
  1198.   }
  1200.   /**
  1201.    * Process EXT-X-CONTENT-STEERING tags.
  1202.    *
  1203.    * @param {!Array.<!shaka.hls.Tag>} tags
  1204.    * @return {!Promise}
  1205.    * @private
  1206.    */
  1207.   async processContentSteering_(tags) {
  1208.     if (!this.playerInterface_ || !this.config_) {
  1209.       return;
  1210.     }
  1211.     let contentSteeringPromise;
  1212.     for (const tag of tags) {
  1213.       const defaultPathwayId = tag.getAttributeValue('PATHWAY-ID');
  1214.       const uri = tag.getAttributeValue('SERVER-URI');
  1215.       if (!defaultPathwayId || !uri) {
  1216.         continue;
  1217.       }
  1218.       this.contentSteeringManager_ =
  1219.             new shaka.util.ContentSteeringManager(this.playerInterface_);
  1220.       this.contentSteeringManager_.configure(this.config_);
  1221.       this.contentSteeringManager_.setBaseUris([this.masterPlaylistUri_]);
  1222.       this.contentSteeringManager_.setManifestType(
  1223.           shaka.media.ManifestParser.HLS);
  1224.       this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
  1225.       contentSteeringPromise =
  1226.           this.contentSteeringManager_.requestInfo(uri);
  1227.       break;
  1228.     }
  1229.     await contentSteeringPromise;
  1230.   }
  1232.   /**
  1233.    * Parse Subtitles and Closed Captions from 'EXT-X-MEDIA' tags.
  1234.    * Create text streams for Subtitles, but not Closed Captions.
  1235.    *
  1236.    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
  1237.    * @return {!Array.<!shaka.extern.Stream>}
  1238.    * @private
  1239.    */
  1240.   parseTexts_(mediaTags) {
  1241.     // Create text stream for each Subtitle media tag.
  1242.     const subtitleTags =
  1243.         shaka.hls.Utils.filterTagsByType(mediaTags, 'SUBTITLES');
  1244.     const textStreams = subtitleTags.map((tag) => {
  1245.       const disableText = this.config_.disableText;
  1246.       if (disableText) {
  1247.         return null;
  1248.       }
  1249.       try {
  1250.         return this.createStreamInfoFromMediaTags_([tag], new Map()).stream;
  1251.       } catch (e) {
  1252.         if (this.config_.hls.ignoreTextStreamFailures) {
  1253.           return null;
  1254.         }
  1255.         throw e;
  1256.       }
  1257.     });
  1259.     const type = shaka.util.ManifestParserUtils.ContentType.TEXT;
  1261.     // Set the codecs for text streams.
  1262.     for (const tag of subtitleTags) {
  1263.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1264.       const codecs = this.groupIdToCodecsMap_.get(groupId);
  1265.       if (codecs) {
  1266.         const textStreamInfos = this.groupIdToStreamInfosMap_.get(groupId);
  1267.         if (textStreamInfos) {
  1268.           for (const textStreamInfo of textStreamInfos) {
  1269.             textStreamInfo.stream.codecs = codecs;
  1270.             textStreamInfo.stream.mimeType =
  1271.                 this.guessMimeTypeBeforeLoading_(type, codecs) ||
  1272.                 this.guessMimeTypeFallback_(type);
  1273.             this.setFullTypeForStream_(textStreamInfo.stream);
  1274.           }
  1275.         }
  1276.       }
  1277.     }
  1279.     // Do not create text streams for Closed captions.
  1280.     return textStreams.filter((s) => s);
  1281.   }
  1283.   /**
  1284.    * @param {!shaka.extern.Stream} stream
  1285.    * @private
  1286.    */
  1287.   setFullTypeForStream_(stream) {
  1288.     stream.fullMimeTypes = new Set([shaka.util.MimeUtils.getFullType(
  1289.         stream.mimeType, stream.codecs)]);
  1290.   }
  1292.   /**
  1293.    * @param {!Array.<!shaka.hls.Tag>} imageTags from the playlist.
  1294.    * @param {!Array.<!shaka.hls.Tag>} iFrameTags from the playlist.
  1295.    * @return {!Promise.<!Array.<!shaka.extern.Stream>>}
  1296.    * @private
  1297.    */
  1298.   async parseImages_(imageTags, iFrameTags) {
  1299.     // Create image stream for each image tag.
  1300.     const imageStreamPromises = imageTags.map(async (tag) => {
  1301.       const disableThumbnails = this.config_.disableThumbnails;
  1302.       if (disableThumbnails) {
  1303.         return null;
  1304.       }
  1305.       try {
  1306.         const streamInfo = await this.createStreamInfoFromImageTag_(tag);
  1307.         return streamInfo.stream;
  1308.       } catch (e) {
  1309.         if (this.config_.hls.ignoreImageStreamFailures) {
  1310.           return null;
  1311.         }
  1312.         throw e;
  1313.       }
  1314.     }).concat(iFrameTags.map((tag) => {
  1315.       const disableThumbnails = this.config_.disableThumbnails;
  1316.       if (disableThumbnails) {
  1317.         return null;
  1318.       }
  1319.       try {
  1320.         const streamInfo = this.createStreamInfoFromIframeTag_(tag);
  1321.         if (streamInfo.stream.codecs !== 'mjpg') {
  1322.           return null;
  1323.         }
  1324.         return streamInfo.stream;
  1325.       } catch (e) {
  1326.         if (this.config_.hls.ignoreImageStreamFailures) {
  1327.           return null;
  1328.         }
  1329.         throw e;
  1330.       }
  1331.     }));
  1332.     const imageStreams = await Promise.all(imageStreamPromises);
  1333.     return imageStreams.filter((s) => s);
  1334.   }
  1336.   /**
  1337.    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
  1338.    * @param {!Map.<string, string>} groupIdPathwayIdMapping
  1339.    * @private
  1340.    */
  1341.   createStreamInfosFromMediaTags_(mediaTags, groupIdPathwayIdMapping) {
  1342.     // Filter out subtitles and  media tags without uri.
  1343.     mediaTags = mediaTags.filter((tag) => {
  1344.       const uri = tag.getAttributeValue('URI') || '';
  1345.       const type = tag.getAttributeValue('TYPE');
  1346.       return type != 'SUBTITLES' && uri != '';
  1347.     });
  1349.     const groupedTags = {};
  1350.     for (const tag of mediaTags) {
  1351.       const key = tag.getTagKey();
  1352.       if (!groupedTags[key]) {
  1353.         groupedTags[key] = [tag];
  1354.       } else {
  1355.         groupedTags[key].push(tag);
  1356.       }
  1357.     }
  1359.     for (const key in groupedTags) {
  1360.       // Create stream info for each audio / video media grouped tag.
  1361.       this.createStreamInfoFromMediaTags_(
  1362.           groupedTags[key], groupIdPathwayIdMapping);
  1363.     }
  1364.   }
  1366.   /**
  1367.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1368.    * @param {!Array.<!shaka.hls.Tag>} sessionKeyTags EXT-X-SESSION-KEY tags
  1369.    * from the playlist.
  1370.    * @param {!Array.<!shaka.hls.Tag>} mediaTags EXT-X-MEDIA tags from the
  1371.    * playlist.
  1372.    * @param {function():!Array.<string>} getUris
  1373.    * @param {?Map.<string, string>=} variables
  1374.    * @return {!Promise.<!Array.<!shaka.extern.Variant>>}
  1375.    * @private
  1376.    */
  1377.   async createVariantsForTags_(tags, sessionKeyTags, mediaTags, getUris,
  1378.       variables) {
  1379.     // EXT-X-SESSION-KEY processing
  1380.     const drmInfos = [];
  1381.     const keyIds = new Set();
  1382.     if (sessionKeyTags.length > 0) {
  1383.       for (const drmTag of sessionKeyTags) {
  1384.         const method = drmTag.getRequiredAttrValue('METHOD');
  1385.         // According to the HLS spec, KEYFORMAT is optional and implicitly
  1386.         // defaults to "identity".
  1387.         // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
  1388.         const keyFormat =
  1389.             drmTag.getAttributeValue('KEYFORMAT') || 'identity';
  1390.         let drmInfo = null;
  1391.         if (method == 'NONE' || this.isAesMethod_(method)) {
  1392.           continue;
  1393.         } else if (keyFormat == 'identity') {
  1394.           // eslint-disable-next-line no-await-in-loop
  1395.           drmInfo = await this.identityDrmParser_(
  1396.               drmTag, /* mimeType= */ '', getUris,
  1397.               /* initSegmentRef= */ null, variables);
  1398.         } else {
  1399.           const drmParser =
  1400.               shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  1402.           drmInfo = drmParser ?
  1403.               drmParser(drmTag, /* mimeType= */ '') : null;
  1404.         }
  1405.         if (drmInfo) {
  1406.           if (drmInfo.keyIds) {
  1407.             for (const keyId of drmInfo.keyIds) {
  1408.               keyIds.add(keyId);
  1409.             }
  1410.           }
  1411.           drmInfos.push(drmInfo);
  1412.         } else {
  1413.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  1414.         }
  1415.       }
  1416.     }
  1418.     const groupedTags = {};
  1419.     for (const tag of tags) {
  1420.       const key = tag.getTagKey();
  1421.       if (!groupedTags[key]) {
  1422.         groupedTags[key] = [tag];
  1423.       } else {
  1424.         groupedTags[key].push(tag);
  1425.       }
  1426.     }
  1428.     const allVariants = [];
  1429.     // Create variants for each group of variant tag.
  1430.     for (const key in groupedTags) {
  1431.       const tags = groupedTags[key];
  1432.       const firstTag = tags[0];
  1434.       const frameRate = firstTag.getAttributeValue('FRAME-RATE');
  1435.       const bandwidth =
  1436.           Number(firstTag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
  1437.           Number(firstTag.getRequiredAttrValue('BANDWIDTH'));
  1439.       const resolution = firstTag.getAttributeValue('RESOLUTION');
  1440.       const [width, height] = resolution ? resolution.split('x') : [null, null];
  1442.       const videoRange = firstTag.getAttributeValue('VIDEO-RANGE');
  1444.       let videoLayout = firstTag.getAttributeValue('REQ-VIDEO-LAYOUT');
  1445.       if (videoLayout && videoLayout.includes(',')) {
  1446.         // If multiple video layout strings are present, pick the first valid
  1447.         // one.
  1448.         const layoutStrings = videoLayout.split(',').filter((layoutString) => {
  1449.           return layoutString == 'CH-STEREO' || layoutString == 'CH-MONO';
  1450.         });
  1451.         videoLayout = layoutStrings[0];
  1452.       }
  1453.       // According to the HLS spec:
  1454.       // By default a video variant is monoscopic, so an attribute
  1455.       // consisting entirely of REQ-VIDEO-LAYOUT="CH-MONO" is unnecessary
  1456.       // and SHOULD NOT be present.
  1457.       videoLayout = videoLayout || 'CH-MONO';
  1459.       const streamInfos = this.createStreamInfosForVariantTags_(tags,
  1460.           mediaTags, resolution, frameRate, bandwidth);
  1462.       goog.asserts.assert(streamInfos.audio.length ||
  1463.           streamInfos.video.length, 'We should have created a stream!');
  1465.       allVariants.push(...this.createVariants_(
  1466.           streamInfos.audio,
  1467.           streamInfos.video,
  1468.           bandwidth,
  1469.           width,
  1470.           height,
  1471.           frameRate,
  1472.           videoRange,
  1473.           videoLayout,
  1474.           drmInfos,
  1475.           keyIds));
  1476.     }
  1477.     return allVariants.filter((variant) => variant != null);
  1478.   }
  1480.   /**
  1481.    * Create audio and video streamInfos from an 'EXT-X-STREAM-INF' tag and its
  1482.    * related media tags.
  1483.    *
  1484.    * @param {!Array.<!shaka.hls.Tag>} tags
  1485.    * @param {!Array.<!shaka.hls.Tag>} mediaTags
  1486.    * @param {?string} resolution
  1487.    * @param {?string} frameRate
  1488.    * @param {number} bandwidth
  1489.    * @return {!shaka.hls.HlsParser.StreamInfos}
  1490.    * @private
  1491.    */
  1492.   createStreamInfosForVariantTags_(
  1493.       tags, mediaTags, resolution, frameRate, bandwidth) {
  1494.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1496.     /** @type {shaka.hls.HlsParser.StreamInfos} */
  1497.     const res = {
  1498.       audio: [],
  1499.       video: [],
  1500.     };
  1501.     const groupIdPathwayIdMapping = new Map();
  1502.     const globalGroupIds = [];
  1503.     let isAudioGroup = false;
  1504.     let isVideoGroup = false;
  1505.     for (const tag of tags) {
  1506.       const audioGroupId = tag.getAttributeValue('AUDIO');
  1507.       const videoGroupId = tag.getAttributeValue('VIDEO');
  1508.       goog.asserts.assert(audioGroupId == null || videoGroupId == null,
  1509.           'Unexpected: both video and audio described by media tags!');
  1511.       const groupId = audioGroupId || videoGroupId;
  1512.       if (!groupId) {
  1513.         continue;
  1514.       }
  1515.       if (!globalGroupIds.includes(groupId)) {
  1516.         globalGroupIds.push(groupId);
  1517.       }
  1518.       const pathwayId = tag.getAttributeValue('PATHWAY-ID');
  1519.       if (pathwayId) {
  1520.         groupIdPathwayIdMapping.set(groupId, pathwayId);
  1521.       }
  1522.       if (audioGroupId) {
  1523.         isAudioGroup = true;
  1524.       } else if (videoGroupId) {
  1525.         isVideoGroup = true;
  1526.       }
  1527.       // Make an educated guess about the stream type.
  1528.       shaka.log.debug('Guessing stream type for', tag.toString());
  1529.     }
  1530.     if (globalGroupIds.length && mediaTags.length) {
  1531.       const mediaTagsForVariant = mediaTags.filter((tag) => {
  1532.         return globalGroupIds.includes(tag.getRequiredAttrValue('GROUP-ID'));
  1533.       });
  1534.       this.createStreamInfosFromMediaTags_(
  1535.           mediaTagsForVariant, groupIdPathwayIdMapping);
  1536.     }
  1537.     const globalGroupId = globalGroupIds.sort().join(',');
  1538.     const streamInfos =
  1539.         (globalGroupId && this.groupIdToStreamInfosMap_.has(globalGroupId)) ?
  1540.         this.groupIdToStreamInfosMap_.get(globalGroupId) : [];
  1541.     if (isAudioGroup) {
  1542.       res.audio.push(...streamInfos);
  1543.     } else if (isVideoGroup) {
  1544.       res.video.push(...streamInfos);
  1545.     }
  1547.     let type;
  1548.     let ignoreStream = false;
  1550.     // The Microsoft HLS manifest generators will make audio-only variants
  1551.     // that link to their URI both directly and through an audio tag.
  1552.     // In that case, ignore the local URI and use the version in the
  1553.     // AUDIO tag, so you inherit its language.
  1554.     // As an example, see the manifest linked in issue #860.
  1555.     const allStreamUris = tags.map((tag) => tag.getRequiredAttrValue('URI'));
  1556.     const hasSameUri = res.audio.find((audio) => {
  1557.       return audio && audio.getUris().find((uri) => {
  1558.         return allStreamUris.includes(uri);
  1559.       });
  1560.     });
  1562.     /** @type {!Array.<string>} */
  1563.     let allCodecs = this.getCodecsForVariantTag_(tags[0]);
  1564.     const videoCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1565.         ContentType.VIDEO, allCodecs);
  1566.     const audioCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1567.         ContentType.AUDIO, allCodecs);
  1569.     if (audioCodecs && !videoCodecs) {
  1570.       // There are no associated media tags, and there's only audio codec,
  1571.       // and no video codec, so it should be audio.
  1572.       type = ContentType.AUDIO;
  1573.       shaka.log.debug('Guessing audio-only.');
  1574.       ignoreStream = res.audio.length > 0;
  1575.     } else if (!res.audio.length && !res.video.length &&
  1576.         audioCodecs && videoCodecs) {
  1577.       // There are both audio and video codecs, so assume multiplexed content.
  1578.       // Note that the default used when CODECS is missing assumes multiple
  1579.       // (and therefore multiplexed).
  1580.       // Recombine the codec strings into one so that MediaSource isn't
  1581.       // lied to later. (That would trigger an error in Chrome.)
  1582.       shaka.log.debug('Guessing multiplexed audio+video.');
  1583.       type = ContentType.VIDEO;
  1584.       allCodecs = [[videoCodecs, audioCodecs].join(',')];
  1585.     } else if (res.audio.length && hasSameUri) {
  1586.       shaka.log.debug('Guessing audio-only.');
  1587.       type = ContentType.AUDIO;
  1588.       ignoreStream = true;
  1589.     } else if (res.video.length && !res.audio.length) {
  1590.       // There are associated video streams.  Assume this is audio.
  1591.       shaka.log.debug('Guessing audio-only.');
  1592.       type = ContentType.AUDIO;
  1593.     } else {
  1594.       shaka.log.debug('Guessing video-only.');
  1595.       type = ContentType.VIDEO;
  1596.     }
  1598.     if (!ignoreStream) {
  1599.       let language = null;
  1600.       let name = null;
  1601.       let channelsCount = null;
  1602.       let spatialAudio = false;
  1603.       let characteristics = null;
  1604.       let sampleRate = null;
  1605.       if (!streamInfos.length) {
  1606.         const mediaTag = mediaTags.find((tag) => {
  1607.           const uri = tag.getAttributeValue('URI') || '';
  1608.           const type = tag.getAttributeValue('TYPE');
  1609.           const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1610.           return type != 'SUBTITLES' && uri == '' &&
  1611.               globalGroupIds.includes(groupId);
  1612.         });
  1613.         if (mediaTag) {
  1614.           language = mediaTag.getAttributeValue('LANGUAGE');
  1615.           name = mediaTag.getAttributeValue('NAME');
  1616.           channelsCount = this.getChannelsCount_(mediaTag);
  1617.           spatialAudio = this.isSpatialAudio_(mediaTag);
  1618.           characteristics = mediaTag.getAttributeValue('CHARACTERISTICS');
  1619.           sampleRate = this.getSampleRate_(mediaTag);
  1620.         }
  1621.       }
  1622.       const streamInfo = this.createStreamInfoFromVariantTags_(
  1623.           tags, allCodecs, type, language, name, channelsCount,
  1624.           characteristics, sampleRate, spatialAudio);
  1625.       if (globalGroupId) {
  1626.         streamInfo.stream.groupId = globalGroupId;
  1627.       }
  1628.       if (!streamInfos.length) {
  1629.         streamInfo.stream.bandwidth = bandwidth;
  1630.       }
  1631.       res[streamInfo.stream.type] = [streamInfo];
  1632.     }
  1633.     return res;
  1634.   }
  1637.   /**
  1638.    * Get the codecs from the 'EXT-X-STREAM-INF' tag.
  1639.    *
  1640.    * @param {!shaka.hls.Tag} tag
  1641.    * @return {!Array.<string>} codecs
  1642.    * @private
  1643.    */
  1644.   getCodecsForVariantTag_(tag) {
  1645.     let codecsString = tag.getAttributeValue('CODECS') || '';
  1647.     const supplementalCodecsString =
  1648.         tag.getAttributeValue('SUPPLEMENTAL-CODECS');
  1650.     this.codecInfoInManifest_ = codecsString.length > 0;
  1652.     if (!this.codecInfoInManifest_ && !this.config_.hls.disableCodecGuessing) {
  1653.       // These are the default codecs to assume if none are specified.
  1654.       const defaultCodecsArray = [];
  1656.       if (!this.config_.disableVideo) {
  1657.         defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
  1658.       }
  1659.       if (!this.config_.disableAudio) {
  1660.         defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
  1661.       }
  1663.       codecsString = defaultCodecsArray.join(',');
  1664.     }
  1666.     // Strip out internal whitespace while splitting on commas:
  1667.     /** @type {!Array.<string>} */
  1668.     const codecs = codecsString.split(/\s*,\s*/);
  1670.     if (supplementalCodecsString) {
  1671.       const supplementalCodecs = supplementalCodecsString.split(/\s*,\s*/)
  1672.           .map((codec) => {
  1673.             return codec.split('/')[0];
  1674.           });
  1675.       codecs.push(...supplementalCodecs);
  1676.     }
  1678.     return shaka.media.SegmentUtils.codecsFiltering(codecs);
  1679.   }
  1681.   /**
  1682.    * Get the channel count information for an HLS audio track.
  1683.    * CHANNELS specifies an ordered, "/" separated list of parameters.
  1684.    * If the type is audio, the first parameter will be a decimal integer
  1685.    * specifying the number of independent, simultaneous audio channels.
  1686.    * No other channels parameters are currently defined.
  1687.    *
  1688.    * @param {!shaka.hls.Tag} tag
  1689.    * @return {?number}
  1690.    * @private
  1691.    */
  1692.   getChannelsCount_(tag) {
  1693.     const channels = tag.getAttributeValue('CHANNELS');
  1694.     if (!channels) {
  1695.       return null;
  1696.     }
  1697.     const channelcountstring = channels.split('/')[0];
  1698.     const count = parseInt(channelcountstring, 10);
  1699.     return count;
  1700.   }
  1702.   /**
  1703.    * Get the sample rate information for an HLS audio track.
  1704.    *
  1705.    * @param {!shaka.hls.Tag} tag
  1706.    * @return {?number}
  1707.    * @private
  1708.    */
  1709.   getSampleRate_(tag) {
  1710.     const sampleRate = tag.getAttributeValue('SAMPLE-RATE');
  1711.     if (!sampleRate) {
  1712.       return null;
  1713.     }
  1714.     return parseInt(sampleRate, 10);
  1715.   }
  1717.   /**
  1718.    * Get the spatial audio information for an HLS audio track.
  1719.    * In HLS the channels field indicates the number of audio channels that the
  1720.    * stream has (eg: 2). In the case of Dolby Atmos, the complexity is
  1721.    * expressed with the number of channels followed by the word JOC
  1722.    * (eg: 16/JOC), so 16 would be the number of channels (eg: 7.3.6 layout),
  1723.    * and JOC indicates that the stream has spatial audio.
  1724.    * @see https://developer.apple.com/documentation/http_live_streaming/hls_authoring_specification_for_apple_devices/hls_authoring_specification_for_apple_devices_appendixes
  1725.    *
  1726.    * @param {!shaka.hls.Tag} tag
  1727.    * @return {boolean}
  1728.    * @private
  1729.    */
  1730.   isSpatialAudio_(tag) {
  1731.     const channels = tag.getAttributeValue('CHANNELS');
  1732.     if (!channels) {
  1733.       return false;
  1734.     }
  1735.     return channels.includes('/JOC');
  1736.   }
  1738.   /**
  1739.    * Get the closed captions map information for the EXT-X-STREAM-INF tag, to
  1740.    * create the stream info.
  1741.    * @param {!shaka.hls.Tag} tag
  1742.    * @param {string} type
  1743.    * @return {Map.<string, string>} closedCaptions
  1744.    * @private
  1745.    */
  1746.   getClosedCaptions_(tag, type) {
  1747.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1748.     // The attribute of closed captions is optional, and the value may be
  1749.     // 'NONE'.
  1750.     const closedCaptionsAttr = tag.getAttributeValue('CLOSED-CAPTIONS');
  1752.     // EXT-X-STREAM-INF tags may have CLOSED-CAPTIONS attributes.
  1753.     // The value can be either a quoted-string or an enumerated-string with
  1754.     // the value NONE. If the value is a quoted-string, it MUST match the
  1755.     // value of the GROUP-ID attribute of an EXT-X-MEDIA tag elsewhere in the
  1756.     // Playlist whose TYPE attribute is CLOSED-CAPTIONS.
  1757.     if (type == ContentType.VIDEO) {
  1758.       if (closedCaptionsAttr && closedCaptionsAttr != 'NONE') {
  1759.         return this.groupIdToClosedCaptionsMap_.get(closedCaptionsAttr);
  1760.       } else if (!closedCaptionsAttr &&
  1761.           this.groupIdToClosedCaptionsMap_.size) {
  1762.         for (const key of this.groupIdToClosedCaptionsMap_.keys()) {
  1763.           return this.groupIdToClosedCaptionsMap_.get(key);
  1764.         }
  1765.       }
  1766.     }
  1767.     return null;
  1768.   }
  1770.   /**
  1771.    * Get the normalized language value.
  1772.    *
  1773.    * @param {?string} languageValue
  1774.    * @return {string}
  1775.    * @private
  1776.    */
  1777.   getLanguage_(languageValue) {
  1778.     const LanguageUtils = shaka.util.LanguageUtils;
  1779.     return LanguageUtils.normalize(languageValue || 'und');
  1780.   }
  1782.   /**
  1783.    * Get the type value.
  1784.    * Shaka recognizes the content types 'audio', 'video', 'text', and 'image'.
  1785.    * The HLS 'subtitles' type needs to be mapped to 'text'.
  1786.    * @param {!shaka.hls.Tag} tag
  1787.    * @return {string}
  1788.    * @private
  1789.    */
  1790.   getType_(tag) {
  1791.     let type = tag.getRequiredAttrValue('TYPE').toLowerCase();
  1792.     if (type == 'subtitles') {
  1793.       type = shaka.util.ManifestParserUtils.ContentType.TEXT;
  1794.     }
  1795.     return type;
  1796.   }
  1798.   /**
  1799.    * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} audioInfos
  1800.    * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} videoInfos
  1801.    * @param {number} bandwidth
  1802.    * @param {?string} width
  1803.    * @param {?string} height
  1804.    * @param {?string} frameRate
  1805.    * @param {?string} videoRange
  1806.    * @param {?string} videoLayout
  1807.    * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
  1808.    * @param {!Set.<string>} keyIds
  1809.    * @return {!Array.<!shaka.extern.Variant>}
  1810.    * @private
  1811.    */
  1812.   createVariants_(
  1813.       audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange,
  1814.       videoLayout, drmInfos, keyIds) {
  1815.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1816.     const DrmEngine = shaka.media.DrmEngine;
  1818.     for (const info of videoInfos) {
  1819.       this.addVideoAttributes_(
  1820.           info.stream, width, height, frameRate, videoRange, videoLayout);
  1821.     }
  1823.     // In case of audio-only or video-only content or the audio/video is
  1824.     // disabled by the config, we create an array of one item containing
  1825.     // a null. This way, the double-loop works for all kinds of content.
  1826.     // NOTE: we currently don't have support for audio-only content.
  1827.     const disableAudio = this.config_.disableAudio;
  1828.     if (!audioInfos.length || disableAudio) {
  1829.       audioInfos = [null];
  1830.     }
  1831.     const disableVideo = this.config_.disableVideo;
  1832.     if (!videoInfos.length || disableVideo) {
  1833.       videoInfos = [null];
  1834.     }
  1836.     const variants = [];
  1837.     for (const audioInfo of audioInfos) {
  1838.       for (const videoInfo of videoInfos) {
  1839.         const audioStream = audioInfo ? audioInfo.stream : null;
  1840.         if (audioStream) {
  1841.           audioStream.drmInfos = drmInfos;
  1842.           audioStream.keyIds = keyIds;
  1843.         }
  1844.         const videoStream = videoInfo ? videoInfo.stream : null;
  1845.         if (videoStream) {
  1846.           videoStream.drmInfos = drmInfos;
  1847.           videoStream.keyIds = keyIds;
  1848.         }
  1849.         const audioDrmInfos = audioInfo ? audioInfo.stream.drmInfos : null;
  1850.         const videoDrmInfos = videoInfo ? videoInfo.stream.drmInfos : null;
  1851.         const videoStreamUri =
  1852.             videoInfo ? videoInfo.getUris().sort().join(',') : '';
  1853.         const audioStreamUri =
  1854.             audioInfo ? audioInfo.getUris().sort().join(',') : '';
  1855.         const variantUriKey = videoStreamUri + ' - ' + audioStreamUri;
  1857.         if (audioStream && videoStream) {
  1858.           if (!DrmEngine.areDrmCompatible(audioDrmInfos, videoDrmInfos)) {
  1859.             shaka.log.warning(
  1860.                 'Incompatible DRM info in HLS variant.  Skipping.');
  1861.             continue;
  1862.           }
  1863.         }
  1865.         if (this.variantUriSet_.has(variantUriKey)) {
  1866.           // This happens when two variants only differ in their text streams.
  1867.           shaka.log.debug(
  1868.               'Skipping variant which only differs in text streams.');
  1869.           continue;
  1870.         }
  1872.         // Since both audio and video are of the same type, this assertion will
  1873.         // catch certain mistakes at runtime that the compiler would miss.
  1874.         goog.asserts.assert(!audioStream ||
  1875.             audioStream.type == ContentType.AUDIO, 'Audio parameter mismatch!');
  1876.         goog.asserts.assert(!videoStream ||
  1877.             videoStream.type == ContentType.VIDEO, 'Video parameter mismatch!');
  1879.         const variant = {
  1880.           id: this.globalId_++,
  1881.           language: audioStream ? audioStream.language : 'und',
  1882.           disabledUntilTime: 0,
  1883.           primary: (!!audioStream && audioStream.primary) ||
  1884.               (!!videoStream && videoStream.primary),
  1885.           audio: audioStream,
  1886.           video: videoStream,
  1887.           bandwidth,
  1888.           allowedByApplication: true,
  1889.           allowedByKeySystem: true,
  1890.           decodingInfos: [],
  1891.         };
  1893.         variants.push(variant);
  1894.         this.variantUriSet_.add(variantUriKey);
  1895.       }
  1896.     }
  1897.     return variants;
  1898.   }
  1900.   /**
  1901.    * Parses an array of EXT-X-MEDIA tags, then stores the values of all tags
  1902.    * with TYPE="CLOSED-CAPTIONS" into a map of group id to closed captions.
  1903.    *
  1904.    * @param {!Array.<!shaka.hls.Tag>} mediaTags
  1905.    * @private
  1906.    */
  1907.   parseClosedCaptions_(mediaTags) {
  1908.     const closedCaptionsTags =
  1909.         shaka.hls.Utils.filterTagsByType(mediaTags, 'CLOSED-CAPTIONS');
  1910.     for (const tag of closedCaptionsTags) {
  1911.       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  1912.           'Should only be called on media tags!');
  1913.       const languageValue = tag.getAttributeValue('LANGUAGE');
  1914.       let language = this.getLanguage_(languageValue);
  1915.       if (!languageValue) {
  1916.         const nameValue = tag.getAttributeValue('NAME');
  1917.         if (nameValue) {
  1918.           language = nameValue;
  1919.         }
  1920.       }
  1922.       // The GROUP-ID value is a quoted-string that specifies the group to which
  1923.       // the Rendition belongs.
  1924.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1926.       // The value of INSTREAM-ID is a quoted-string that specifies a Rendition
  1927.       // within the segments in the Media Playlist. This attribute is REQUIRED
  1928.       // if the TYPE attribute is CLOSED-CAPTIONS.
  1929.       // We need replace SERVICE string by our internal svc string.
  1930.       const instreamId = tag.getRequiredAttrValue('INSTREAM-ID')
  1931.           .replace('SERVICE', 'svc');
  1932.       if (!this.groupIdToClosedCaptionsMap_.get(groupId)) {
  1933.         this.groupIdToClosedCaptionsMap_.set(groupId, new Map());
  1934.       }
  1935.       this.groupIdToClosedCaptionsMap_.get(groupId).set(instreamId, language);
  1936.     }
  1937.   }
  1939.   /**
  1940.    * Parse EXT-X-MEDIA media tag into a Stream object.
  1941.    *
  1942.    * @param {!Array.<!shaka.hls.Tag>} tags
  1943.    * @param {!Map.<string, string>} groupIdPathwayIdMapping
  1944.    * @return {!shaka.hls.HlsParser.StreamInfo}
  1945.    * @private
  1946.    */
  1947.   createStreamInfoFromMediaTags_(tags, groupIdPathwayIdMapping) {
  1948.     const verbatimMediaPlaylistUris = [];
  1949.     const globalGroupIds = [];
  1950.     const groupIdUriMappping = new Map();
  1951.     for (const tag of tags) {
  1952.       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  1953.           'Should only be called on media tags!');
  1954.       const uri = tag.getRequiredAttrValue('URI');
  1955.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1956.       verbatimMediaPlaylistUris.push(uri);
  1957.       globalGroupIds.push(groupId);
  1958.       groupIdUriMappping.set(groupId, uri);
  1959.     }
  1961.     const globalGroupId = globalGroupIds.sort().join(',');
  1962.     const firstTag = tags[0];
  1963.     let codecs = '';
  1964.     /** @type {string} */
  1965.     const type = this.getType_(firstTag);
  1966.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  1967.       codecs = firstTag.getAttributeValue('CODECS') || '';
  1968.     } else {
  1969.       for (const groupId of globalGroupIds) {
  1970.         if (this.groupIdToCodecsMap_.has(groupId)) {
  1971.           codecs = this.groupIdToCodecsMap_.get(groupId);
  1972.           break;
  1973.         }
  1974.       }
  1975.     }
  1977.     // Check if the stream has already been created as part of another Variant
  1978.     // and return it if it has.
  1979.     const key = verbatimMediaPlaylistUris.sort().join(',');
  1980.     if (this.uriToStreamInfosMap_.has(key)) {
  1981.       return this.uriToStreamInfosMap_.get(key);
  1982.     }
  1983.     const streamId = this.globalId_++;
  1984.     if (this.contentSteeringManager_) {
  1985.       for (const [groupId, uri] of groupIdUriMappping) {
  1986.         const pathwayId = groupIdPathwayIdMapping.get(groupId);
  1987.         if (pathwayId) {
  1988.           this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
  1989.         }
  1990.       }
  1991.     }
  1993.     const language = firstTag.getAttributeValue('LANGUAGE');
  1994.     const name = firstTag.getAttributeValue('NAME');
  1996.     // NOTE: According to the HLS spec, "DEFAULT=YES" requires "AUTOSELECT=YES".
  1997.     // However, we don't bother to validate "AUTOSELECT", since we don't
  1998.     // actually use it in our streaming model, and we treat everything as
  1999.     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
  2000.     // only be selected explicitly by the user, and we don't have a way to
  2001.     // represent that in our model.
  2002.     const defaultAttrValue = firstTag.getAttributeValue('DEFAULT');
  2003.     const primary = defaultAttrValue == 'YES';
  2005.     const channelsCount =
  2006.         type == 'audio' ? this.getChannelsCount_(firstTag) : null;
  2007.     const spatialAudio =
  2008.         type == 'audio' ? this.isSpatialAudio_(firstTag) : false;
  2009.     const characteristics = firstTag.getAttributeValue('CHARACTERISTICS');
  2011.     const forcedAttrValue = firstTag.getAttributeValue('FORCED');
  2012.     const forced = forcedAttrValue == 'YES';
  2013.     const sampleRate = type == 'audio' ? this.getSampleRate_(firstTag) : null;
  2014.     // TODO: Should we take into account some of the currently ignored
  2015.     // attributes: INSTREAM-ID, Attribute descriptions: https://bit.ly/2lpjOhj
  2016.     const streamInfo = this.createStreamInfo_(
  2017.         streamId, verbatimMediaPlaylistUris, codecs, type, language,
  2018.         primary, name, channelsCount, /* closedCaptions= */ null,
  2019.         characteristics, forced, sampleRate, spatialAudio);
  2020.     if (streamInfo.stream) {
  2021.       streamInfo.stream.groupId = globalGroupId;
  2022.     }
  2023.     if (this.groupIdToStreamInfosMap_.has(globalGroupId)) {
  2024.       this.groupIdToStreamInfosMap_.get(globalGroupId).push(streamInfo);
  2025.     } else {
  2026.       this.groupIdToStreamInfosMap_.set(globalGroupId, [streamInfo]);
  2027.     }
  2029.     this.uriToStreamInfosMap_.set(key, streamInfo);
  2030.     return streamInfo;
  2031.   }
  2033.   /**
  2034.    * Parse EXT-X-IMAGE-STREAM-INF media tag into a Stream object.
  2035.    *
  2036.    * @param {shaka.hls.Tag} tag
  2037.    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
  2038.    * @private
  2039.    */
  2040.   async createStreamInfoFromImageTag_(tag) {
  2041.     goog.asserts.assert(tag.name == 'EXT-X-IMAGE-STREAM-INF',
  2042.         'Should only be called on image tags!');
  2043.     /** @type {string} */
  2044.     const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
  2046.     const verbatimImagePlaylistUri = tag.getRequiredAttrValue('URI');
  2047.     const codecs = tag.getAttributeValue('CODECS', 'jpeg') || '';
  2049.     // Check if the stream has already been created as part of another Variant
  2050.     // and return it if it has.
  2051.     if (this.uriToStreamInfosMap_.has(verbatimImagePlaylistUri)) {
  2052.       return this.uriToStreamInfosMap_.get(verbatimImagePlaylistUri);
  2053.     }
  2055.     const language = tag.getAttributeValue('LANGUAGE');
  2056.     const name = tag.getAttributeValue('NAME');
  2058.     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
  2060.     const streamInfo = this.createStreamInfo_(
  2061.         this.globalId_++, [verbatimImagePlaylistUri], codecs, type, language,
  2062.         /* primary= */ false, name, /* channelsCount= */ null,
  2063.         /* closedCaptions= */ null, characteristics, /* forced= */ false,
  2064.         /* sampleRate= */ null, /* spatialAudio= */ false);
  2066.     // Parse misc attributes.
  2067.     const resolution = tag.getAttributeValue('RESOLUTION');
  2068.     if (resolution) {
  2069.       // The RESOLUTION tag represents the resolution of a single thumbnail, not
  2070.       // of the entire sheet at once (like we expect in the output).
  2071.       // So multiply by the layout size.
  2073.       // Since we need to have generated the segment index for this, we can't
  2074.       // lazy-load in this situation.
  2075.       await streamInfo.stream.createSegmentIndex();
  2077.       const reference = streamInfo.stream.segmentIndex.get(0);
  2078.       const layout = reference.getTilesLayout();
  2079.       if (layout) {
  2080.         streamInfo.stream.width =
  2081.             Number(resolution.split('x')[0]) * Number(layout.split('x')[0]);
  2082.         streamInfo.stream.height =
  2083.             Number(resolution.split('x')[1]) * Number(layout.split('x')[1]);
  2084.         // TODO: What happens if there are multiple grids, with different
  2085.         // layout sizes, inside this image stream?
  2086.       }
  2087.     }
  2088.     const bandwidth = tag.getAttributeValue('BANDWIDTH');
  2089.     if (bandwidth) {
  2090.       streamInfo.stream.bandwidth = Number(bandwidth);
  2091.     }
  2093.     this.uriToStreamInfosMap_.set(verbatimImagePlaylistUri, streamInfo);
  2094.     return streamInfo;
  2095.   }
  2097.   /**
  2098.    * Parse EXT-X-I-FRAME-STREAM-INF media tag into a Stream object.
  2099.    *
  2100.    * @param {shaka.hls.Tag} tag
  2101.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2102.    * @private
  2103.    */
  2104.   createStreamInfoFromIframeTag_(tag) {
  2105.     goog.asserts.assert(tag.name == 'EXT-X-I-FRAME-STREAM-INF',
  2106.         'Should only be called on iframe tags!');
  2107.     /** @type {string} */
  2108.     const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
  2110.     const verbatimIFramePlaylistUri = tag.getRequiredAttrValue('URI');
  2111.     const codecs = tag.getAttributeValue('CODECS') || '';
  2113.     // Check if the stream has already been created as part of another Variant
  2114.     // and return it if it has.
  2115.     if (this.uriToStreamInfosMap_.has(verbatimIFramePlaylistUri)) {
  2116.       return this.uriToStreamInfosMap_.get(verbatimIFramePlaylistUri);
  2117.     }
  2119.     const language = tag.getAttributeValue('LANGUAGE');
  2120.     const name = tag.getAttributeValue('NAME');
  2122.     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
  2124.     const streamInfo = this.createStreamInfo_(
  2125.         this.globalId_++, [verbatimIFramePlaylistUri], codecs, type, language,
  2126.         /* primary= */ false, name, /* channelsCount= */ null,
  2127.         /* closedCaptions= */ null, characteristics, /* forced= */ false,
  2128.         /* sampleRate= */ null, /* spatialAudio= */ false);
  2130.     // Parse misc attributes.
  2131.     const resolution = tag.getAttributeValue('RESOLUTION');
  2132.     const [width, height] = resolution ? resolution.split('x') : [null, null];
  2133.     streamInfo.stream.width = Number(width) || undefined;
  2134.     streamInfo.stream.height = Number(height) || undefined;
  2135.     const bandwidth = tag.getAttributeValue('BANDWIDTH');
  2136.     if (bandwidth) {
  2137.       streamInfo.stream.bandwidth = Number(bandwidth);
  2138.     }
  2140.     this.uriToStreamInfosMap_.set(verbatimIFramePlaylistUri, streamInfo);
  2141.     return streamInfo;
  2142.   }
  2144.   /**
  2145.    * Parse an EXT-X-STREAM-INF media tag into a Stream object.
  2146.    *
  2147.    * @param {!Array.<!shaka.hls.Tag>} tags
  2148.    * @param {!Array.<string>} allCodecs
  2149.    * @param {string} type
  2150.    * @param {?string} language
  2151.    * @param {?string} name
  2152.    * @param {?number} channelsCount
  2153.    * @param {?string} characteristics
  2154.    * @param {?number} sampleRate
  2155.    * @param {boolean} spatialAudio
  2156.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2157.    * @private
  2158.    */
  2159.   createStreamInfoFromVariantTags_(tags, allCodecs, type, language, name,
  2160.       channelsCount, characteristics, sampleRate, spatialAudio) {
  2161.     const streamId = this.globalId_++;
  2162.     const verbatimMediaPlaylistUris = [];
  2163.     for (const tag of tags) {
  2164.       goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  2165.           'Should only be called on variant tags!');
  2166.       const uri = tag.getRequiredAttrValue('URI');
  2167.       const pathwayId = tag.getAttributeValue('PATHWAY-ID');
  2168.       if (this.contentSteeringManager_ && pathwayId) {
  2169.         this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
  2170.       }
  2171.       verbatimMediaPlaylistUris.push(uri);
  2172.     }
  2174.     const key = verbatimMediaPlaylistUris.sort().join(',');
  2175.     if (this.uriToStreamInfosMap_.has(key)) {
  2176.       return this.uriToStreamInfosMap_.get(key);
  2177.     }
  2179.     const closedCaptions = this.getClosedCaptions_(tags[0], type);
  2180.     const codecs = shaka.util.ManifestParserUtils.guessCodecs(type, allCodecs);
  2181.     const streamInfo = this.createStreamInfo_(
  2182.         streamId, verbatimMediaPlaylistUris, codecs, type, language,
  2183.         /* primary= */ false, name, channelsCount, closedCaptions,
  2184.         characteristics, /* forced= */ false, sampleRate,
  2185.         /* spatialAudio= */ false);
  2187.     this.uriToStreamInfosMap_.set(key, streamInfo);
  2188.     return streamInfo;
  2189.   }
  2192.   /**
  2193.    * @param {number} streamId
  2194.    * @param {!Array.<string>} verbatimMediaPlaylistUris
  2195.    * @param {string} codecs
  2196.    * @param {string} type
  2197.    * @param {?string} languageValue
  2198.    * @param {boolean} primary
  2199.    * @param {?string} name
  2200.    * @param {?number} channelsCount
  2201.    * @param {Map.<string, string>} closedCaptions
  2202.    * @param {?string} characteristics
  2203.    * @param {boolean} forced
  2204.    * @param {?number} sampleRate
  2205.    * @param {boolean} spatialAudio
  2206.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2207.    * @private
  2208.    */
  2209.   createStreamInfo_(streamId, verbatimMediaPlaylistUris, codecs, type,
  2210.       languageValue, primary, name, channelsCount, closedCaptions,
  2211.       characteristics, forced, sampleRate, spatialAudio) {
  2212.     // TODO: Refactor, too many parameters
  2214.     // This stream is lazy-loaded inside the createSegmentIndex function.
  2215.     // So we start out with a stream object that does not contain the actual
  2216.     // segment index, then download when createSegmentIndex is called.
  2217.     const stream = this.makeStreamObject_(streamId, codecs, type,
  2218.         languageValue, primary, name, channelsCount, closedCaptions,
  2219.         characteristics, forced, sampleRate, spatialAudio);
  2221.     const redirectUris = [];
  2222.     const getUris = () => {
  2223.       if (this.contentSteeringManager_ &&
  2224.           verbatimMediaPlaylistUris.length > 1) {
  2225.         return this.contentSteeringManager_.getLocations(streamId);
  2226.       }
  2227.       return redirectUris.concat(shaka.hls.Utils.constructUris(
  2228.           [this.masterPlaylistUri_], verbatimMediaPlaylistUris,
  2229.           this.globalVariables_));
  2230.     };
  2231.     const streamInfo = {
  2232.       stream,
  2233.       type,
  2234.       redirectUris,
  2235.       getUris,
  2236.       // These values are filled out or updated after lazy-loading:
  2237.       minTimestamp: 0,
  2238.       maxTimestamp: 0,
  2239.       mediaSequenceToStartTime: new Map(),
  2240.       canSkipSegments: false,
  2241.       canBlockReload: false,
  2242.       hasEndList: false,
  2243.       firstSequenceNumber: -1,
  2244.       nextMediaSequence: -1,
  2245.       nextPart: -1,
  2246.       loadedOnce: false,
  2247.     };
  2249.     /** @param {!AbortSignal} abortSignal */
  2250.     const downloadSegmentIndex = async (abortSignal) => {
  2251.       const uris = streamInfo.getUris();
  2252.       // Download the actual manifest.
  2253.       const response = await this.requestManifest_(
  2254.           streamInfo.getUris(), /* isPlaylist= */ true);
  2255.       if (abortSignal.aborted) {
  2256.         return;
  2257.       }
  2259.       // Record the final URI after redirects.
  2260.       const responseUri = response.uri;
  2261.       if (responseUri != response.originalUri && !uris.includes(responseUri)) {
  2262.         redirectUris.push(responseUri);
  2263.       }
  2265.       // Record the redirected, final URI of this media playlist when we parse
  2266.       // it.
  2267.       /** @type {!shaka.hls.Playlist} */
  2268.       const playlist = this.manifestTextParser_.parsePlaylist(response.data);
  2270.       let mimeType = undefined;
  2272.       // If no codec info was provided in the manifest and codec guessing is
  2273.       // disabled we try to get necessary info from the media data.
  2274.       if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
  2275.         const basicInfo =
  2276.             await this.getMediaPlaylistBasicInfo_(playlist, getUris);
  2278.         goog.asserts.assert(
  2279.             type === basicInfo.type, 'Media types should match!');
  2281.         mimeType = basicInfo.mimeType;
  2282.         codecs = basicInfo.codecs;
  2283.       }
  2285.       const wasLive = this.isLive_();
  2286.       const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
  2287.           streamId, playlist, getUris, responseUri, codecs,
  2288.           type, languageValue, primary, name, channelsCount, closedCaptions,
  2289.           characteristics, forced, sampleRate, spatialAudio, mimeType);
  2290.       if (abortSignal.aborted) {
  2291.         return;
  2292.       }
  2294.       const realStream = realStreamInfo.stream;
  2296.       if (this.isLive_() && !wasLive) {
  2297.         // Now that we know that the presentation is live, convert the timeline
  2298.         // to live.
  2299.         this.changePresentationTimelineToLive_(playlist);
  2300.       }
  2302.       // Copy values from the real stream info to our initial one.
  2303.       streamInfo.minTimestamp = realStreamInfo.minTimestamp;
  2304.       streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
  2305.       streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
  2306.       streamInfo.canBlockReload = realStreamInfo.canBlockReload;
  2307.       streamInfo.hasEndList = realStreamInfo.hasEndList;
  2308.       streamInfo.mediaSequenceToStartTime =
  2309.           realStreamInfo.mediaSequenceToStartTime;
  2310.       streamInfo.nextMediaSequence = realStreamInfo.nextMediaSequence;
  2311.       streamInfo.nextPart = realStreamInfo.nextPart;
  2312.       streamInfo.loadedOnce = true;
  2313.       stream.segmentIndex = realStream.segmentIndex;
  2314.       stream.encrypted = realStream.encrypted;
  2315.       stream.drmInfos = realStream.drmInfos;
  2316.       stream.keyIds = realStream.keyIds;
  2317.       stream.mimeType = realStream.mimeType;
  2318.       stream.bandwidth = stream.bandwidth || realStream.bandwidth;
  2319.       stream.codecs = stream.codecs || realStream.codecs;
  2320.       this.setFullTypeForStream_(stream);
  2322.       // Since we lazy-loaded this content, the player may need to create new
  2323.       // sessions for the DRM info in this stream.
  2324.       if (stream.drmInfos.length) {
  2325.         this.playerInterface_.newDrmInfo(stream);
  2326.       }
  2328.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2329.       if (type == ContentType.VIDEO || type == ContentType.AUDIO) {
  2330.         for (const otherStreamInfo of this.uriToStreamInfosMap_.values()) {
  2331.           if (!otherStreamInfo.loadedOnce && otherStreamInfo.type == type) {
  2332.             // To aid manifest filtering, assume before loading that all video
  2333.             // renditions have the same MIME type.  (And likewise for audio.)
  2334.             otherStreamInfo.stream.mimeType = realStream.mimeType;
  2335.             this.setFullTypeForStream_(otherStreamInfo.stream);
  2336.           }
  2337.         }
  2338.       }
  2340.       if (type == ContentType.TEXT) {
  2341.         const firstSegment = realStream.segmentIndex.get(0);
  2342.         if (firstSegment && firstSegment.initSegmentReference) {
  2343.           stream.mimeType = 'application/mp4';
  2344.           this.setFullTypeForStream_(stream);
  2345.         }
  2346.       }
  2348.       // Add finishing touches to the stream that can only be done once we have
  2349.       // more full context on the media as a whole.
  2350.       if (this.hasEnoughInfoToFinalizeStreams_()) {
  2351.         if (!this.streamsFinalized_) {
  2352.           // Mark this manifest as having been finalized, so we don't go through
  2353.           // this whole process of finishing touches a second time.
  2354.           this.streamsFinalized_ = true;
  2355.           // Finalize all of the currently-loaded streams.
  2356.           const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  2357.           const activeStreamInfos =
  2358.               streamInfos.filter((s) => s.stream.segmentIndex);
  2359.           this.finalizeStreams_(activeStreamInfos);
  2360.           // With the addition of this new stream, we now have enough info to
  2361.           // figure out how long the streams should be. So process all streams
  2362.           // we have downloaded up until this point.
  2363.           this.determineDuration_();
  2364.           // Finally, start the update timer, if this asset has been determined
  2365.           // to be a livestream.
  2366.           const delay = this.getUpdatePlaylistDelay_();
  2367.           if (delay > 0) {
  2368.             this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
  2369.           }
  2370.         } else {
  2371.           // We don't need to go through the full process; just finalize this
  2372.           // single stream.
  2373.           this.finalizeStreams_([streamInfo]);
  2374.         }
  2375.       }
  2376.     };
  2378.     /** @type {Promise} */
  2379.     let creationPromise = null;
  2380.     /** @type {!AbortController} */
  2381.     let abortController = new AbortController();
  2382.     const safeCreateSegmentIndex = () => {
  2383.       // An operation is already in progress.  The second and subsequent
  2384.       // callers receive the same Promise as the first caller, and only one
  2385.       // download operation will occur.
  2386.       if (creationPromise) {
  2387.         return creationPromise;
  2388.       }
  2390.       // Create a new AbortController to be able to cancel this specific
  2391.       // download.
  2392.       abortController = new AbortController();
  2394.       // Create a Promise tied to the outcome of downloadSegmentIndex().  If
  2395.       // downloadSegmentIndex is rejected, creationPromise will also be
  2396.       // rejected.
  2397.       creationPromise = new Promise((resolve) => {
  2398.         resolve(downloadSegmentIndex(abortController.signal));
  2399.       });
  2400.       return creationPromise;
  2401.     };
  2403.     stream.createSegmentIndex = safeCreateSegmentIndex;
  2405.     stream.closeSegmentIndex = () => {
  2406.       // If we're mid-creation, cancel it.
  2407.       if (creationPromise && !stream.segmentIndex) {
  2408.         abortController.abort();
  2409.       }
  2410.       // If we have a segment index, release it.
  2411.       if (stream.segmentIndex) {
  2412.         stream.segmentIndex.release();
  2413.         stream.segmentIndex = null;
  2414.       }
  2415.       // Clear the creation Promise so that a new operation can begin.
  2416.       creationPromise = null;
  2417.     };
  2419.     return streamInfo;
  2420.   }
  2422.   /**
  2423.    * @return {number}
  2424.    * @private
  2425.    */
  2426.   getMinDuration_() {
  2427.     let minDuration = Infinity;
  2428.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  2429.       if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text') {
  2430.         // Since everything is already offset to 0 (either by sync or by being
  2431.         // VOD), only maxTimestamp is necessary to compute the duration.
  2432.         minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
  2433.       }
  2434.     }
  2435.     return minDuration;
  2436.   }
  2438.   /**
  2439.    * @return {number}
  2440.    * @private
  2441.    */
  2442.   getLiveDuration_() {
  2443.     let maxTimestamp = Infinity;
  2444.     let minTimestamp = Infinity;
  2445.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  2446.       if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text') {
  2447.         maxTimestamp = Math.min(maxTimestamp, streamInfo.maxTimestamp);
  2448.         minTimestamp = Math.min(minTimestamp, streamInfo.minTimestamp);
  2449.       }
  2450.     }
  2451.     return maxTimestamp - minTimestamp;
  2452.   }
  2454.   /**
  2455.    * @param {!Array.<!shaka.extern.Stream>} streams
  2456.    * @private
  2457.    */
  2458.   notifySegmentsForStreams_(streams) {
  2459.     const references = [];
  2460.     for (const stream of streams) {
  2461.       if (!stream.segmentIndex) {
  2462.         // The stream was closed since the list of streams was built.
  2463.         continue;
  2464.       }
  2465.       stream.segmentIndex.forEachTopLevelReference((reference) => {
  2466.         references.push(reference);
  2467.       });
  2468.     }
  2469.     this.presentationTimeline_.notifySegments(references);
  2470.   }
  2472.   /**
  2473.    * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  2474.    * @private
  2475.    */
  2476.   finalizeStreams_(streamInfos) {
  2477.     if (!this.isLive_()) {
  2478.       const minDuration = this.getMinDuration_();
  2479.       for (const streamInfo of streamInfos) {
  2480.         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
  2481.       }
  2482.     }
  2483.     this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
  2484.     if (this.config_.hls.ignoreManifestProgramDateTime) {
  2485.       this.syncStreamsWithSequenceNumber_(streamInfos);
  2486.     } else {
  2487.       this.syncStreamsWithProgramDateTime_(streamInfos);
  2488.       if (this.config_.hls.ignoreManifestProgramDateTimeForTypes.length > 0) {
  2489.         this.syncStreamsWithSequenceNumber_(streamInfos);
  2490.       }
  2491.     }
  2492.   }
  2494.   /**
  2495.    * @param {string} type
  2496.    * @return {boolean}
  2497.    * @private
  2498.    */
  2499.   ignoreManifestProgramDateTimeFor_(type) {
  2500.     if (this.config_.hls.ignoreManifestProgramDateTime) {
  2501.       return true;
  2502.     }
  2503.     const forTypes = this.config_.hls.ignoreManifestProgramDateTimeForTypes;
  2504.     return forTypes.includes(type);
  2505.   }
  2507.   /**
  2508.    * There are some values on streams that can only be set once we know about
  2509.    * both the video and audio content, if present.
  2510.    * This checks if there is at least one video downloaded (if the media has
  2511.    * video), and that there is at least one audio downloaded (if the media has
  2512.    * audio).
  2513.    * @return {boolean}
  2514.    * @private
  2515.    */
  2516.   hasEnoughInfoToFinalizeStreams_() {
  2517.     if (!this.manifest_) {
  2518.       return false;
  2519.     }
  2520.     const videos = [];
  2521.     const audios = [];
  2522.     for (const variant of this.manifest_.variants) {
  2523.       if (variant.video) {
  2524.         videos.push(variant.video);
  2525.       }
  2526.       if (variant.audio) {
  2527.         audios.push(variant.audio);
  2528.       }
  2529.     }
  2530.     if (videos.length > 0 && !videos.some((stream) => stream.segmentIndex)) {
  2531.       return false;
  2532.     }
  2533.     if (audios.length > 0 && !audios.some((stream) => stream.segmentIndex)) {
  2534.       return false;
  2535.     }
  2536.     return true;
  2537.   }
  2539.   /**
  2540.    * @param {number} streamId
  2541.    * @param {!shaka.hls.Playlist} playlist
  2542.    * @param {function():!Array.<string>} getUris
  2543.    * @param {string} responseUri
  2544.    * @param {string} codecs
  2545.    * @param {string} type
  2546.    * @param {?string} languageValue
  2547.    * @param {boolean} primary
  2548.    * @param {?string} name
  2549.    * @param {?number} channelsCount
  2550.    * @param {Map.<string, string>} closedCaptions
  2551.    * @param {?string} characteristics
  2552.    * @param {boolean} forced
  2553.    * @param {?number} sampleRate
  2554.    * @param {boolean} spatialAudio
  2555.    * @param {(string|undefined)} mimeType
  2556.    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
  2557.    * @private
  2558.    */
  2559.   async convertParsedPlaylistIntoStreamInfo_(streamId, playlist,
  2560.       getUris, responseUri, codecs, type, languageValue, primary, name,
  2561.       channelsCount, closedCaptions, characteristics, forced, sampleRate,
  2562.       spatialAudio, mimeType = undefined) {
  2563.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  2564.       // EXT-X-MEDIA and EXT-X-IMAGE-STREAM-INF tags should point to media
  2565.       // playlists.
  2566.       throw new shaka.util.Error(
  2567.           shaka.util.Error.Severity.CRITICAL,
  2568.           shaka.util.Error.Category.MANIFEST,
  2569.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  2570.     }
  2572.     /** @type {!Array.<!shaka.hls.Tag>} */
  2573.     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  2574.         'EXT-X-DEFINE');
  2576.     const mediaVariables =
  2577.         this.parseMediaVariables_(variablesTags, responseUri);
  2579.     goog.asserts.assert(playlist.segments != null,
  2580.         'Media playlist should have segments!');
  2582.     this.determinePresentationType_(playlist);
  2584.     if (this.isLive_()) {
  2585.       this.determineLastTargetDuration_(playlist);
  2586.     }
  2588.     if (!mimeType) {
  2589.       mimeType = await this.guessMimeType_(type, codecs, playlist,
  2590.           mediaVariables, getUris);
  2591.     }
  2593.     const {drmInfos, keyIds, encrypted, aesEncrypted} =
  2594.         await this.parseDrmInfo_(playlist, mimeType, getUris, mediaVariables);
  2596.     if (encrypted && !drmInfos.length && !aesEncrypted) {
  2597.       throw new shaka.util.Error(
  2598.           shaka.util.Error.Severity.CRITICAL,
  2599.           shaka.util.Error.Category.MANIFEST,
  2600.           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
  2601.     }
  2603.     const stream = this.makeStreamObject_(streamId, codecs, type,
  2604.         languageValue, primary, name, channelsCount, closedCaptions,
  2605.         characteristics, forced, sampleRate, spatialAudio);
  2606.     stream.encrypted = encrypted;
  2607.     stream.drmInfos = drmInfos;
  2608.     stream.keyIds = keyIds;
  2609.     stream.mimeType = mimeType;
  2610.     this.setFullTypeForStream_(stream);
  2612.     const mediaSequenceToStartTime = this.isLive_() ?
  2613.         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
  2615.     const {segments, bandwidth} = this.createSegments_(
  2616.         playlist, stream, mediaSequenceToStartTime, mediaVariables, getUris,
  2617.         type);
  2618.     if (bandwidth) {
  2619.       stream.bandwidth = bandwidth;
  2620.     }
  2622.     // This new calculation is necessary for Low Latency streams.
  2623.     if (this.isLive_()) {
  2624.       this.determineLastTargetDuration_(playlist);
  2625.     }
  2627.     const firstStartTime = segments[0].startTime;
  2628.     const lastSegment = segments[segments.length - 1];
  2629.     const lastEndTime = lastSegment.endTime;
  2630.     /** @type {!shaka.media.SegmentIndex} */
  2631.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  2632.     stream.segmentIndex = segmentIndex;
  2634.     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
  2635.         playlist.tags, 'EXT-X-SERVER-CONTROL');
  2636.     const canSkipSegments = serverControlTag ?
  2637.           serverControlTag.getAttribute('CAN-SKIP-UNTIL') != null : false;
  2638.     const canBlockReload = serverControlTag ?
  2639.           serverControlTag.getAttribute('CAN-BLOCK-RELOAD') != null : false;
  2641.     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  2642.         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  2644.     const {nextMediaSequence, nextPart} =
  2645.         this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
  2647.     return {
  2648.       stream,
  2649.       type,
  2650.       redirectUris: [],
  2651.       getUris,
  2652.       minTimestamp: firstStartTime,
  2653.       maxTimestamp: lastEndTime,
  2654.       canSkipSegments,
  2655.       canBlockReload,
  2656.       hasEndList: false,
  2657.       firstSequenceNumber: -1,
  2658.       nextMediaSequence,
  2659.       nextPart,
  2660.       mediaSequenceToStartTime,
  2661.       loadedOnce: false,
  2662.     };
  2663.   }
  2665.   /**
  2666.    * Get the next msn and part
  2667.    *
  2668.    * @param {number} mediaSequenceNumber
  2669.    * @param {!Array.<!shaka.media.SegmentReference>} segments
  2670.    * @return {{nextMediaSequence: number, nextPart:number}}}
  2671.    * @private
  2672.    */
  2673.   getNextMediaSequenceAndPart_(mediaSequenceNumber, segments) {
  2674.     const currentMediaSequence = mediaSequenceNumber + segments.length - 1;
  2675.     let nextMediaSequence = currentMediaSequence;
  2676.     let nextPart = -1;
  2677.     if (!segments.length) {
  2678.       nextMediaSequence++;
  2679.       return {
  2680.         nextMediaSequence,
  2681.         nextPart,
  2682.       };
  2683.     }
  2684.     const lastSegment = segments[segments.length - 1];
  2685.     const partialReferences = lastSegment.partialReferences;
  2686.     if (!lastSegment.partialReferences.length) {
  2687.       nextMediaSequence++;
  2688.       if (lastSegment.hasByterangeOptimization()) {
  2689.         nextPart = 0;
  2690.       }
  2691.       return {
  2692.         nextMediaSequence,
  2693.         nextPart,
  2694.       };
  2695.     }
  2696.     nextPart = partialReferences.length - 1;
  2697.     const lastPartialReference =
  2698.         partialReferences[partialReferences.length - 1];
  2699.     if (!lastPartialReference.isPreload()) {
  2700.       nextMediaSequence++;
  2701.       nextPart = 0;
  2702.     }
  2703.     return {
  2704.       nextMediaSequence,
  2705.       nextPart,
  2706.     };
  2707.   }
  2710.   /**
  2711.    * Creates a stream object with the given parameters.
  2712.    * The parameters that are passed into here are only the things that can be
  2713.    * known without downloading the media playlist; other values must be set
  2714.    * manually on the object after creation.
  2715.    * @param {number} id
  2716.    * @param {string} codecs
  2717.    * @param {string} type
  2718.    * @param {?string} languageValue
  2719.    * @param {boolean} primary
  2720.    * @param {?string} name
  2721.    * @param {?number} channelsCount
  2722.    * @param {Map.<string, string>} closedCaptions
  2723.    * @param {?string} characteristics
  2724.    * @param {boolean} forced
  2725.    * @param {?number} sampleRate
  2726.    * @param {boolean} spatialAudio
  2727.    * @return {!shaka.extern.Stream}
  2728.    * @private
  2729.    */
  2730.   makeStreamObject_(id, codecs, type, languageValue, primary, name,
  2731.       channelsCount, closedCaptions, characteristics, forced, sampleRate,
  2732.       spatialAudio) {
  2733.     // Fill out a "best-guess" mimeType, for now. It will be replaced once the
  2734.     // stream is lazy-loaded.
  2735.     const mimeType = this.guessMimeTypeBeforeLoading_(type, codecs) ||
  2736.         this.guessMimeTypeFallback_(type);
  2737.     const roles = [];
  2738.     if (characteristics) {
  2739.       for (const characteristic of characteristics.split(',')) {
  2740.         roles.push(characteristic);
  2741.       }
  2742.     }
  2744.     let kind = undefined;
  2745.     let accessibilityPurpose = null;
  2746.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  2747.       if (roles.includes('public.accessibility.transcribes-spoken-dialog') &&
  2748.           roles.includes('public.accessibility.describes-music-and-sound')) {
  2749.         kind = shaka.util.ManifestParserUtils.TextStreamKind.CLOSED_CAPTION;
  2750.       } else {
  2751.         kind = shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE;
  2752.       }
  2753.     } else {
  2754.       if (roles.includes('public.accessibility.describes-video')) {
  2755.         accessibilityPurpose =
  2756.               shaka.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED;
  2757.       }
  2758.     }
  2760.     // If there are no roles, and we have defaulted to the subtitle "kind" for
  2761.     // this track, add the implied subtitle role.
  2762.     if (!roles.length &&
  2763.         kind === shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE) {
  2764.       roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
  2765.     }
  2767.     const stream = {
  2768.       id: this.globalId_++,
  2769.       originalId: name,
  2770.       groupId: null,
  2771.       createSegmentIndex: () => Promise.resolve(),
  2772.       segmentIndex: null,
  2773.       mimeType,
  2774.       codecs,
  2775.       kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
  2776.           shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
  2777.       encrypted: false,
  2778.       drmInfos: [],
  2779.       keyIds: new Set(),
  2780.       language: this.getLanguage_(languageValue),
  2781.       originalLanguage: languageValue,
  2782.       label: name,  // For historical reasons, since before "originalId".
  2783.       type,
  2784.       primary,
  2785.       // TODO: trick mode
  2786.       trickModeVideo: null,
  2787.       emsgSchemeIdUris: null,
  2788.       frameRate: undefined,
  2789.       pixelAspectRatio: undefined,
  2790.       width: undefined,
  2791.       height: undefined,
  2792.       bandwidth: undefined,
  2793.       roles,
  2794.       forced,
  2795.       channelsCount,
  2796.       audioSamplingRate: sampleRate,
  2797.       spatialAudio,
  2798.       closedCaptions,
  2799.       hdr: undefined,
  2800.       videoLayout: undefined,
  2801.       tilesLayout: undefined,
  2802.       accessibilityPurpose: accessibilityPurpose,
  2803.       external: false,
  2804.       fastSwitching: false,
  2805.       fullMimeTypes: new Set(),
  2806.     };
  2807.     this.setFullTypeForStream_(stream);
  2808.     return stream;
  2809.   }
  2811.   /**
  2812.    * @param {!shaka.hls.Playlist} playlist
  2813.    * @param {string} mimeType
  2814.    * @param {function():!Array.<string>} getUris
  2815.    * @param {?Map.<string, string>=} variables
  2816.    * @return {Promise.<{
  2817.    *   drmInfos: !Array.<shaka.extern.DrmInfo>,
  2818.    *   keyIds: !Set.<string>,
  2819.    *   encrypted: boolean,
  2820.    *   aesEncrypted: boolean
  2821.    * }>}
  2822.    * @private
  2823.    */
  2824.   async parseDrmInfo_(playlist, mimeType, getUris, variables) {
  2825.     /** @type {!Map<!shaka.hls.Tag, ?shaka.media.InitSegmentReference>} */
  2826.     const drmTagsMap = new Map();
  2827.     if (playlist.segments) {
  2828.       for (const segment of playlist.segments) {
  2829.         const segmentKeyTags = shaka.hls.Utils.filterTagsByName(segment.tags,
  2830.             'EXT-X-KEY');
  2831.         let initSegmentRef = null;
  2832.         if (segmentKeyTags.length) {
  2833.           initSegmentRef = this.getInitSegmentReference_(playlist,
  2834.               segment.tags, getUris, variables);
  2835.           for (const segmentKeyTag of segmentKeyTags) {
  2836.             drmTagsMap.set(segmentKeyTag, initSegmentRef);
  2837.           }
  2838.         }
  2839.       }
  2840.     }
  2842.     let encrypted = false;
  2843.     let aesEncrypted = false;
  2845.     /** @type {!Array.<shaka.extern.DrmInfo>}*/
  2846.     const drmInfos = [];
  2847.     const keyIds = new Set();
  2849.     for (const [key, value] of drmTagsMap) {
  2850.       const drmTag = /** @type {!shaka.hls.Tag} */ (key);
  2851.       const initSegmentRef =
  2852.       /** @type {?shaka.media.InitSegmentReference} */ (value);
  2853.       const method = drmTag.getRequiredAttrValue('METHOD');
  2854.       if (method != 'NONE') {
  2855.         encrypted = true;
  2857.         // According to the HLS spec, KEYFORMAT is optional and implicitly
  2858.         // defaults to "identity".
  2859.         // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
  2860.         const keyFormat =
  2861.             drmTag.getAttributeValue('KEYFORMAT') || 'identity';
  2862.         let drmInfo = null;
  2864.         if (this.isAesMethod_(method)) {
  2865.           // These keys are handled separately.
  2866.           aesEncrypted = true;
  2867.           continue;
  2868.         } else if (keyFormat == 'identity') {
  2869.           // eslint-disable-next-line no-await-in-loop
  2870.           drmInfo = await this.identityDrmParser_(
  2871.               drmTag, mimeType, getUris, initSegmentRef, variables);
  2872.         } else {
  2873.           const drmParser =
  2874.               shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  2875.           drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
  2876.         }
  2877.         if (drmInfo) {
  2878.           if (drmInfo.keyIds) {
  2879.             for (const keyId of drmInfo.keyIds) {
  2880.               keyIds.add(keyId);
  2881.             }
  2882.           }
  2883.           drmInfos.push(drmInfo);
  2884.         } else {
  2885.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  2886.         }
  2887.       }
  2888.     }
  2890.     return {drmInfos, keyIds, encrypted, aesEncrypted};
  2891.   }
  2893.   /**
  2894.    * @param {!shaka.hls.Tag} drmTag
  2895.    * @param {!shaka.hls.Playlist} playlist
  2896.    * @param {function():!Array.<string>} getUris
  2897.    * @param {?Map.<string, string>=} variables
  2898.    * @return {!shaka.extern.aesKey}
  2899.    * @private
  2900.    */
  2901.   parseAESDrmTag_(drmTag, playlist, getUris, variables) {
  2902.     // Check if the Web Crypto API is available.
  2903.     if (!window.crypto || !window.crypto.subtle) {
  2904.       shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
  2905.           'AES. (Web Crypto only exists in secure origins like https)');
  2906.       throw new shaka.util.Error(
  2907.           shaka.util.Error.Severity.CRITICAL,
  2908.           shaka.util.Error.Category.MANIFEST,
  2909.           shaka.util.Error.Code.NO_WEB_CRYPTO_API);
  2910.     }
  2912.     // HLS RFC 8216 Section 5.2:
  2913.     // An EXT-X-KEY tag with a KEYFORMAT of "identity" that does not have an IV
  2914.     // attribute indicates that the Media Sequence Number is to be used as the
  2915.     // IV when decrypting a Media Segment, by putting its big-endian binary
  2916.     // representation into a 16-octet (128-bit) buffer and padding (on the left)
  2917.     // with zeros.
  2918.     let firstMediaSequenceNumber = 0;
  2919.     let iv;
  2920.     const ivHex = drmTag.getAttributeValue('IV', '');
  2921.     if (!ivHex) {
  2922.       // Media Sequence Number will be used as IV.
  2923.       firstMediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  2924.           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  2925.     } else {
  2926.       // Exclude 0x at the start of string.
  2927.       iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
  2928.       if (iv.byteLength != 16) {
  2929.         throw new shaka.util.Error(
  2930.             shaka.util.Error.Severity.CRITICAL,
  2931.             shaka.util.Error.Category.MANIFEST,
  2932.             shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
  2933.       }
  2934.     }
  2936.     const aesKeyInfoKey = `${drmTag.toString()}-${firstMediaSequenceNumber}`;
  2937.     if (!this.aesKeyInfoMap_.has(aesKeyInfoKey)) {
  2938.       // Default AES-128
  2939.       const keyInfo = {
  2940.         bitsKey: 128,
  2941.         blockCipherMode: 'CBC',
  2942.         iv,
  2943.         firstMediaSequenceNumber,
  2944.       };
  2946.       const method = drmTag.getRequiredAttrValue('METHOD');
  2947.       switch (method) {
  2948.         case 'AES-256':
  2949.           keyInfo.bitsKey = 256;
  2950.           break;
  2951.         case 'AES-256-CTR':
  2952.           keyInfo.bitsKey = 256;
  2953.           keyInfo.blockCipherMode = 'CTR';
  2954.           break;
  2955.       }
  2957.       // Don't download the key object until the segment is parsed, to avoid a
  2958.       // startup delay for long manifests with lots of keys.
  2959.       keyInfo.fetchKey = async () => {
  2960.         const keyUris = shaka.hls.Utils.constructSegmentUris(
  2961.             getUris(), drmTag.getRequiredAttrValue('URI'), variables);
  2963.         const keyMapKey = keyUris.sort().join('');
  2964.         if (!this.aesKeyMap_.has(keyMapKey)) {
  2965.           const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  2966.           const request = shaka.net.NetworkingEngine.makeRequest(
  2967.               keyUris, this.config_.retryParameters);
  2968.           const keyResponse = this.makeNetworkRequest_(request, requestType);
  2969.           this.aesKeyMap_.set(keyMapKey, keyResponse);
  2970.         }
  2971.         const keyResponse = await this.aesKeyMap_.get(keyMapKey);
  2973.         // keyResponse.status is undefined when URI is "data:text/plain;base64,"
  2974.         if (!keyResponse.data ||
  2975.             keyResponse.data.byteLength != (keyInfo.bitsKey / 8)) {
  2976.           throw new shaka.util.Error(
  2977.               shaka.util.Error.Severity.CRITICAL,
  2978.               shaka.util.Error.Category.MANIFEST,
  2979.               shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
  2980.         }
  2982.         const algorithm = {
  2983.           name: keyInfo.blockCipherMode == 'CTR' ? 'AES-CTR' : 'AES-CBC',
  2984.           length: keyInfo.bitsKey,
  2985.         };
  2986.         keyInfo.cryptoKey = await window.crypto.subtle.importKey(
  2987.             'raw', keyResponse.data, algorithm, true, ['decrypt']);
  2988.         keyInfo.fetchKey = undefined; // No longer needed.
  2989.       };
  2990.       this.aesKeyInfoMap_.set(aesKeyInfoKey, keyInfo);
  2991.     }
  2992.     return this.aesKeyInfoMap_.get(aesKeyInfoKey);
  2993.   }
  2996.   /**
  2997.    * @param {!shaka.hls.Playlist} playlist
  2998.    * @private
  2999.    */
  3000.   determinePresentationType_(playlist) {
  3001.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  3002.     const presentationTypeTag =
  3003.         shaka.hls.Utils.getFirstTagWithName(playlist.tags,
  3004.             'EXT-X-PLAYLIST-TYPE');
  3005.     const endListTag =
  3006.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  3008.     const isVod = (presentationTypeTag && presentationTypeTag.value == 'VOD') ||
  3009.         endListTag;
  3010.     const isEvent = presentationTypeTag &&
  3011.         presentationTypeTag.value == 'EVENT' && !isVod;
  3012.     const isLive = !isVod && !isEvent;
  3014.     if (isVod) {
  3015.       this.setPresentationType_(PresentationType.VOD);
  3016.     } else {
  3017.       // If it's not VOD, it must be presentation type LIVE or an ongoing EVENT.
  3018.       if (isLive) {
  3019.         this.setPresentationType_(PresentationType.LIVE);
  3020.       } else {
  3021.         this.setPresentationType_(PresentationType.EVENT);
  3022.       }
  3023.     }
  3024.   }
  3027.   /**
  3028.    * @param {!shaka.hls.Playlist} playlist
  3029.    * @private
  3030.    */
  3031.   determineLastTargetDuration_(playlist) {
  3032.     let lastTargetDuration = Infinity;
  3033.     const segments = playlist.segments;
  3034.     if (segments.length) {
  3035.       let segmentIndex = segments.length - 1;
  3036.       while (segmentIndex >= 0) {
  3037.         const segment = segments[segmentIndex];
  3038.         const extinfTag =
  3039.             shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXTINF');
  3040.         if (extinfTag) {
  3041.           // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  3042.           // We're interested in the duration part.
  3043.           const extinfValues = extinfTag.value.split(',');
  3044.           lastTargetDuration = Number(extinfValues[0]);
  3045.           break;
  3046.         }
  3047.         segmentIndex--;
  3048.       }
  3049.     }
  3051.     const targetDurationTag = this.getRequiredTag_(playlist.tags,
  3052.         'EXT-X-TARGETDURATION');
  3053.     const targetDuration = Number(targetDurationTag.value);
  3054.     const partialTargetDurationTag =
  3055.       shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-PART-INF');
  3056.     if (partialTargetDurationTag) {
  3057.       this.partialTargetDuration_ = Number(
  3058.           partialTargetDurationTag.getRequiredAttrValue('PART-TARGET'));
  3059.     }
  3060.     // Get the server-recommended min distance from the live edge.
  3061.     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
  3062.         playlist.tags, 'EXT-X-SERVER-CONTROL');
  3063.     // According to the HLS spec, updates should not happen more often than
  3064.     // once in targetDuration.  It also requires us to only update the active
  3065.     // variant.  We might implement that later, but for now every variant
  3066.     // will be updated.  To get the update period, choose the smallest
  3067.     // targetDuration value across all playlists.
  3068.     // 1. Update the shortest one to use as update period and segment
  3069.     // availability time (for LIVE).
  3070.     if (this.lowLatencyMode_ && this.partialTargetDuration_) {
  3071.       // For low latency streaming, use the partial segment target duration.
  3072.       if (this.lowLatencyByterangeOptimization_) {
  3073.         // We always have at least 1 partial segment part, and most servers
  3074.         // allow you to make a request with _HLS_msn=X&_HLS_part=0 with a
  3075.         // distance of 4 partial segments.  With this we ensure that we
  3076.         // obtain the minimum latency in this type of case.
  3077.         if (this.partialTargetDuration_ * 5 <= lastTargetDuration) {
  3078.           this.lastTargetDuration_ = Math.min(
  3079.               this.partialTargetDuration_, this.lastTargetDuration_);
  3080.         } else {
  3081.           this.lastTargetDuration_ = Math.min(
  3082.               lastTargetDuration, this.lastTargetDuration_);
  3083.         }
  3084.       } else {
  3085.         this.lastTargetDuration_ = Math.min(
  3086.             this.partialTargetDuration_, this.lastTargetDuration_);
  3087.       }
  3088.       // Use 'PART-HOLD-BACK' as the presentation delay for low latency mode.
  3089.       this.lowLatencyPresentationDelay_ = serverControlTag ? Number(
  3090.           serverControlTag.getRequiredAttrValue('PART-HOLD-BACK')) : 0;
  3091.     } else {
  3092.       this.lastTargetDuration_ = Math.min(
  3093.           lastTargetDuration, this.lastTargetDuration_);
  3094.       // Use 'HOLD-BACK' as the presentation delay for default if defined.
  3095.       const holdBack = serverControlTag ?
  3096.           serverControlTag.getAttribute('HOLD-BACK') : null;
  3097.       this.presentationDelay_ = holdBack ? Number(holdBack.value) : 0;
  3098.     }
  3099.     // 2. Update the longest target duration if need be to use as a
  3100.     // presentation delay later.
  3101.     this.maxTargetDuration_ = Math.max(
  3102.         targetDuration, this.maxTargetDuration_);
  3103.   }
  3106.   /**
  3107.    * @param {!shaka.hls.Playlist} playlist
  3108.    * @private
  3109.    */
  3110.   changePresentationTimelineToLive_(playlist) {
  3111.     // The live edge will be calculated from segments, so we don't need to
  3112.     // set a presentation start time.  We will assert later that this is
  3113.     // working as expected.
  3115.     // The HLS spec (RFC 8216) states in 6.3.3:
  3116.     //
  3117.     // "The client SHALL choose which Media Segment to play first ... the
  3118.     // client SHOULD NOT choose a segment that starts less than three target
  3119.     // durations from the end of the Playlist file.  Doing so can trigger
  3120.     // playback stalls."
  3121.     //
  3122.     // We accomplish this in our DASH-y model by setting a presentation
  3123.     // delay of configured value, or 3 segments duration if not configured.
  3124.     // This will be the "live edge" of the presentation.
  3125.     let presentationDelay;
  3126.     if (this.config_.defaultPresentationDelay) {
  3127.       presentationDelay = this.config_.defaultPresentationDelay;
  3128.     } else if (this.lowLatencyPresentationDelay_) {
  3129.       presentationDelay = this.lowLatencyPresentationDelay_;
  3130.     } else if (this.presentationDelay_) {
  3131.       presentationDelay = this.presentationDelay_;
  3132.     } else {
  3133.       const playlistSegments = playlist.segments.length;
  3134.       let delaySegments = this.config_.hls.liveSegmentsDelay;
  3135.       if (delaySegments > (playlistSegments - 2)) {
  3136.         delaySegments = Math.max(1, playlistSegments - 2);
  3137.       }
  3138.       presentationDelay = this.maxTargetDuration_ * delaySegments;
  3139.     }
  3141.     this.presentationTimeline_.setPresentationStartTime(0);
  3142.     this.presentationTimeline_.setDelay(presentationDelay);
  3143.     this.presentationTimeline_.setStatic(false);
  3144.   }
  3146.   /**
  3147.    * Get the InitSegmentReference for a segment if it has a EXT-X-MAP tag.
  3148.    * @param {!shaka.hls.Playlist} playlist
  3149.    * @param {!Array.<!shaka.hls.Tag>} tags Segment tags
  3150.    * @param {function():!Array.<string>} getUris
  3151.    * @param {?Map.<string, string>=} variables
  3152.    * @return {shaka.media.InitSegmentReference}
  3153.    * @private
  3154.    */
  3155.   getInitSegmentReference_(playlist, tags, getUris, variables) {
  3156.     /** @type {?shaka.hls.Tag} */
  3157.     const mapTag = shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-MAP');
  3159.     if (!mapTag) {
  3160.       return null;
  3161.     }
  3162.     // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
  3163.     const verbatimInitSegmentUri = mapTag.getRequiredAttrValue('URI');
  3164.     const absoluteInitSegmentUris = shaka.hls.Utils.constructSegmentUris(
  3165.         getUris(), verbatimInitSegmentUri, variables);
  3167.     const mapTagKey = [
  3168.       absoluteInitSegmentUris.toString(),
  3169.       mapTag.getAttributeValue('BYTERANGE', ''),
  3170.     ].join('-');
  3171.     if (!this.mapTagToInitSegmentRefMap_.has(mapTagKey)) {
  3172.       /** @type {shaka.extern.aesKey|undefined} */
  3173.       let aesKey = undefined;
  3174.       let byteRangeTag = null;
  3175.       for (const tag of tags) {
  3176.         if (tag.name == 'EXT-X-KEY') {
  3177.           if (this.isAesMethod_(tag.getRequiredAttrValue('METHOD')) &&
  3178.               tag.id < mapTag.id) {
  3179.             aesKey =
  3180.                 this.parseAESDrmTag_(tag, playlist, getUris, variables);
  3181.           }
  3182.         } else if (tag.name == 'EXT-X-BYTERANGE' && tag.id < mapTag.id) {
  3183.           byteRangeTag = tag;
  3184.         }
  3185.       }
  3186.       const initSegmentRef = this.createInitSegmentReference_(
  3187.           absoluteInitSegmentUris, mapTag, byteRangeTag, aesKey);
  3188.       this.mapTagToInitSegmentRefMap_.set(mapTagKey, initSegmentRef);
  3189.     }
  3190.     return this.mapTagToInitSegmentRefMap_.get(mapTagKey);
  3191.   }
  3193.   /**
  3194.    * Create an InitSegmentReference object for the EXT-X-MAP tag in the media
  3195.    * playlist.
  3196.    * @param {!Array.<string>} absoluteInitSegmentUris
  3197.    * @param {!shaka.hls.Tag} mapTag EXT-X-MAP
  3198.    * @param {shaka.hls.Tag=} byteRangeTag EXT-X-BYTERANGE
  3199.    * @param {shaka.extern.aesKey=} aesKey
  3200.    * @return {!shaka.media.InitSegmentReference}
  3201.    * @private
  3202.    */
  3203.   createInitSegmentReference_(absoluteInitSegmentUris, mapTag, byteRangeTag,
  3204.       aesKey) {
  3205.     let startByte = 0;
  3206.     let endByte = null;
  3207.     let byterange = mapTag.getAttributeValue('BYTERANGE');
  3208.     if (!byterange && byteRangeTag) {
  3209.       byterange = byteRangeTag.value;
  3210.     }
  3211.     // If a BYTERANGE attribute is not specified, the segment consists
  3212.     // of the entire resource.
  3213.     if (byterange) {
  3214.       const blocks = byterange.split('@');
  3215.       const byteLength = Number(blocks[0]);
  3216.       startByte = Number(blocks[1]);
  3217.       endByte = startByte + byteLength - 1;
  3219.       if (aesKey) {
  3220.         // MAP segment encrypted with method AES, when served with
  3221.         // HTTP Range, has the unencrypted size specified in the range.
  3222.         // See: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
  3223.         const length = (endByte + 1) - startByte;
  3224.         if (length % 16) {
  3225.           endByte += (16 - (length % 16));
  3226.         }
  3227.       }
  3228.     }
  3230.     const initSegmentRef = new shaka.media.InitSegmentReference(
  3231.         () => absoluteInitSegmentUris,
  3232.         startByte,
  3233.         endByte,
  3234.         /* mediaQuality= */ null,
  3235.         /* timescale= */ null,
  3236.         /* segmentData= */ null,
  3237.         aesKey);
  3238.     return initSegmentRef;
  3239.   }
  3241.   /**
  3242.    * Parses one shaka.hls.Segment object into a shaka.media.SegmentReference.
  3243.    *
  3244.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  3245.    * @param {shaka.media.SegmentReference} previousReference
  3246.    * @param {!shaka.hls.Segment} hlsSegment
  3247.    * @param {number} startTime
  3248.    * @param {!Map.<string, string>} variables
  3249.    * @param {!shaka.hls.Playlist} playlist
  3250.    * @param {shaka.extern.Stream} stream
  3251.    * @param {function():!Array.<string>} getUris
  3252.    * @param {shaka.extern.aesKey=} aesKey
  3253.    * @return {shaka.media.SegmentReference}
  3254.    * @private
  3255.    */
  3256.   createSegmentReference_(
  3257.       initSegmentReference, previousReference, hlsSegment, startTime,
  3258.       variables, playlist, stream, getUris, aesKey) {
  3259.     const tags = hlsSegment.tags;
  3260.     const extinfTag =
  3261.         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
  3263.     let endTime = 0;
  3264.     let startByte = 0;
  3265.     let endByte = null;
  3267.     if (hlsSegment.partialSegments.length && !this.lowLatencyMode_) {
  3268.       shaka.log.alwaysWarn('Low-latency HLS live stream detected, but ' +
  3269.                 'low-latency streaming mode is not enabled in Shaka ' +
  3270.                 'Player. Set streaming.lowLatencyMode configuration to ' +
  3271.                 'true, and see https://bit.ly/3clctcj for details.');
  3272.     }
  3274.     let syncTime = null;
  3275.     if (!this.config_.hls.ignoreManifestProgramDateTime) {
  3276.       const dateTimeTag =
  3277.           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
  3278.       if (dateTimeTag && dateTimeTag.value) {
  3279.         syncTime = shaka.util.TXml.parseDate(dateTimeTag.value);
  3280.         goog.asserts.assert(syncTime != null,
  3281.             'EXT-X-PROGRAM-DATE-TIME format not valid');
  3282.       }
  3283.     }
  3285.     let status = shaka.media.SegmentReference.Status.AVAILABLE;
  3286.     if (shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-GAP')) {
  3287.       status = shaka.media.SegmentReference.Status.MISSING;
  3288.     }
  3290.     if (!extinfTag) {
  3291.       if (hlsSegment.partialSegments.length == 0) {
  3292.         // EXTINF tag must be available if the segment has no partial segments.
  3293.         throw new shaka.util.Error(
  3294.             shaka.util.Error.Severity.CRITICAL,
  3295.             shaka.util.Error.Category.MANIFEST,
  3296.             shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
  3297.       } else if (!this.lowLatencyMode_) {
  3298.         // Without EXTINF and without low-latency mode, partial segments get
  3299.         // ignored.
  3300.         return null;
  3301.       }
  3302.     }
  3304.     // Create SegmentReferences for the partial segments.
  3305.     let partialSegmentRefs = [];
  3307.     // Optimization for LL-HLS with byterange
  3308.     // More info in https://tinyurl.com/hls-open-byte-range
  3309.     let segmentWithByteRangeOptimization = false;
  3310.     let getUrisOptimization = null;
  3311.     let somePartialSegmentWithGap = false;
  3312.     let isPreloadSegment = false;
  3314.     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
  3315.       const byterangeOptimizationSupport = (stream.mimeType == 'video/mp4' ||
  3316.           stream.mimeType == 'audio/mp4') && window.ReadableStream &&
  3317.           this.config_.hls.allowLowLatencyByteRangeOptimization;
  3319.       let partialSyncTime = syncTime;
  3320.       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
  3321.         const item = hlsSegment.partialSegments[i];
  3322.         const pPreviousReference = i == 0 ?
  3323.           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
  3324.         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
  3326.         // If DURATION is missing from this partial segment, use the target
  3327.         // partial duration from the top of the playlist, which is a required
  3328.         // attribute for content with partial segments.
  3329.         const pDuration = Number(item.getAttributeValue('DURATION')) ||
  3330.             this.partialTargetDuration_;
  3332.         // If for some reason we have neither an explicit duration, nor a target
  3333.         // partial duration, we should SKIP this partial segment to avoid
  3334.         // duplicating content in the presentation timeline.
  3335.         if (!pDuration) {
  3336.           continue;
  3337.         }
  3339.         const pEndTime = pStartTime + pDuration;
  3341.         let pStartByte = 0;
  3342.         let pEndByte = null;
  3343.         if (item.name == 'EXT-X-PRELOAD-HINT') {
  3344.           // A preload hinted partial segment may have byterange start info.
  3345.           const pByterangeStart = item.getAttributeValue('BYTERANGE-START');
  3346.           pStartByte = pByterangeStart ? Number(pByterangeStart) : 0;
  3347.           // A preload hinted partial segment may have byterange length info.
  3348.           const pByterangeLength = item.getAttributeValue('BYTERANGE-LENGTH');
  3349.           if (pByterangeLength) {
  3350.             pEndByte = pStartByte + Number(pByterangeLength) - 1;
  3351.           } else if (pStartByte) {
  3352.             // If we have a non-zero start byte, but no end byte, follow the
  3353.             // recommendation of https://tinyurl.com/hls-open-byte-range and
  3354.             // set the end byte explicitly to a large integer.
  3355.             pEndByte = Number.MAX_SAFE_INTEGER;
  3356.           }
  3357.         } else {
  3358.           const pByterange = item.getAttributeValue('BYTERANGE');
  3359.           [pStartByte, pEndByte] =
  3360.             this.parseByteRange_(pPreviousReference, pByterange);
  3361.         }
  3362.         const pUri = item.getAttributeValue('URI');
  3363.         if (!pUri) {
  3364.           continue;
  3365.         }
  3367.         let partialStatus = shaka.media.SegmentReference.Status.AVAILABLE;
  3368.         if (item.getAttributeValue('GAP') == 'YES') {
  3369.           partialStatus = shaka.media.SegmentReference.Status.MISSING;
  3370.           somePartialSegmentWithGap = true;
  3371.         }
  3373.         let uris = null;
  3374.         const getPartialUris = () => {
  3375.           if (uris == null) {
  3376.             goog.asserts.assert(pUri, 'Partial uri should be defined!');
  3377.             uris = shaka.hls.Utils.constructSegmentUris(
  3378.                 getUris(), pUri, variables);
  3379.           }
  3380.           return uris;
  3381.         };
  3383.         if (byterangeOptimizationSupport &&
  3384.             pStartByte >= 0 && pEndByte != null) {
  3385.           getUrisOptimization = getPartialUris;
  3386.           segmentWithByteRangeOptimization = true;
  3387.         }
  3389.         const partial = new shaka.media.SegmentReference(
  3390.             pStartTime,
  3391.             pEndTime,
  3392.             getPartialUris,
  3393.             pStartByte,
  3394.             pEndByte,
  3395.             initSegmentReference,
  3396.             /* timestampOffset= */ 0,
  3397.             /* appendWindowStart= */ 0,
  3398.             /* appendWindowEnd= */ Infinity,
  3399.             /* partialReferences= */ [],
  3400.             /* tilesLayout= */ '',
  3401.             /* tileDuration= */ null,
  3402.             partialSyncTime,
  3403.             partialStatus,
  3404.             aesKey);
  3405.         if (item.name == 'EXT-X-PRELOAD-HINT') {
  3406.           partial.markAsPreload();
  3407.           isPreloadSegment = true;
  3408.         }
  3409.         // The spec doesn't say that we can assume INDEPENDENT=YES for the
  3410.         // first partial segment. It does call the flag "optional", though, and
  3411.         // that cases where there are no such flags on any partial segments, it
  3412.         // is sensible to assume the first one is independent.
  3413.         if (item.getAttributeValue('INDEPENDENT') != 'YES' && i > 0) {
  3414.           partial.markAsNonIndependent();
  3415.         }
  3416.         partialSegmentRefs.push(partial);
  3418.         if (partialSyncTime) {
  3419.           partialSyncTime += pDuration;
  3420.         }
  3421.       } // for-loop of hlsSegment.partialSegments
  3422.     }
  3424.     // If the segment has EXTINF tag, set the segment's end time, start byte
  3425.     // and end byte based on the duration and byterange information.
  3426.     // Otherwise, calculate the end time, start / end byte based on its partial
  3427.     // segments.
  3428.     // Note that the sum of partial segments durations may be slightly different
  3429.     // from the parent segment's duration. In this case, use the duration from
  3430.     // the parent segment tag.
  3431.     if (extinfTag) {
  3432.       // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  3433.       // We're interested in the duration part.
  3434.       const extinfValues = extinfTag.value.split(',');
  3435.       const duration = Number(extinfValues[0]);
  3436.       // Skip segments without duration
  3437.       if (duration == 0) {
  3438.         return null;
  3439.       }
  3440.       endTime = startTime + duration;
  3441.     } else if (partialSegmentRefs.length) {
  3442.       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
  3443.     } else {
  3444.       // Skip segments without duration and without partialsegments
  3445.       return null;
  3446.     }
  3448.     if (segmentWithByteRangeOptimization) {
  3449.       // We cannot optimize segments with gaps, or with a start byte that is
  3450.       // not 0.
  3451.       if (somePartialSegmentWithGap || partialSegmentRefs[0].startByte != 0) {
  3452.         segmentWithByteRangeOptimization = false;
  3453.         getUrisOptimization = null;
  3454.       } else {
  3455.         partialSegmentRefs = [];
  3456.       }
  3457.     }
  3459.     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
  3460.     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
  3461.     // and has partial segments, set the start byte and end byte base on the
  3462.     // partial segments.
  3463.     const byterangeTag =
  3464.          shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-BYTERANGE');
  3465.     if (byterangeTag) {
  3466.       [startByte, endByte] =
  3467.           this.parseByteRange_(previousReference, byterangeTag.value);
  3468.     } else if (partialSegmentRefs.length) {
  3469.       startByte = partialSegmentRefs[0].startByte;
  3470.       endByte = partialSegmentRefs[partialSegmentRefs.length - 1].endByte;
  3471.     }
  3473.     let tilesLayout = '';
  3474.     let tileDuration = null;
  3475.     if (stream.type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
  3476.       // By default in HLS the tilesLayout is 1x1
  3477.       tilesLayout = '1x1';
  3478.       const tilesTag =
  3479.           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-TILES');
  3480.       if (tilesTag) {
  3481.         tilesLayout = tilesTag.getRequiredAttrValue('LAYOUT');
  3482.         const duration = tilesTag.getAttributeValue('DURATION');
  3483.         if (duration) {
  3484.           tileDuration = Number(duration);
  3485.         }
  3486.       }
  3487.     }
  3489.     let uris = null;
  3490.     const getSegmentUris = () => {
  3491.       if (getUrisOptimization) {
  3492.         return getUrisOptimization();
  3493.       }
  3494.       if (uris == null) {
  3495.         uris = shaka.hls.Utils.constructSegmentUris(getUris(),
  3496.             hlsSegment.verbatimSegmentUri, variables);
  3497.       }
  3498.       return uris || [];
  3499.     };
  3501.     const allPartialSegments = partialSegmentRefs.length > 0 &&
  3502.         !!hlsSegment.verbatimSegmentUri;
  3504.     const reference = new shaka.media.SegmentReference(
  3505.         startTime,
  3506.         endTime,
  3507.         getSegmentUris,
  3508.         startByte,
  3509.         endByte,
  3510.         initSegmentReference,
  3511.         /* timestampOffset= */ 0,
  3512.         /* appendWindowStart= */ 0,
  3513.         /* appendWindowEnd= */ Infinity,
  3514.         partialSegmentRefs,
  3515.         tilesLayout,
  3516.         tileDuration,
  3517.         syncTime,
  3518.         status,
  3519.         aesKey,
  3520.         allPartialSegments,
  3521.     );
  3523.     if (segmentWithByteRangeOptimization) {
  3524.       this.lowLatencyByterangeOptimization_ = true;
  3525.       reference.markAsByterangeOptimization();
  3527.       if (isPreloadSegment) {
  3528.         reference.markAsPreload();
  3529.       }
  3530.     }
  3532.     return reference;
  3533.   }
  3536.   /**
  3537.    * Parse the startByte and endByte.
  3538.    * @param {shaka.media.SegmentReference} previousReference
  3539.    * @param {?string} byterange
  3540.    * @return {!Array.<number>} An array with the start byte and end byte.
  3541.    * @private
  3542.    */
  3543.   parseByteRange_(previousReference, byterange) {
  3544.     let startByte = 0;
  3545.     let endByte = null;
  3546.     // If BYTERANGE is not specified, the segment consists of the entire
  3547.     // resource.
  3548.     if (byterange) {
  3549.       const blocks = byterange.split('@');
  3550.       const byteLength = Number(blocks[0]);
  3551.       if (blocks[1]) {
  3552.         startByte = Number(blocks[1]);
  3553.       } else {
  3554.         goog.asserts.assert(previousReference,
  3555.             'Cannot refer back to previous HLS segment!');
  3556.         startByte = previousReference.endByte + 1;
  3557.       }
  3558.       endByte = startByte + byteLength - 1;
  3559.     }
  3560.     return [startByte, endByte];
  3561.   }
  3563.   /**
  3564.    * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences and
  3565.    * get the bandwidth necessary for this segments If it's defined in the
  3566.    * playlist.
  3567.    *
  3568.    * @param {!shaka.hls.Playlist} playlist
  3569.    * @param {shaka.extern.Stream} stream
  3570.    * @param {!Map.<number, number>} mediaSequenceToStartTime
  3571.    * @param {!Map.<string, string>} variables
  3572.    * @param {function():!Array.<string>} getUris
  3573.    * @param {string} type
  3574.    * @return {{segments: !Array.<!shaka.media.SegmentReference>,
  3575.    *          bandwidth: (number|undefined)}}
  3576.    * @private
  3577.    */
  3578.   createSegments_(playlist, stream, mediaSequenceToStartTime, variables,
  3579.       getUris, type) {
  3580.     /** @type {Array.<!shaka.hls.Segment>} */
  3581.     const hlsSegments = playlist.segments;
  3582.     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
  3584.     /** @type {shaka.media.InitSegmentReference} */
  3585.     let initSegmentRef;
  3587.     /** @type {shaka.extern.aesKey|undefined} */
  3588.     let aesKey = undefined;
  3590.     let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3591.         playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', 0);
  3592.     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3593.         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  3594.     const skipTag = shaka.hls.Utils.getFirstTagWithName(
  3595.         playlist.tags, 'EXT-X-SKIP');
  3596.     const skippedSegments =
  3597.         skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
  3598.     let position = mediaSequenceNumber + skippedSegments;
  3599.     let firstStartTime = 0;
  3601.     // For live stream, use the cached value in the mediaSequenceToStartTime
  3602.     // map if available.
  3603.     if (this.isLive_() && mediaSequenceToStartTime.has(position)) {
  3604.       firstStartTime = mediaSequenceToStartTime.get(position);
  3605.     }
  3606.     // This is for recovering from disconnects.
  3607.     if (firstStartTime === 0 &&
  3608.         this.presentationType_ == shaka.hls.HlsParser.PresentationType_.LIVE &&
  3609.         mediaSequenceToStartTime.size > 0 &&
  3610.         !mediaSequenceToStartTime.has(position)) {
  3611.       firstStartTime = this.presentationTimeline_.getSegmentAvailabilityStart();
  3612.     }
  3614.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  3615.     const references = [];
  3617.     let previousReference = null;
  3619.     /** @type {!Array.<{bitrate: number, duration: number}>} */
  3620.     const bitrates = [];
  3622.     for (let i = 0; i < hlsSegments.length; i++) {
  3623.       const item = hlsSegments[i];
  3624.       const startTime =
  3625.           (i == 0) ? firstStartTime : previousReference.endTime;
  3626.       position = mediaSequenceNumber + skippedSegments + i;
  3628.       const discontinuityTag = shaka.hls.Utils.getFirstTagWithName(
  3629.           item.tags, 'EXT-X-DISCONTINUITY');
  3630.       if (discontinuityTag) {
  3631.         discontinuitySequence++;
  3632.       }
  3634.       // Apply new AES tags as you see them, keeping a running total.
  3635.       for (const drmTag of item.tags) {
  3636.         if (drmTag.name == 'EXT-X-KEY') {
  3637.           if (this.isAesMethod_(drmTag.getRequiredAttrValue('METHOD'))) {
  3638.             aesKey =
  3639.                 this.parseAESDrmTag_(drmTag, playlist, getUris, variables);
  3640.           } else {
  3641.             aesKey = undefined;
  3642.           }
  3643.         }
  3644.       }
  3646.       mediaSequenceToStartTime.set(position, startTime);
  3648.       initSegmentRef = this.getInitSegmentReference_(playlist,
  3649.           item.tags, getUris, variables);
  3651.       // If the stream is low latency and the user has not configured the
  3652.       // lowLatencyMode, but if it has been configured to activate the
  3653.       // lowLatencyMode if a stream of this type is detected, we automatically
  3654.       // activate the lowLatencyMode.
  3655.       if (!this.lowLatencyMode_) {
  3656.         const autoLowLatencyMode = this.playerInterface_.isAutoLowLatencyMode();
  3657.         if (autoLowLatencyMode) {
  3658.           this.playerInterface_.enableLowLatencyMode();
  3659.           this.lowLatencyMode_ = this.playerInterface_.isLowLatencyMode();
  3660.         }
  3661.       }
  3663.       const reference = this.createSegmentReference_(
  3664.           initSegmentRef,
  3665.           previousReference,
  3666.           item,
  3667.           startTime,
  3668.           variables,
  3669.           playlist,
  3670.           stream,
  3671.           getUris,
  3672.           aesKey);
  3674.       if (reference) {
  3675.         const bitrate = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3676.             item.tags, 'EXT-X-BITRATE');
  3677.         if (bitrate) {
  3678.           bitrates.push({
  3679.             bitrate,
  3680.             duration: reference.endTime - reference.startTime,
  3681.           });
  3682.         } else if (bitrates.length) {
  3683.           // It applies to every segment between it and the next EXT-X-BITRATE,
  3684.           // so we use the latest bitrate value
  3685.           const prevBitrate = bitrates.pop();
  3686.           prevBitrate.duration += reference.endTime - reference.startTime;
  3687.           bitrates.push(prevBitrate);
  3688.         }
  3690.         previousReference = reference;
  3691.         reference.discontinuitySequence = discontinuitySequence;
  3693.         if (this.ignoreManifestProgramDateTimeFor_(type) &&
  3694.             this.minSequenceNumber_ != null &&
  3695.             position < this.minSequenceNumber_) {
  3696.           // This segment is ignored as part of our fallback synchronization
  3697.           // method.
  3698.         } else {
  3699.           references.push(reference);
  3700.         }
  3701.       }
  3702.     }
  3704.     let bandwidth = undefined;
  3705.     if (bitrates.length) {
  3706.       const duration = bitrates.reduce((sum, value) => {
  3707.         return sum + value.duration;
  3708.       }, 0);
  3709.       bandwidth = Math.round(bitrates.reduce((sum, value) => {
  3710.         return sum + value.bitrate * value.duration;
  3711.       }, 0) / duration * 1000);
  3712.     }
  3714.     // If some segments have sync times, but not all, extrapolate the sync
  3715.     // times of the ones with none.
  3716.     const someSyncTime = references.some((ref) => ref.syncTime != null);
  3717.     if (someSyncTime) {
  3718.       for (let i = 0; i < references.length; i++) {
  3719.         const reference = references[i];
  3720.         if (reference.syncTime != null) {
  3721.           // No need to extrapolate.
  3722.           continue;
  3723.         }
  3724.         // Find the nearest segment with syncTime, in either direction.
  3725.         // This looks forward and backward simultaneously, keeping track of what
  3726.         // to offset the syncTime it finds by as it goes.
  3727.         let forwardAdd = 0;
  3728.         let forwardI = i;
  3729.         /**
  3730.          * Look forwards one reference at a time, summing all durations as we
  3731.          * go, until we find a reference with a syncTime to use as a basis.
  3732.          * This DOES count the original reference, but DOESN'T count the first
  3733.          * reference with a syncTime (as we approach it from behind).
  3734.          * @return {?number}
  3735.          */
  3736.         const lookForward = () => {
  3737.           const other = references[forwardI];
  3738.           if (other) {
  3739.             if (other.syncTime != null) {
  3740.               return other.syncTime + forwardAdd;
  3741.             }
  3742.             forwardAdd -= other.endTime - other.startTime;
  3743.             forwardI += 1;
  3744.           }
  3745.           return null;
  3746.         };
  3747.         let backwardAdd = 0;
  3748.         let backwardI = i;
  3749.         /**
  3750.          * Look backwards one reference at a time, summing all durations as we
  3751.          * go, until we find a reference with a syncTime to use as a basis.
  3752.          * This DOESN'T count the original reference, but DOES count the first
  3753.          * reference with a syncTime (as we approach it from ahead).
  3754.          * @return {?number}
  3755.          */
  3756.         const lookBackward = () => {
  3757.           const other = references[backwardI];
  3758.           if (other) {
  3759.             if (other != reference) {
  3760.               backwardAdd += other.endTime - other.startTime;
  3761.             }
  3762.             if (other.syncTime != null) {
  3763.               return other.syncTime + backwardAdd;
  3764.             }
  3765.             backwardI -= 1;
  3766.           }
  3767.           return null;
  3768.         };
  3769.         while (reference.syncTime == null) {
  3770.           reference.syncTime = lookBackward();
  3771.           if (reference.syncTime == null) {
  3772.             reference.syncTime = lookForward();
  3773.           }
  3774.         }
  3775.       }
  3776.     }
  3778.     // Split the sync times properly among partial segments.
  3779.     if (someSyncTime) {
  3780.       for (const reference of references) {
  3781.         let syncTime = reference.syncTime;
  3782.         for (const partial of reference.partialReferences) {
  3783.           partial.syncTime = syncTime;
  3784.           syncTime += partial.endTime - partial.startTime;
  3785.         }
  3786.       }
  3787.     }
  3789.     // lowestSyncTime is a value from a previous playlist update.  Use it to
  3790.     // set reference start times.  If this is the first playlist parse, we will
  3791.     // skip this step, and wait until we have sync time across stream types.
  3792.     const lowestSyncTime = this.lowestSyncTime_;
  3793.     if (someSyncTime && lowestSyncTime != Infinity) {
  3794.       if (!this.ignoreManifestProgramDateTimeFor_(type)) {
  3795.         for (const reference of references) {
  3796.           reference.syncAgainst(lowestSyncTime);
  3797.         }
  3798.       }
  3799.     }
  3801.     return {
  3802.       segments: references,
  3803.       bandwidth,
  3804.     };
  3805.   }
  3807.   /**
  3808.    * Attempts to guess stream's mime type based on content type and URI.
  3809.    *
  3810.    * @param {string} contentType
  3811.    * @param {string} codecs
  3812.    * @return {?string}
  3813.    * @private
  3814.    */
  3815.   guessMimeTypeBeforeLoading_(contentType, codecs) {
  3816.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  3817.       if (codecs == 'vtt' || codecs == 'wvtt') {
  3818.         // If codecs is 'vtt', it's WebVTT.
  3819.         return 'text/vtt';
  3820.       } else if (codecs && codecs !== '') {
  3821.         // Otherwise, assume MP4-embedded text, since text-based formats tend
  3822.         // not to have a codecs string at all.
  3823.         return 'application/mp4';
  3824.       }
  3825.     }
  3827.     if (contentType == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
  3828.       if (!codecs || codecs == 'jpeg') {
  3829.         return 'image/jpeg';
  3830.       }
  3831.     }
  3833.     if (contentType == shaka.util.ManifestParserUtils.ContentType.AUDIO) {
  3834.       // See: https://bugs.chromium.org/p/chromium/issues/detail?id=489520
  3835.       if (codecs == 'mp4a.40.34') {
  3836.         return 'audio/mpeg';
  3837.       }
  3838.     }
  3840.     if (codecs == 'mjpg') {
  3841.       return 'application/mp4';
  3842.     }
  3844.     // Not enough information to guess from the content type and codecs.
  3845.     return null;
  3846.   }
  3848.   /**
  3849.    * Get a fallback mime type for the content. Used if all the better methods
  3850.    * for determining the mime type have failed.
  3851.    *
  3852.    * @param {string} contentType
  3853.    * @return {string}
  3854.    * @private
  3855.    */
  3856.   guessMimeTypeFallback_(contentType) {
  3857.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  3858.       // If there was no codecs string and no content-type, assume HLS text
  3859.       // streams are WebVTT.
  3860.       return 'text/vtt';
  3861.     }
  3862.     // If the HLS content is lacking in both MIME type metadata and
  3863.     // segment file extensions, we fall back to assuming it's MP4.
  3864.     const map = shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
  3865.     return map['mp4'];
  3866.   }
  3868.   /**
  3869.    * Attempts to guess stream's mime type based on content type, URI, and
  3870.    * contents of the playlist.
  3871.    *
  3872.    * @param {string} contentType
  3873.    * @param {string} codecs
  3874.    * @param {!shaka.hls.Playlist} playlist
  3875.    * @param {!Map.<string, string>} variables
  3876.    * @param {function():!Array.<string>} getUris
  3877.    * @return {!Promise.<string>}
  3878.    * @private
  3879.    */
  3880.   async guessMimeType_(contentType, codecs, playlist, variables, getUris) {
  3881.     const HlsParser = shaka.hls.HlsParser;
  3882.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  3884.     // If you wait long enough, requesting the first segment can fail
  3885.     // because it has fallen off the left edge of DVR, so to be safer,
  3886.     // let's request the middle segment.
  3887.     goog.asserts.assert(playlist.segments.length,
  3888.         'Playlist should have segments!');
  3889.     const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
  3891.     const middleSegment = playlist.segments[middleSegmentIdx];
  3892.     if (shaka.hls.Utils.getFirstTagWithName(middleSegment.tags, 'EXT-X-GAP')) {
  3893.       return this.guessMimeTypeFallback_(contentType);
  3894.     }
  3896.     const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
  3897.         getUris(),
  3898.         middleSegment.verbatimSegmentUri,
  3899.         variables);
  3901.     const parsedUri = new goog.Uri(middleSegmentUris[0]);
  3902.     const extension = parsedUri.getPath().split('.').pop();
  3903.     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
  3905.     let mimeType = map[extension];
  3906.     if (mimeType) {
  3907.       return mimeType;
  3908.     }
  3910.     mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
  3911.     if (mimeType) {
  3912.       return mimeType;
  3913.     }
  3915.     // The extension map didn't work, so guess based on codecs.
  3916.     mimeType = this.guessMimeTypeBeforeLoading_(contentType, codecs);
  3917.     if (mimeType) {
  3918.       return mimeType;
  3919.     }
  3921.     // If unable to guess mime type, request a segment and try getting it
  3922.     // from the response.
  3923.     let contentMimeType;
  3924.     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
  3925.     const headRequest = shaka.net.NetworkingEngine.makeRequest(
  3926.         middleSegmentUris, this.config_.retryParameters);
  3927.     try {
  3928.       headRequest.method = 'HEAD';
  3929.       const response = await this.makeNetworkRequest_(
  3930.           headRequest, requestType, {type});
  3932.       contentMimeType = response.headers['content-type'];
  3933.     } catch (error) {
  3934.       if (error &&
  3935.         (error.code == shaka.util.Error.Code.HTTP_ERROR ||
  3936.          error.code == shaka.util.Error.Code.BAD_HTTP_STATUS)) {
  3937.         headRequest.method = 'GET';
  3938.         const response = await this.makeNetworkRequest_(
  3939.             headRequest, requestType, {type});
  3941.         contentMimeType = response.headers['content-type'];
  3942.       }
  3943.     }
  3945.     if (contentMimeType) {
  3946.       // Split the MIME type in case the server sent additional parameters.
  3947.       return contentMimeType.split(';')[0];
  3948.     }
  3950.     return this.guessMimeTypeFallback_(contentType);
  3951.   }
  3953.   /**
  3954.    * Returns a tag with a given name.
  3955.    * Throws an error if tag was not found.
  3956.    *
  3957.    * @param {!Array.<shaka.hls.Tag>} tags
  3958.    * @param {string} tagName
  3959.    * @return {!shaka.hls.Tag}
  3960.    * @private
  3961.    */
  3962.   getRequiredTag_(tags, tagName) {
  3963.     const tag = shaka.hls.Utils.getFirstTagWithName(tags, tagName);
  3964.     if (!tag) {
  3965.       throw new shaka.util.Error(
  3966.           shaka.util.Error.Severity.CRITICAL,
  3967.           shaka.util.Error.Category.MANIFEST,
  3968.           shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, tagName);
  3969.     }
  3971.     return tag;
  3972.   }
  3974.   /**
  3975.    * @param {shaka.extern.Stream} stream
  3976.    * @param {?string} width
  3977.    * @param {?string} height
  3978.    * @param {?string} frameRate
  3979.    * @param {?string} videoRange
  3980.    * @param {?string} videoLayout
  3981.    * @private
  3982.    */
  3983.   addVideoAttributes_(stream, width, height, frameRate, videoRange,
  3984.       videoLayout) {
  3985.     if (stream) {
  3986.       stream.width = Number(width) || undefined;
  3987.       stream.height = Number(height) || undefined;
  3988.       stream.frameRate = Number(frameRate) || undefined;
  3989.       stream.hdr = videoRange || undefined;
  3990.       stream.videoLayout = videoLayout || undefined;
  3991.     }
  3992.   }
  3994.   /**
  3995.    * Makes a network request for the manifest and returns a Promise
  3996.    * with the resulting data.
  3997.    *
  3998.    * @param {!Array.<string>} uris
  3999.    * @param {boolean=} isPlaylist
  4000.    * @return {!Promise.<!shaka.extern.Response>}
  4001.    * @private
  4002.    */
  4003.   requestManifest_(uris, isPlaylist) {
  4004.     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  4006.     const request = shaka.net.NetworkingEngine.makeRequest(
  4007.         uris, this.config_.retryParameters);
  4009.     const type = isPlaylist ?
  4010.         shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_PLAYLIST :
  4011.         shaka.net.NetworkingEngine.AdvancedRequestType.MASTER_PLAYLIST;
  4012.     return this.makeNetworkRequest_(request, requestType, {type});
  4013.   }
  4015.   /**
  4016.    * Called when the update timer ticks. Because parsing a manifest is async,
  4017.    * this method is async. To work with this, this method will schedule the next
  4018.    * update when it finished instead of using a repeating-start.
  4019.    *
  4020.    * @return {!Promise}
  4021.    * @private
  4022.    */
  4023.   async onUpdate_() {
  4024.     shaka.log.info('Updating manifest...');
  4026.     goog.asserts.assert(
  4027.         this.getUpdatePlaylistDelay_() > 0,
  4028.         'We should only call |onUpdate_| when we are suppose to be updating.');
  4030.     // Detect a call to stop()
  4031.     if (!this.playerInterface_) {
  4032.       return;
  4033.     }
  4035.     try {
  4036.       const startTime = Date.now();
  4037.       await this.update();
  4039.       // Keep track of how long the longest manifest update took.
  4040.       const endTime = Date.now();
  4042.       // This may have converted to VOD, in which case we stop updating.
  4043.       if (this.isLive_()) {
  4044.         const updateDuration = (endTime - startTime) / 1000.0;
  4045.         this.averageUpdateDuration_.sample(1, updateDuration);
  4046.         const delay = this.getUpdatePlaylistDelay_();
  4047.         const finalDelay = Math.max(0,
  4048.             delay - this.averageUpdateDuration_.getEstimate());
  4049.         this.updatePlaylistTimer_.tickAfter(/* seconds= */ finalDelay);
  4050.       }
  4051.     } catch (error) {
  4052.       // Detect a call to stop() during this.update()
  4053.       if (!this.playerInterface_) {
  4054.         return;
  4055.       }
  4057.       goog.asserts.assert(error instanceof shaka.util.Error,
  4058.           'Should only receive a Shaka error');
  4060.       if (this.config_.raiseFatalErrorOnManifestUpdateRequestFailure) {
  4061.         this.playerInterface_.onError(error);
  4062.         return;
  4063.       }
  4065.       // We will retry updating, so override the severity of the error.
  4066.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  4067.       this.playerInterface_.onError(error);
  4069.       // Try again very soon.
  4070.       this.updatePlaylistTimer_.tickAfter(/* seconds= */ 0.1);
  4071.     }
  4073.     // Detect a call to stop()
  4074.     if (!this.playerInterface_) {
  4075.       return;
  4076.     }
  4078.     this.playerInterface_.onManifestUpdated();
  4079.   }
  4082.   /**
  4083.    * @return {boolean}
  4084.    * @private
  4085.    */
  4086.   isLive_() {
  4087.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  4088.     return this.presentationType_ != PresentationType.VOD;
  4089.   }
  4092.   /**
  4093.    * @return {number}
  4094.    * @private
  4095.    */
  4096.   getUpdatePlaylistDelay_() {
  4097.     // The HLS spec (RFC 8216) states in 6.3.4:
  4098.     // "the client MUST wait for at least the target duration before
  4099.     // attempting to reload the Playlist file again".
  4100.     // For LL-HLS, the server must add a new partial segment to the Playlist
  4101.     // every part target duration.
  4102.     return this.lastTargetDuration_;
  4103.   }
  4106.   /**
  4107.    * @param {shaka.hls.HlsParser.PresentationType_} type
  4108.    * @private
  4109.    */
  4110.   setPresentationType_(type) {
  4111.     this.presentationType_ = type;
  4113.     if (this.presentationTimeline_) {
  4114.       this.presentationTimeline_.setStatic(!this.isLive_());
  4115.     }
  4117.     // If this manifest is not for live content, then we have no reason to
  4118.     // update it.
  4119.     if (!this.isLive_()) {
  4120.       this.updatePlaylistTimer_.stop();
  4121.     }
  4122.   }
  4125.   /**
  4126.    * Create a networking request. This will manage the request using the
  4127.    * parser's operation manager. If the parser has already been stopped, the
  4128.    * request will not be made.
  4129.    *
  4130.    * @param {shaka.extern.Request} request
  4131.    * @param {shaka.net.NetworkingEngine.RequestType} type
  4132.    * @param {shaka.extern.RequestContext=} context
  4133.    * @return {!Promise.<shaka.extern.Response>}
  4134.    * @private
  4135.    */
  4136.   makeNetworkRequest_(request, type, context) {
  4137.     if (!this.operationManager_) {
  4138.       throw new shaka.util.Error(
  4139.           shaka.util.Error.Severity.CRITICAL,
  4140.           shaka.util.Error.Category.PLAYER,
  4141.           shaka.util.Error.Code.OPERATION_ABORTED);
  4142.     }
  4144.     const op = this.playerInterface_.networkingEngine.request(
  4145.         type, request, context);
  4146.     this.operationManager_.manage(op);
  4148.     return op.promise;
  4149.   }
  4151.   /**
  4152.    * @param {string} method
  4153.    * @return {boolean}
  4154.    * @private
  4155.    */
  4156.   isAesMethod_(method) {
  4157.     return method == 'AES-128' ||
  4158.         method == 'AES-256' ||
  4159.         method == 'AES-256-CTR';
  4160.   }
  4162.   /**
  4163.    * @param {!shaka.hls.Tag} drmTag
  4164.    * @param {string} mimeType
  4165.    * @return {?shaka.extern.DrmInfo}
  4166.    * @private
  4167.    */
  4168.   static fairplayDrmParser_(drmTag, mimeType) {
  4169.     if (mimeType == 'video/mp2t') {
  4170.       throw new shaka.util.Error(
  4171.           shaka.util.Error.Severity.CRITICAL,
  4172.           shaka.util.Error.Category.MANIFEST,
  4173.           shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
  4174.     }
  4176.     if (shaka.util.Platform.isMediaKeysPolyfilled()) {
  4177.       throw new shaka.util.Error(
  4178.           shaka.util.Error.Severity.CRITICAL,
  4179.           shaka.util.Error.Category.MANIFEST,
  4180.           shaka.util.Error.Code
  4181.               .HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
  4182.     }
  4184.     const method = drmTag.getRequiredAttrValue('METHOD');
  4185.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4186.     if (!VALID_METHODS.includes(method)) {
  4187.       shaka.log.error('FairPlay in HLS is only supported with [',
  4188.           VALID_METHODS.join(', '), '], not', method);
  4189.       return null;
  4190.     }
  4192.     let encryptionScheme = 'cenc';
  4193.     if (method == 'SAMPLE-AES') {
  4194.       // It should be 'cbcs-1-9' but Safari doesn't support it.
  4195.       // See: https://github.com/WebKit/WebKit/blob/main/Source/WebCore/Modules/encryptedmedia/MediaKeyEncryptionScheme.idl
  4196.       encryptionScheme = 'cbcs';
  4197.     }
  4199.     /*
  4200.      * Even if we're not able to construct initData through the HLS tag, adding
  4201.      * a DRMInfo will allow DRM Engine to request a media key system access
  4202.      * with the correct keySystem and initDataType
  4203.      */
  4204.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4205.         'com.apple.fps', encryptionScheme, [
  4206.           {initDataType: 'sinf', initData: new Uint8Array(0), keyId: null},
  4207.         ]);
  4209.     return drmInfo;
  4210.   }
  4212.   /**
  4213.    * @param {!shaka.hls.Tag} drmTag
  4214.    * @return {?shaka.extern.DrmInfo}
  4215.    * @private
  4216.    */
  4217.   static widevineDrmParser_(drmTag) {
  4218.     const method = drmTag.getRequiredAttrValue('METHOD');
  4219.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4220.     if (!VALID_METHODS.includes(method)) {
  4221.       shaka.log.error('Widevine in HLS is only supported with [',
  4222.           VALID_METHODS.join(', '), '], not', method);
  4223.       return null;
  4224.     }
  4226.     let encryptionScheme = 'cenc';
  4227.     if (method == 'SAMPLE-AES') {
  4228.       encryptionScheme = 'cbcs';
  4229.     }
  4231.     const uri = drmTag.getRequiredAttrValue('URI');
  4232.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri.split('?')[0]);
  4234.     // The data encoded in the URI is a PSSH box to be used as init data.
  4235.     const pssh = shaka.util.BufferUtils.toUint8(parsedData.data);
  4236.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4237.         'com.widevine.alpha', encryptionScheme, [
  4238.           {initDataType: 'cenc', initData: pssh},
  4239.         ]);
  4241.     const keyId = drmTag.getAttributeValue('KEYID');
  4242.     if (keyId) {
  4243.       const keyIdLowerCase = keyId.toLowerCase();
  4244.       // This value should begin with '0x':
  4245.       goog.asserts.assert(
  4246.           keyIdLowerCase.startsWith('0x'), 'Incorrect KEYID format!');
  4247.       // But the output should not contain the '0x':
  4248.       drmInfo.keyIds = new Set([keyIdLowerCase.substr(2)]);
  4249.     }
  4250.     return drmInfo;
  4251.   }
  4253.   /**
  4254.    * See: https://docs.microsoft.com/en-us/playready/packaging/mp4-based-formats-supported-by-playready-clients?tabs=case4
  4255.    *
  4256.    * @param {!shaka.hls.Tag} drmTag
  4257.    * @return {?shaka.extern.DrmInfo}
  4258.    * @private
  4259.    */
  4260.   static playreadyDrmParser_(drmTag) {
  4261.     const method = drmTag.getRequiredAttrValue('METHOD');
  4262.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4263.     if (!VALID_METHODS.includes(method)) {
  4264.       shaka.log.error('PlayReady in HLS is only supported with [',
  4265.           VALID_METHODS.join(', '), '], not', method);
  4266.       return null;
  4267.     }
  4269.     let encryptionScheme = 'cenc';
  4270.     if (method == 'SAMPLE-AES') {
  4271.       encryptionScheme = 'cbcs';
  4272.     }
  4274.     const uri = drmTag.getRequiredAttrValue('URI');
  4275.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri.split('?')[0]);
  4277.     // The data encoded in the URI is a PlayReady Pro Object, so we need
  4278.     // convert it to pssh.
  4279.     const data = shaka.util.BufferUtils.toUint8(parsedData.data);
  4280.     const systemId = new Uint8Array([
  4281.       0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
  4282.       0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
  4283.     ]);
  4284.     const keyIds = new Set();
  4285.     const psshVersion = 0;
  4286.     const pssh =
  4287.         shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  4288.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4289.         'com.microsoft.playready', encryptionScheme, [
  4290.           {initDataType: 'cenc', initData: pssh},
  4291.         ]);
  4293.     return drmInfo;
  4294.   }
  4296.   /**
  4297.    * See: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-5.1
  4298.    *
  4299.    * @param {!shaka.hls.Tag} drmTag
  4300.    * @param {string} mimeType
  4301.    * @param {function():!Array.<string>} getUris
  4302.    * @param {?shaka.media.InitSegmentReference} initSegmentRef
  4303.    * @param {?Map.<string, string>=} variables
  4304.    * @return {!Promise.<?shaka.extern.DrmInfo>}
  4305.    * @private
  4306.    */
  4307.   async identityDrmParser_(drmTag, mimeType, getUris, initSegmentRef,
  4308.       variables) {
  4309.     if (mimeType == 'video/mp2t') {
  4310.       throw new shaka.util.Error(
  4311.           shaka.util.Error.Severity.CRITICAL,
  4312.           shaka.util.Error.Category.MANIFEST,
  4313.           shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
  4314.     }
  4316.     if (shaka.util.Platform.isMediaKeysPolyfilled()) {
  4317.       throw new shaka.util.Error(
  4318.           shaka.util.Error.Severity.CRITICAL,
  4319.           shaka.util.Error.Category.MANIFEST,
  4320.           shaka.util.Error.Code
  4321.               .HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
  4322.     }
  4324.     const method = drmTag.getRequiredAttrValue('METHOD');
  4325.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4326.     if (!VALID_METHODS.includes(method)) {
  4327.       shaka.log.error('Identity (ClearKey) in HLS is only supported with [',
  4328.           VALID_METHODS.join(', '), '], not', method);
  4329.       return null;
  4330.     }
  4332.     const keyUris = shaka.hls.Utils.constructSegmentUris(
  4333.         getUris(), drmTag.getRequiredAttrValue('URI'), variables);
  4335.     let key;
  4336.     if (keyUris[0].startsWith('data:text/plain;base64,')) {
  4337.       key = shaka.util.Uint8ArrayUtils.toHex(
  4338.           shaka.util.Uint8ArrayUtils.fromBase64(
  4339.               keyUris[0].split('data:text/plain;base64,').pop()));
  4340.     } else {
  4341.       const keyMapKey = keyUris.sort().join('');
  4342.       if (!this.identityKeyMap_.has(keyMapKey)) {
  4343.         const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  4344.         const request = shaka.net.NetworkingEngine.makeRequest(
  4345.             keyUris, this.config_.retryParameters);
  4346.         const keyResponse = this.makeNetworkRequest_(request, requestType);
  4347.         this.identityKeyMap_.set(keyMapKey, keyResponse);
  4348.       }
  4349.       const keyResponse = await this.identityKeyMap_.get(keyMapKey);
  4350.       key = shaka.util.Uint8ArrayUtils.toHex(keyResponse.data);
  4351.     }
  4353.     // NOTE: The ClearKey CDM requires a key-id to key mapping.  HLS doesn't
  4354.     // provide a key ID anywhere.  So although we could use the 'URI' attribute
  4355.     // to fetch the actual 16-byte key, without a key ID, we can't provide this
  4356.     // automatically to the ClearKey CDM. By default we assume that keyId is 0,
  4357.     // but we will try to get key ID from Init Segment.
  4358.     // If the application want override this behavior will have to use
  4359.     // player.configure('drm.clearKeys', { ... }) to provide the key IDs
  4360.     // and keys or player.configure('drm.servers.org\.w3\.clearkey', ...) to
  4361.     // provide a ClearKey license server URI.
  4362.     let keyId = '00000000000000000000000000000000';
  4364.     if (initSegmentRef) {
  4365.       let defaultKID;
  4366.       if (this.identityKidMap_.has(initSegmentRef)) {
  4367.         defaultKID = this.identityKidMap_.get(initSegmentRef);
  4368.       } else {
  4369.         const initSegmentRequest = shaka.util.Networking.createSegmentRequest(
  4370.             initSegmentRef.getUris(),
  4371.             initSegmentRef.getStartByte(),
  4372.             initSegmentRef.getEndByte(),
  4373.             this.config_.retryParameters);
  4374.         const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  4375.         const initType =
  4376.             shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
  4377.         const initResponse = await this.makeNetworkRequest_(
  4378.             initSegmentRequest, requestType, {type: initType});
  4380.         defaultKID = shaka.media.SegmentUtils.getDefaultKID(
  4381.             initResponse.data);
  4382.         this.identityKidMap_.set(initSegmentRef, defaultKID);
  4383.       }
  4384.       if (defaultKID) {
  4385.         keyId = defaultKID;
  4386.       }
  4387.     }
  4389.     const clearkeys = new Map();
  4390.     clearkeys.set(keyId, key);
  4392.     let encryptionScheme = 'cenc';
  4393.     if (method == 'SAMPLE-AES') {
  4394.       encryptionScheme = 'cbcs';
  4395.     }
  4397.     return shaka.util.ManifestParserUtils.createDrmInfoFromClearKeys(
  4398.         clearkeys, encryptionScheme);
  4399.   }
  4400. };
  4403. /**
  4404.  * @typedef {{
  4405.  *   stream: !shaka.extern.Stream,
  4406.  *   type: string,
  4407.  *   redirectUris: !Array.<string>,
  4408.  *   getUris: function():!Array.<string>,
  4409.  *   minTimestamp: number,
  4410.  *   maxTimestamp: number,
  4411.  *   mediaSequenceToStartTime: !Map.<number, number>,
  4412.  *   canSkipSegments: boolean,
  4413.  *   canBlockReload: boolean,
  4414.  *   hasEndList: boolean,
  4415.  *   firstSequenceNumber: number,
  4416.  *   nextMediaSequence: number,
  4417.  *   nextPart: number,
  4418.  *   loadedOnce: boolean
  4419.  * }}
  4420.  *
  4421.  * @description
  4422.  * Contains a stream and information about it.
  4423.  *
  4424.  * @property {!shaka.extern.Stream} stream
  4425.  *   The Stream itself.
  4426.  * @property {string} type
  4427.  *   The type value. Could be 'video', 'audio', 'text', or 'image'.
  4428.  * @property {!Array.<string>} redirectUris
  4429.  *   The redirect URIs.
  4430.  * @property {function():!Array.<string>} getUris
  4431.  *   The verbatim media playlist URIs, as it appeared in the master playlist.
  4432.  * @property {number} minTimestamp
  4433.  *   The minimum timestamp found in the stream.
  4434.  * @property {number} maxTimestamp
  4435.  *   The maximum timestamp found in the stream.
  4436.  * @property {!Map.<number, number>} mediaSequenceToStartTime
  4437.  *   A map of media sequence numbers to media start times.
  4438.  *   Only used for VOD content.
  4439.  * @property {boolean} canSkipSegments
  4440.  *   True if the server supports delta playlist updates, and we can send a
  4441.  *   request for a playlist that can skip older media segments.
  4442.  * @property {boolean} canBlockReload
  4443.  *   True if the server supports blocking playlist reload, and we can send a
  4444.  *   request for a playlist that can block reload until some segments are
  4445.  *   present.
  4446.  * @property {boolean} hasEndList
  4447.  *   True if the stream has an EXT-X-ENDLIST tag.
  4448.  * @property {number} firstSequenceNumber
  4449.  *   The sequence number of the first reference. Only calculated if needed.
  4450.  * @property {number} nextMediaSequence
  4451.  *   The next media sequence.
  4452.  * @property {number} nextPart
  4453.  *   The next part.
  4454.  * @property {boolean} loadedOnce
  4455.  *   True if the stream has been loaded at least once.
  4456.  */
  4457. shaka.hls.HlsParser.StreamInfo;
  4460. /**
  4461.  * @typedef {{
  4462.  *   audio: !Array.<shaka.hls.HlsParser.StreamInfo>,
  4463.  *   video: !Array.<shaka.hls.HlsParser.StreamInfo>
  4464.  * }}
  4465.  *
  4466.  * @description Audio and video stream infos.
  4467.  * @property {!Array.<shaka.hls.HlsParser.StreamInfo>} audio
  4468.  * @property {!Array.<shaka.hls.HlsParser.StreamInfo>} video
  4469.  */
  4470. shaka.hls.HlsParser.StreamInfos;
  4473. /**
  4474.  * @const {!Object.<string, string>}
  4475.  * @private
  4476.  */
  4477. shaka.hls.HlsParser.RAW_FORMATS_TO_MIME_TYPES_ = {
  4478.   'aac': 'audio/aac',
  4479.   'ac3': 'audio/ac3',
  4480.   'ec3': 'audio/ec3',
  4481.   'mp3': 'audio/mpeg',
  4482. };
  4485. /**
  4486.  * @const {!Object.<string, string>}
  4487.  * @private
  4488.  */
  4489. shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
  4490.   'mp4': 'audio/mp4',
  4491.   'mp4a': 'audio/mp4',
  4492.   'm4s': 'audio/mp4',
  4493.   'm4i': 'audio/mp4',
  4494.   'm4a': 'audio/mp4',
  4495.   'm4f': 'audio/mp4',
  4496.   'cmfa': 'audio/mp4',
  4497.   // MPEG2-TS also uses video/ for audio: https://bit.ly/TsMse
  4498.   'ts': 'video/mp2t',
  4499.   'tsa': 'video/mp2t',
  4500. };
  4503. /**
  4504.  * @const {!Object.<string, string>}
  4505.  * @private
  4506.  */
  4507. shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = {
  4508.   'mp4': 'video/mp4',
  4509.   'mp4v': 'video/mp4',
  4510.   'm4s': 'video/mp4',
  4511.   'm4i': 'video/mp4',
  4512.   'm4v': 'video/mp4',
  4513.   'm4f': 'video/mp4',
  4514.   'cmfv': 'video/mp4',
  4515.   'ts': 'video/mp2t',
  4516.   'tsv': 'video/mp2t',
  4517. };
  4520. /**
  4521.  * @const {!Object.<string, string>}
  4522.  * @private
  4523.  */
  4524. shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_ = {
  4525.   'mp4': 'application/mp4',
  4526.   'm4s': 'application/mp4',
  4527.   'm4i': 'application/mp4',
  4528.   'm4f': 'application/mp4',
  4529.   'cmft': 'application/mp4',
  4530.   'vtt': 'text/vtt',
  4531.   'webvtt': 'text/vtt',
  4532.   'ttml': 'application/ttml+xml',
  4533. };
  4536. /**
  4537.  * @const {!Object.<string, string>}
  4538.  * @private
  4539.  */
  4540. shaka.hls.HlsParser.IMAGE_EXTENSIONS_TO_MIME_TYPES_ = {
  4541.   'jpg': 'image/jpeg',
  4542.   'png': 'image/png',
  4543.   'svg': 'image/svg+xml',
  4544.   'webp': 'image/webp',
  4545.   'avif': 'image/avif',
  4546. };
  4549. /**
  4550.  * @const {!Object.<string, !Object.<string, string>>}
  4551.  * @private
  4552.  */
  4553. shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_ = {
  4554.   'audio': shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_,
  4555.   'video': shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_,
  4556.   'text': shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_,
  4557.   'image': shaka.hls.HlsParser.IMAGE_EXTENSIONS_TO_MIME_TYPES_,
  4558. };
  4561. /**
  4562.  * @typedef {function(!shaka.hls.Tag, string):?shaka.extern.DrmInfo}
  4563.  * @private
  4564.  */
  4565. shaka.hls.HlsParser.DrmParser_;
  4568. /**
  4569.  * @const {!Object.<string, shaka.hls.HlsParser.DrmParser_>}
  4570.  * @private
  4571.  */
  4572. shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
  4573.   'com.apple.streamingkeydelivery':
  4574.       shaka.hls.HlsParser.fairplayDrmParser_,
  4575.   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
  4576.       shaka.hls.HlsParser.widevineDrmParser_,
  4577.   'com.microsoft.playready':
  4578.       shaka.hls.HlsParser.playreadyDrmParser_,
  4579. };
  4582. /**
  4583.  * @enum {string}
  4584.  * @private
  4585.  */
  4586. shaka.hls.HlsParser.PresentationType_ = {
  4587.   VOD: 'VOD',
  4588.   EVENT: 'EVENT',
  4589.   LIVE: 'LIVE',
  4590. };
  4592. shaka.media.ManifestParser.registerParserByMime(
  4593.     'application/x-mpegurl', () => new shaka.hls.HlsParser());
  4594. shaka.media.ManifestParser.registerParserByMime(
  4595.     'application/vnd.apple.mpegurl', () => new shaka.hls.HlsParser());