Source: lib/hls/hls_parser.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  19. goog.provide('shaka.hls.HlsParser');
  21. goog.require('goog.Uri');
  22. goog.require('goog.asserts');
  23. goog.require('shaka.hls.ManifestTextParser');
  24. goog.require('shaka.hls.Playlist');
  25. goog.require('shaka.hls.PlaylistType');
  26. goog.require('shaka.hls.Tag');
  27. goog.require('shaka.hls.Utils');
  28. goog.require('shaka.log');
  29. goog.require('shaka.media.DrmEngine');
  30. goog.require('shaka.media.InitSegmentReference');
  31. goog.require('shaka.media.ManifestParser');
  32. goog.require('shaka.media.PresentationTimeline');
  33. goog.require('shaka.media.SegmentIndex');
  34. goog.require('shaka.media.SegmentReference');
  35. goog.require('shaka.net.DataUriPlugin');
  36. goog.require('shaka.net.NetworkingEngine');
  37. goog.require('shaka.text.TextEngine');
  38. goog.require('shaka.util.DataViewReader');
  39. goog.require('shaka.util.Error');
  40. goog.require('shaka.util.Functional');
  41. goog.require('shaka.util.LanguageUtils');
  42. goog.require('shaka.util.ManifestParserUtils');
  43. goog.require('shaka.util.MimeUtils');
  44. goog.require('shaka.util.Mp4Parser');
  45. goog.require('shaka.util.OperationManager');
  49. /**
  50.  * Creates a new HLS parser.
  51.  *
  52.  * @struct
  53.  * @constructor
  54.  * @implements {shakaExtern.ManifestParser}
  55.  * @export
  56.  */
  57. shaka.hls.HlsParser = function() {
  58.   /** @private {?shakaExtern.ManifestParser.PlayerInterface} */
  59.   this.playerInterface_ = null;
  61.   /** @private {?shakaExtern.ManifestConfiguration} */
  62.   this.config_ = null;
  64.   /** @private {number} */
  65.   this.globalId_ = 1;
  67.   /**
  68.    * @private {!Map.<number, shaka.hls.HlsParser.StreamInfo>}
  69.    */
  70.   // TODO: This is now only used for text codec detection, try to remove.
  71.   this.mediaTagsToStreamInfosMap_ = new Map();
  73.   /**
  74.    * The values are strings of the form "<VIDEO URI> - <AUDIO URI>",
  75.    * where the URIs are the verbatim media playlist URIs as they appeared in the
  76.    * master playlist.
  77.    *
  78.    * Used to avoid duplicates that vary only in their text stream.
  79.    *
  80.    * @private {!Set.<string>}
  81.    */
  82.   this.variantUriSet_ = new Set();
  84.   /**
  85.    * A map from (verbatim) media playlist URI to stream infos representing the
  86.    * playlists.
  87.    *
  88.    * On update, used to iterate through and update from media playlists.
  89.    *
  90.    * On initial parse, used to iterate through and determine minimum timestamps,
  91.    * offsets, and to handle TS rollover.
  92.    *
  93.    * During parsing, used to avoid duplicates in the async methods
  94.    * createStreamInfoFromMediaTag_ and createStreamInfoFromVariantTag_.
  95.    *
  96.    * During parsing of updates, used by getStartTime_ to determine the start
  97.    * time of the first segment from existing segment references.
  98.    *
  99.    * @private {!Map.<string, shaka.hls.HlsParser.StreamInfo>}
  100.    */
  101.   this.uriToStreamInfosMap_ = new Map();
  103.   /** @private {?shaka.media.PresentationTimeline} */
  104.   this.presentationTimeline_ = null;
  106.   /**
  107.    * The master playlist URI, after redirects.
  108.    *
  109.    * @private {string}
  110.    */
  111.   this.masterPlaylistUri_ = '';
  113.   /** @private {shaka.hls.ManifestTextParser} */
  114.   this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
  116.   /**
  117.    * The update period in seconds, or null for no updates.
  118.    * @private {?number}
  119.    */
  120.   this.updatePeriod_ = null;
  122.   /** @private {?number} */
  123.   this.updateTimer_ = null;
  125.   /** @private {shaka.hls.HlsParser.PresentationType_} */
  126.   this.presentationType_ = shaka.hls.HlsParser.PresentationType_.VOD;
  128.   /** @private {?shakaExtern.Manifest} */
  129.   this.manifest_ = null;
  131.   /** @private {number} */
  132.   this.maxTargetDuration_ = 0;
  134.   /** @private {number} */
  135.   this.minTargetDuration_ = Infinity;
  137.   /** @private {!shaka.util.OperationManager} */
  138.   this.operationManager_ = new shaka.util.OperationManager();
  140.   /** @private {!Array.<!Array.<!shaka.media.SegmentReference>>} */
  141.   this.segmentsToNotifyByStream_ = [];
  142. };
  145. /**
  146.  * @typedef {{
  147.  *   stream: !shakaExtern.Stream,
  148.  *   segmentIndex: !shaka.media.SegmentIndex,
  149.  *   drmInfos: !Array.<shakaExtern.DrmInfo>,
  150.  *   verbatimMediaPlaylistUri: string,
  151.  *   absoluteMediaPlaylistUri: string,
  152.  *   minTimestamp: number,
  153.  *   maxTimestamp: number,
  154.  *   duration: number
  155.  * }}
  156.  *
  157.  * @description
  158.  * Contains a stream and information about it.
  159.  *
  160.  * @property {!shakaExtern.Stream} stream
  161.  *   The Stream itself.
  162.  * @property {!shaka.media.SegmentIndex} segmentIndex
  163.  *   SegmentIndex of the stream.
  164.  * @property {!Array.<shakaExtern.DrmInfo>} drmInfos
  165.  *   DrmInfos of the stream.  There may be multiple for multi-DRM content.
  166.  * @property {string} verbatimMediaPlaylistUri
  167.  *   The verbatim media playlist URI, as it appeared in the master playlist.
  168.  *   This has not been canonicalized into an absolute URI.  This gives us a
  169.  *   consistent key for this playlist, even if redirects cause us to update
  170.  *   from different origins each time.
  171.  * @property {string} absoluteMediaPlaylistUri
  172.  *   The absolute media playlist URI, resolved relative to the master playlist
  173.  *   and updated to reflect any redirects.
  174.  * @property {number} minTimestamp
  175.  *   The minimum timestamp found in the stream.
  176.  * @property {number} maxTimestamp
  177.  *   The maximum timestamp found in the stream.
  178.  * @property {number} duration
  179.  *   The duration of the playlist.  Used for VOD only.
  180.  */
  181. shaka.hls.HlsParser.StreamInfo;
  184. /**
  185.  * @override
  186.  * @exportInterface
  187.  */
  188. shaka.hls.HlsParser.prototype.configure = function(config) {
  189.   this.config_ = config;
  190. };
  193. /**
  194.  * @override
  195.  * @exportInterface
  196.  */
  197. shaka.hls.HlsParser.prototype.start = function(uri, playerInterface) {
  198.   goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  199.   this.playerInterface_ = playerInterface;
  201.   return this.requestManifest_(uri).then(function(response) {
  202.     // Record the master playlist URI after redirects.
  203.     this.masterPlaylistUri_ = response.uri;
  205.     return this.parseManifest_(response.data).then(function() {
  206.       this.setUpdateTimer_(this.updatePeriod_);
  207.       return this.manifest_;
  208.     }.bind(this));
  209.   }.bind(this));
  210. };
  213. /**
  214.  * @override
  215.  * @exportInterface
  216.  */
  217. shaka.hls.HlsParser.prototype.stop = function() {
  218.   this.playerInterface_ = null;
  219.   this.config_ = null;
  220.   this.mediaTagsToStreamInfosMap_.clear();
  221.   this.variantUriSet_.clear();
  222.   this.uriToStreamInfosMap_.clear();
  223.   this.manifest_ = null;
  224.   return this.operationManager_.destroy();
  225. };
  228. /**
  229.  * @override
  230.  * @exportInterface
  231.  */
  232. shaka.hls.HlsParser.prototype.update = function() {
  233.   if (!this.isLive_()) {
  234.     return;
  235.   }
  237.   const promises = [];
  239.   for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  240.     promises.push(this.updateStream_(streamInfo));
  241.   }
  243.   return Promise.all(promises);
  244. };
  247. /**
  248.  * Updates a stream.
  249.  *
  250.  * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  251.  * @throws shaka.util.Error
  252.  * @private
  253.  */
  254. shaka.hls.HlsParser.prototype.updateStream_ = function(streamInfo) {
  255.   this.requestManifest_(streamInfo.absoluteMediaPlaylistUri).then(
  256.       function(response) {
  257.     const Utils = shaka.hls.Utils;
  258.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  259.     const playlist = this.manifestTextParser_.parsePlaylist(
  260.         response.data, response.uri);
  261.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  262.       throw new shaka.util.Error(
  263.           shaka.util.Error.Severity.CRITICAL,
  264.           shaka.util.Error.Category.MANIFEST,
  265.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  266.     }
  268.     let mediaSequenceTag = Utils.getFirstTagWithName(playlist.tags,
  269.                                                      'EXT-X-MEDIA-SEQUENCE');
  271.     let startPosition = mediaSequenceTag ? Number(mediaSequenceTag.value) : 0;
  272.     let stream = streamInfo.stream;
  273.     this.createSegments_(streamInfo.verbatimMediaPlaylistUri, playlist,
  274.                          startPosition, stream.mimeType, stream.codecs)
  275.         .then(function(segments) {
  276.           streamInfo.segmentIndex.replace(segments);
  278.           let newestSegment = segments[segments.length - 1];
  279.           goog.asserts.assert(newestSegment, 'Should have segments!');
  281.           // Once the last segment has been added to the playlist,
  282.           // #EXT-X-ENDLIST tag will be appended.
  283.           // If that happened, treat the rest of the EVENT presentation as VOD.
  284.           let endListTag = Utils.getFirstTagWithName(playlist.tags,
  285.                                                      'EXT-X-ENDLIST');
  286.           if (endListTag) {
  287.             // Convert the presentation to VOD and set the duration to the last
  288.             // segment's end time.
  289.             this.setPresentationType_(PresentationType.VOD);
  290.             this.presentationTimeline_.setDuration(newestSegment.endTime);
  291.           }
  292.         }.bind(this));
  293.   }.bind(this));
  294. };
  297. /**
  298.  * @override
  299.  * @exportInterface
  300.  */
  301. shaka.hls.HlsParser.prototype.onExpirationUpdated = function(
  302.     sessionId, expiration) {
  303.   // No-op
  304. };
  307. /**
  308.  * Parses the manifest.
  309.  *
  310.  * @param {!ArrayBuffer} data
  311.  * @throws shaka.util.Error When there is a parsing error.
  312.  * @return {!Promise}
  313.  * @private
  314.  */
  315. shaka.hls.HlsParser.prototype.parseManifest_ = function(data) {
  316.   goog.asserts.assert(this.masterPlaylistUri_,
  317.       'Master playlist URI must be set before calling parseManifest_!');
  319.   const playlist = this.manifestTextParser_.parsePlaylist(
  320.       data, this.masterPlaylistUri_);
  322.   // We don't support directly providing a Media Playlist.
  323.   // See the error code for details.
  324.   if (playlist.type != shaka.hls.PlaylistType.MASTER) {
  325.     throw new shaka.util.Error(
  326.         shaka.util.Error.Severity.CRITICAL,
  327.         shaka.util.Error.Category.MANIFEST,
  328.         shaka.util.Error.Code.HLS_MASTER_PLAYLIST_NOT_PROVIDED);
  329.   }
  331.   return this.createPeriod_(playlist).then(function(period) {
  332.     // HLS has no notion of periods.  We're treating the whole presentation as
  333.     // one period.
  334.     this.playerInterface_.filterAllPeriods([period]);
  336.     // Find the min and max timestamp of the earliest segment in all streams.
  337.     // Find the minimum duration of all streams as well.
  338.     let minFirstTimestamp = Infinity;
  339.     let maxFirstTimestamp = 0;
  340.     let maxLastTimestamp = 0;
  341.     let minDuration = Infinity;
  343.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  344.       minFirstTimestamp =
  345.           Math.min(minFirstTimestamp, streamInfo.minTimestamp);
  346.       maxFirstTimestamp =
  347.           Math.max(maxFirstTimestamp, streamInfo.minTimestamp);
  348.       maxLastTimestamp =
  349.           Math.max(maxLastTimestamp, streamInfo.maxTimestamp);
  350.       if (streamInfo.stream.type != 'text') {
  351.         minDuration = Math.min(minDuration, streamInfo.duration);
  352.       }
  353.     }
  355.     goog.asserts.assert(this.presentationTimeline_ == null,
  356.                         'Presentation timeline created early!');
  357.     this.createPresentationTimeline_(maxLastTimestamp);
  359.     if (this.isLive_()) {
  360.       // The HLS spec (RFC 8216) states in 6.3.3:
  361.       //
  362.       // "The client SHALL choose which Media Segment to play first ... the
  363.       // client SHOULD NOT choose a segment that starts less than three target
  364.       // durations from the end of the Playlist file.  Doing so can trigger
  365.       // playback stalls."
  366.       //
  367.       // We accomplish this in our DASH-y model by setting a presentation delay
  368.       // of 3 segments.  This will be the "live edge" of the presentation.
  369.       let threeSegmentDurations = this.maxTargetDuration_ * 3;
  370.       this.presentationTimeline_.setDelay(threeSegmentDurations);
  372.       // The HLS spec (RFC 8216) states in 6.3.4:
  373.       // "the client MUST wait for at least the target duration before
  374.       // attempting to reload the Playlist file again"
  375.       this.updatePeriod_ = this.minTargetDuration_;
  377.       // The spec says nothing much about seeking in live content, but Safari's
  378.       // built-in HLS implementation does not allow it.  Therefore we will set
  379.       // the availability window equal to the presentation delay.  The player
  380.       // will be able to buffer ahead three segments, but the seek window will
  381.       // be zero-sized.
  382.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  384.       if (this.presentationType_ == PresentationType.LIVE) {
  385.         let segmentAvailabilityDuration = threeSegmentDurations;
  386.         if (!isNaN(this.config_.availabilityWindowOverride)) {
  387.           segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
  388.         }
  389.         this.presentationTimeline_.setSegmentAvailabilityDuration(
  390.             segmentAvailabilityDuration);
  391.       }
  393.       let rolloverSeconds =
  394.           shaka.hls.HlsParser.TS_ROLLOVER_ / shaka.hls.HlsParser.TS_TIMESCALE_;
  395.       let offset = 0;
  396.       while (maxFirstTimestamp >= rolloverSeconds) {
  397.         offset += rolloverSeconds;
  398.         maxFirstTimestamp -= rolloverSeconds;
  399.       }
  400.       if (offset) {
  401.         shaka.log.debug('Offsetting live streams by', offset,
  402.                         'to compensate for rollover');
  404.         for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  405.           if (streamInfo.minTimestamp < rolloverSeconds) {
  406.             shaka.log.v1('Offset applied to', streamInfo.stream.type);
  407.             // This is the offset that StreamingEngine must apply to align the
  408.             // actual segment times with the period.
  409.             streamInfo.stream.presentationTimeOffset = -offset;
  410.             // The segments were created with actual media times, rather than
  411.             // period-aligned times, so offset them all to period time.
  412.             streamInfo.segmentIndex.offset(offset);
  413.           } else {
  414.             shaka.log.v1('Offset NOT applied to', streamInfo.stream.type);
  415.           }
  416.         }
  417.       }
  418.     } else {
  419.       // For VOD/EVENT content, offset everything back to 0.
  420.       // Use the minimum timestamp as the offset for all streams.
  421.       // Use the minimum duration as the presentation duration.
  422.       this.presentationTimeline_.setDuration(minDuration);
  423.       // Use a negative offset to adjust towards 0.
  424.       this.presentationTimeline_.offset(-minFirstTimestamp);
  426.       for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  427.         // This is the offset that StreamingEngine must apply to align the
  428.         // actual segment times with the period.
  429.         streamInfo.stream.presentationTimeOffset = minFirstTimestamp;
  430.         // The segments were created with actual media times, rather than
  431.         // period-aligned times, so offset them all now.
  432.         streamInfo.segmentIndex.offset(-minFirstTimestamp);
  433.         // Finally, fit the segments to the period duration.
  434.         streamInfo.segmentIndex.fit(minDuration);
  435.       }
  436.     }
  438.     this.manifest_ = {
  439.       presentationTimeline: this.presentationTimeline_,
  440.       periods: [period],
  441.       offlineSessionIds: [],
  442.       minBufferTime: 0
  443.     };
  444.   }.bind(this));
  445. };
  448. /**
  449.  * Parses a playlist into a Period object.
  450.  *
  451.  * @param {!shaka.hls.Playlist} playlist
  452.  * @return {!Promise.<!shakaExtern.Period>}
  453.  * @private
  454.  */
  455. shaka.hls.HlsParser.prototype.createPeriod_ = function(playlist) {
  456.   const Utils = shaka.hls.Utils;
  457.   const Functional = shaka.util.Functional;
  458.   let tags = playlist.tags;
  460.   let mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
  461.   let textStreamTags = mediaTags.filter(function(tag) {
  462.     let type = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  463.     return type == 'SUBTITLES';
  464.   }.bind(this));
  466.   // TODO: CLOSED-CAPTIONS requires the parsing of CEA-608 from the video.
  467.   let textStreamPromises = textStreamTags.map(function(tag) {
  468.     return this.createTextStream_(tag, playlist);
  469.   }.bind(this));
  471.   return Promise.all(textStreamPromises).then(function(textStreams) {
  472.     // Create Variants for every 'EXT-X-STREAM-INF' tag.  Do this after text
  473.     // streams have been created, so that we can push text codecs found on the
  474.     // variant tag back into the created text streams.
  475.     let variantTags = Utils.filterTagsByName(tags, 'EXT-X-STREAM-INF');
  476.     let variantsPromises = variantTags.map(function(tag) {
  477.       return this.createVariantsForTag_(tag, playlist);
  478.     }.bind(this));
  480.     return Promise.all(variantsPromises).then(function(allVariants) {
  481.       let variants = allVariants.reduce(Functional.collapseArrays, []);
  482.       return {
  483.         startTime: 0,
  484.         variants: variants,
  485.         textStreams: textStreams
  486.       };
  487.     }.bind(this));
  488.   }.bind(this));
  489. };
  492. /**
  493.  * @param {!shaka.hls.Tag} tag
  494.  * @param {!shaka.hls.Playlist} playlist
  495.  * @return {!Promise.<!Array.<!shakaExtern.Variant>>}
  496.  * @private
  497.  */
  498. shaka.hls.HlsParser.prototype.createVariantsForTag_ = function(tag, playlist) {
  499.   goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  500.                       'Should only be called on variant tags!');
  501.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  502.   const HlsParser = shaka.hls.HlsParser;
  503.   const Utils = shaka.hls.Utils;
  505.   // These are the default codecs to assume if none are specified.
  506.   //
  507.   // The video codec is H.264, with baseline profile and level 3.0.
  508.   // http://blog.pearce.org.nz/2013/11/what-does-h264avc1-codecs-parameters.html
  509.   //
  510.   // The audio codec is "low-complexity" AAC.
  511.   const defaultCodecs = 'avc1.42E01E,mp4a.40.2';
  513.   const codecsString = tag.getAttributeValue('CODECS', defaultCodecs);
  514.   // Strip out internal whitespace while splitting on commas:
  515.   /** @type {!Array.<string>} */
  516.   let codecs = codecsString.split(/\s*,\s*/);
  517.   let resolutionAttr = tag.getAttribute('RESOLUTION');
  518.   let width = null;
  519.   let height = null;
  520.   let frameRate = tag.getAttributeValue('FRAME-RATE');
  521.   let bandwidth =
  522.       Number(HlsParser.getRequiredAttributeValue_(tag, 'BANDWIDTH'));
  524.   if (resolutionAttr) {
  525.     let resBlocks = resolutionAttr.value.split('x');
  526.     width = resBlocks[0];
  527.     height = resBlocks[1];
  528.   }
  530.   // After filtering, this is a list of the media tags we will process to
  531.   // combine with the variant tag (EXT-X-STREAM-INF) we are working on.
  532.   let mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
  534.   // Do not create stream info from closed captions media tags, which are
  535.   // embedded in video streams.
  536.   mediaTags = mediaTags.filter((tag) => {
  537.     const type = HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  538.     return type != 'CLOSED-CAPTIONS';
  539.   });
  541.   // AUDIO or VIDEO tags without a URI attribute are valid.
  542.   // If there is no uri, it means that audio/video is embedded in the
  543.   // stream described by the Variant tag.
  544.   // Do not create stream from AUDIO/VIDEO EXT-X-MEDIA tags without URI
  545.   mediaTags = mediaTags.filter((tag) => {
  546.     const uri = tag.getAttributeValue('URI') || '';
  547.     const type = tag.getAttributeValue('TYPE') || '';
  548.     return type == 'SUBTITLES' || uri != '';
  549.   });
  551.   let audioGroupId = tag.getAttributeValue('AUDIO');
  552.   let videoGroupId = tag.getAttributeValue('VIDEO');
  553.   goog.asserts.assert(audioGroupId == null || videoGroupId == null,
  554.       'Unexpected: both video and audio described by media tags!');
  556.   // Find any associated audio or video groups and create streams for them.
  557.   if (audioGroupId) {
  558.     mediaTags = Utils.findMediaTags(mediaTags, 'AUDIO', audioGroupId);
  559.   } else if (videoGroupId) {
  560.     mediaTags = Utils.findMediaTags(mediaTags, 'VIDEO', videoGroupId);
  561.   }
  563.   // There may be a codec string for the text stream.  We should identify it,
  564.   // add it to the appropriate stream, then strip it out of the variant to
  565.   // avoid confusing our multiplex detection below.
  566.   let textCodecs = this.guessCodecsSafe_(ContentType.TEXT, codecs);
  567.   if (textCodecs) {
  568.     // We found a text codec in the list, so look for an associated text stream.
  569.     let subGroupId = tag.getAttributeValue('SUBTITLES');
  570.     if (subGroupId) {
  571.       let textTags = Utils.findMediaTags(mediaTags, 'SUBTITLES', subGroupId);
  572.       goog.asserts.assert(textTags.length == 1,
  573.                           'Exactly one text tag expected!');
  574.       if (textTags.length) {
  575.         // We found a text codec and text stream, so make sure the codec is
  576.         // attached to the stream.
  577.         const textStreamInfo =
  578.             this.mediaTagsToStreamInfosMap_.get(textTags[0].id);
  579.         textStreamInfo.stream.codecs = textCodecs;
  580.       }
  581.     }
  583.     // Remove this entry from the list of codecs that belong to audio/video.
  584.     codecs.splice(codecs.indexOf(textCodecs), 1);
  585.   }
  587.   let promises = mediaTags.map(function(tag) {
  588.     return this.createStreamInfoFromMediaTag_(tag, codecs);
  589.   }.bind(this));
  591.   let audioStreamInfos = [];
  592.   let videoStreamInfos = [];
  594.   return Promise.all(promises).then(function(data) {
  595.     if (audioGroupId) {
  596.       audioStreamInfos = data;
  597.     } else if (videoGroupId) {
  598.       videoStreamInfos = data;
  599.     }
  601.     // Make an educated guess about the stream type.
  602.     shaka.log.debug('Guessing stream type for', tag.toString());
  603.     let type;
  604.     let ignoreStream = false;
  605.     if (!audioStreamInfos.length && !videoStreamInfos.length) {
  606.       // There are no associated streams.  This is either an audio-only stream,
  607.       // a video-only stream, or a multiplexed stream.
  609.       if (codecs.length == 1) {
  610.         // There is only one codec, so it shouldn't be multiplexed.
  612.         let videoCodecs = this.guessCodecsSafe_(ContentType.VIDEO, codecs);
  613.         if (resolutionAttr || frameRate || videoCodecs) {
  614.           // Assume video-only.
  615.           shaka.log.debug('Guessing video-only.');
  616.           type = ContentType.VIDEO;
  617.         } else {
  618.           // Assume audio-only.
  619.           shaka.log.debug('Guessing audio-only.');
  620.           type = ContentType.AUDIO;
  621.         }
  622.       } else {
  623.         // There are multiple codecs, so assume multiplexed content.
  624.         // Note that the default used when CODECS is missing assumes multiple
  625.         // (and therefore multiplexed).
  626.         // Recombine the codec strings into one so that MediaSource isn't
  627.         // lied to later.  (That would trigger an error in Chrome.)
  628.         shaka.log.debug('Guessing multiplexed audio+video.');
  629.         type = ContentType.VIDEO;
  630.         codecs = [codecs.join(',')];
  631.       }
  632.     } else if (audioStreamInfos.length) {
  633.       let streamURI = HlsParser.getRequiredAttributeValue_(tag, 'URI');
  634.       let firstAudioStreamURI = audioStreamInfos[0].verbatimMediaPlaylistUri;
  635.       if (streamURI == firstAudioStreamURI) {
  636.         // The Microsoft HLS manifest generators will make audio-only variants
  637.         // that link to their URI both directly and through an audio tag.
  638.         // In that case, ignore the local URI and use the version in the
  639.         // AUDIO tag, so you inherit its language.
  640.         // As an example, see the manifest linked in issue #860.
  641.         shaka.log.debug('Guessing audio-only.');
  642.         type = ContentType.AUDIO;
  643.         ignoreStream = true;
  644.       } else {
  645.         // There are associated audio streams.  Assume this is video.
  646.         shaka.log.debug('Guessing video.');
  647.         type = ContentType.VIDEO;
  648.       }
  649.     } else {
  650.       // There are associated video streams.  Assume this is audio.
  651.       goog.asserts.assert(videoStreamInfos.length,
  652.           'No video streams!  This should have been handled already!');
  653.       shaka.log.debug('Guessing audio.');
  654.       type = ContentType.AUDIO;
  655.     }
  657.     goog.asserts.assert(type, 'Type should have been set by now!');
  658.     if (ignoreStream) {
  659.       return Promise.resolve();
  660.     }
  661.     return this.createStreamInfoFromVariantTag_(tag, codecs, type);
  662.   }.bind(this)).then(function(streamInfo) {
  663.     if (streamInfo) {
  664.       if (streamInfo.stream.type == ContentType.AUDIO) {
  665.         audioStreamInfos = [streamInfo];
  666.       } else {
  667.         videoStreamInfos = [streamInfo];
  668.       }
  669.     }
  670.     goog.asserts.assert(videoStreamInfos || audioStreamInfos,
  671.         'We should have created a stream!');
  673.     if (videoStreamInfos) {
  674.       this.filterLegacyCodecs_(videoStreamInfos);
  675.     }
  676.     if (audioStreamInfos) {
  677.       this.filterLegacyCodecs_(audioStreamInfos);
  678.     }
  680.     return this.createVariants_(
  681.         audioStreamInfos,
  682.         videoStreamInfos,
  683.         bandwidth,
  684.         width,
  685.         height,
  686.         frameRate);
  687.   }.bind(this));
  688. };
  691. /**
  692.  * Filters out unsupported codec strings from an array of stream infos.
  693.  * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} streamInfos
  694.  * @private
  695.  */
  696. shaka.hls.HlsParser.prototype.filterLegacyCodecs_ = function(streamInfos) {
  697.   streamInfos.forEach(function(streamInfo) {
  698.     let codecs = streamInfo.stream.codecs.split(',');
  699.     codecs = codecs.filter(function(codec) {
  700.       // mp4a.40.34 is a nonstandard codec string that is sometimes used in HLS
  701.       // for legacy reasons.  It is not recognized by non-Apple MSE.
  702.       // See https://bugs.chromium.org/p/chromium/issues/detail?id=489520
  703.       // Therefore, ignore this codec string.
  704.       return codec != 'mp4a.40.34';
  705.     });
  706.     streamInfo.stream.codecs = codecs.join(',');
  707.   });
  708. };
  711. /**
  712.  * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} audioInfos
  713.  * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} videoInfos
  714.  * @param {number} bandwidth
  715.  * @param {?string} width
  716.  * @param {?string} height
  717.  * @param {?string} frameRate
  718.  * @return {!Array.<!shakaExtern.Variant>}
  719.  * @private
  720.  */
  721. shaka.hls.HlsParser.prototype.createVariants_ =
  722.     function(audioInfos, videoInfos, bandwidth, width, height, frameRate) {
  723.   const DrmEngine = shaka.media.DrmEngine;
  725.   videoInfos.forEach(function(info) {
  726.     this.addVideoAttributes_(info.stream, width, height, frameRate);
  727.   }.bind(this));
  729.   // In case of audio-only or video-only content, we create an array of
  730.   // one item containing a null.  This way, the double-loop works for all
  731.   // kinds of content.
  732.   // NOTE: we currently don't have support for audio-only content.
  733.   if (!audioInfos.length) {
  734.     audioInfos = [null];
  735.   }
  736.   if (!videoInfos.length) {
  737.     videoInfos = [null];
  738.   }
  740.   let variants = [];
  741.   for (let i = 0; i < audioInfos.length; i++) {
  742.     for (let j = 0; j < videoInfos.length; j++) {
  743.       let audioStream = audioInfos[i] ? audioInfos[i].stream : null;
  744.       let videoStream = videoInfos[j] ? videoInfos[j].stream : null;
  745.       let audioDrmInfos = audioInfos[i] ? audioInfos[i].drmInfos : null;
  746.       let videoDrmInfos = videoInfos[j] ? videoInfos[j].drmInfos : null;
  748.       let drmInfos;
  749.       if (audioStream && videoStream) {
  750.         if (DrmEngine.areDrmCompatible(audioDrmInfos, videoDrmInfos)) {
  751.           drmInfos = DrmEngine.getCommonDrmInfos(audioDrmInfos, videoDrmInfos);
  752.         } else {
  753.           shaka.log.warning('Incompatible DRM info in HLS variant.  Skipping.');
  754.           continue;
  755.         }
  756.       } else if (audioStream) {
  757.         drmInfos = audioDrmInfos;
  758.       } else if (videoStream) {
  759.         drmInfos = videoDrmInfos;
  760.       }
  762.       const videoStreamUri =
  763.           videoInfos[i] ? videoInfos[i].verbatimMediaPlaylistUri : '';
  764.       const audioStreamUri =
  765.           audioInfos[i] ? audioInfos[i].verbatimMediaPlaylistUri : '';
  766.       const variantUriKey = videoStreamUri + ' - ' + audioStreamUri;
  767.       if (this.variantUriSet_.has(variantUriKey)) {
  768.         // This happens when two variants only differ in their text streams.
  769.         shaka.log.debug('Skipping variant which only differs in text streams.');
  770.         continue;
  771.       }
  773.       let variant = this.createVariant_(
  774.           audioStream, videoStream, bandwidth, drmInfos);
  775.       variants.push(variant);
  776.       this.variantUriSet_.add(variantUriKey);
  777.     }
  778.   }
  779.   return variants;
  780. };
  783. /**
  784.  * @param {shakaExtern.Stream} audio
  785.  * @param {shakaExtern.Stream} video
  786.  * @param {number} bandwidth
  787.  * @param {!Array.<shakaExtern.DrmInfo>} drmInfos
  788.  * @return {!shakaExtern.Variant}
  789.  * @private
  790.  */
  791. shaka.hls.HlsParser.prototype.createVariant_ =
  792.     function(audio, video, bandwidth, drmInfos) {
  793.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  795.   // Since both audio and video are of the same type, this assertion will catch
  796.   // certain mistakes at runtime that the compiler would miss.
  797.   goog.asserts.assert(!audio || audio.type == ContentType.AUDIO,
  798.                       'Audio parameter mismatch!');
  799.   goog.asserts.assert(!video || video.type == ContentType.VIDEO,
  800.                       'Video parameter mismatch!');
  802.   return {
  803.     id: this.globalId_++,
  804.     language: audio ? audio.language : 'und',
  805.     primary: (!!audio && audio.primary) || (!!video && video.primary),
  806.     audio: audio,
  807.     video: video,
  808.     bandwidth: bandwidth,
  809.     drmInfos: drmInfos,
  810.     allowedByApplication: true,
  811.     allowedByKeySystem: true
  812.   };
  813. };
  816. /**
  817.  * Parses an EXT-X-MEDIA tag with TYPE="SUBTITLES" into a text stream.
  818.  *
  819.  * @param {!shaka.hls.Tag} tag
  820.  * @param {!shaka.hls.Playlist} playlist
  821.  * @return {!Promise.<?shakaExtern.Stream>}
  822.  * @private
  823.  */
  824. shaka.hls.HlsParser.prototype.createTextStream_ = function(tag, playlist) {
  825.   goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  826.                       'Should only be called on media tags!');
  828.   let type = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  829.   goog.asserts.assert(type == 'SUBTITLES',
  830.                       'Should only be called on tags with TYPE="SUBTITLES"!');
  832.   return this.createStreamInfoFromMediaTag_(tag, [])
  833.     .then(function(streamInfo) {
  834.         return streamInfo.stream;
  835.       });
  836. };
  839. /**
  840.  * Parse EXT-X-MEDIA media tag into a Stream object.
  841.  *
  842.  * @param {shaka.hls.Tag} tag
  843.  * @param {!Array.<string>} allCodecs
  844.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  845.  * @private
  846.  */
  847. shaka.hls.HlsParser.prototype.createStreamInfoFromMediaTag_ =
  848.     function(tag, allCodecs) {
  849.   goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  850.                       'Should only be called on media tags!');
  852.   const HlsParser = shaka.hls.HlsParser;
  853.   const verbatimMediaPlaylistUri = HlsParser.getRequiredAttributeValue_(
  854.       tag, 'URI');
  856.   // Check if the stream has already been created as part of another Variant
  857.   // and return it if it has.
  858.   if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
  859.     return Promise.resolve(
  860.         this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri));
  861.   }
  863.   let type = HlsParser.getRequiredAttributeValue_(tag, 'TYPE').toLowerCase();
  864.   // Shaka recognizes the content types 'audio', 'video' and 'text'.
  865.   // The HLS 'subtitles' type needs to be mapped to 'text'.
  866.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  867.   if (type == 'subtitles') type = ContentType.TEXT;
  869.   const LanguageUtils = shaka.util.LanguageUtils;
  870.   const language = LanguageUtils.normalize(/** @type {string} */(
  871.       tag.getAttributeValue('LANGUAGE', 'und')));
  872.   const name = tag.getAttributeValue('NAME');
  874.   let defaultAttr = tag.getAttribute('DEFAULT');
  875.   let autoselectAttr = tag.getAttribute('AUTOSELECT');
  876.   // TODO: Should we take into account some of the currently ignored attributes:
  877.   // FORCED, INSTREAM-ID, CHARACTERISTICS, CHANNELS?
  878.   // Attribute descriptions: https://goo.gl/EpU48b
  879.   let channelsAttribute = tag.getAttributeValue('CHANNELS');
  880.   let channelsCount = type == 'audio' ?
  881.       this.getChannelCount_(channelsAttribute) : null;
  882.   let primary = !!defaultAttr || !!autoselectAttr;
  883.   return this.createStreamInfo_(
  884.       verbatimMediaPlaylistUri, allCodecs, type, language, primary,
  885.       name, channelsCount).then(function(streamInfo) {
  886.     // TODO: This check is necessary because of the possibility of multiple
  887.     // calls to createStreamInfoFromMediaTag_ before either has resolved.
  888.     if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
  889.       return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
  890.     }
  892.     this.mediaTagsToStreamInfosMap_.set(tag.id, streamInfo);
  893.     this.uriToStreamInfosMap_.set(verbatimMediaPlaylistUri, streamInfo);
  894.     return streamInfo;
  895.   }.bind(this));
  896. };
  899. /**
  900.  * Get the channel count information for an HLS audio track.
  901.  *
  902.  * @param {?string} channels A string that specifies an ordered, "/" separated
  903.  *   list of parameters.  If the type is audio, the first parameter will be a
  904.  *   decimal integer specifying the number of independent, simultaneous audio
  905.  *   channels.
  906.  *   No other channels parameters are currently defined.
  907.  * @return {?number} channelcount
  908.  * @private
  909.  */
  910. shaka.hls.HlsParser.prototype.getChannelCount_ = function(channels) {
  911.   if (!channels) return null;
  912.   let channelcountstring = channels.split('/')[0];
  913.   let count = parseInt(channelcountstring, 10);
  914.   return count;
  915. };
  918. /**
  919.  * Parse an EXT-X-STREAM-INF media tag into a Stream object.
  920.  *
  921.  * @param {!shaka.hls.Tag} tag
  922.  * @param {!Array.<string>} allCodecs
  923.  * @param {string} type
  924.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  925.  * @private
  926.  */
  927. shaka.hls.HlsParser.prototype.createStreamInfoFromVariantTag_ =
  928.     function(tag, allCodecs, type) {
  929.   goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  930.                       'Should only be called on media tags!');
  932.   const HlsParser = shaka.hls.HlsParser;
  933.   const verbatimMediaPlaylistUri = HlsParser.getRequiredAttributeValue_(
  934.       tag, 'URI');
  936.   if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
  937.     return Promise.resolve(
  938.         this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri));
  939.   }
  941.   return this.createStreamInfo_(verbatimMediaPlaylistUri, allCodecs, type,
  942.                                 /* language */ 'und', /* primary */ false,
  943.                                 /* name */ null, /* channelcount */ null).then(
  944.       function(streamInfo) {
  945.         // TODO: This check is necessary because of the possibility of multiple
  946.         // calls to createStreamInfoFromVariantTag_ before either has resolved.
  947.         if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
  948.           return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
  949.         }
  951.         this.uriToStreamInfosMap_.set(verbatimMediaPlaylistUri, streamInfo);
  952.         return streamInfo;
  953.       }.bind(this));
  954. };
  957. /**
  958.  * @param {string} verbatimMediaPlaylistUri
  959.  * @param {!Array.<string>} allCodecs
  960.  * @param {string} type
  961.  * @param {string} language
  962.  * @param {boolean} primary
  963.  * @param {?string} name
  964.  * @param {?number} channelsCount
  965.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  966.  * @throws shaka.util.Error
  967.  * @private
  968.  */
  969. shaka.hls.HlsParser.prototype.createStreamInfo_ = function(
  970.     verbatimMediaPlaylistUri, allCodecs, type, language, primary, name,
  971.     channelsCount) {
  972.   // TODO: Refactor, too many parameters
  973.   const Utils = shaka.hls.Utils;
  974.   const HlsParser = shaka.hls.HlsParser;
  976.   let absoluteMediaPlaylistUri = Utils.constructAbsoluteUri(
  977.       this.masterPlaylistUri_, verbatimMediaPlaylistUri);
  979.   /** @type {!shaka.hls.Playlist} */
  980.   let playlist;
  981.   /** @type {string} */
  982.   let codecs = '';
  983.   /** @type {string} */
  984.   let mimeType;
  986.   return this.requestManifest_(absoluteMediaPlaylistUri).then((response) => {
  987.     // Record the final URI after redirects.
  988.     absoluteMediaPlaylistUri = response.uri;
  990.     // Record the redirected, final URI of this media playlist when we parse it.
  991.     playlist = this.manifestTextParser_.parsePlaylist(
  992.         response.data, absoluteMediaPlaylistUri);
  994.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  995.       // EXT-X-MEDIA tags should point to media playlists.
  996.       throw new shaka.util.Error(
  997.           shaka.util.Error.Severity.CRITICAL,
  998.           shaka.util.Error.Category.MANIFEST,
  999.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  1000.     }
  1002.     goog.asserts.assert(playlist.segments != null,
  1003.                         'Media playlist should have segments!');
  1005.     this.determinePresentationType_(playlist);
  1007.     codecs = this.guessCodecs_(type, allCodecs);
  1008.     return this.guessMimeType_(type, codecs, playlist);
  1009.   }).then((mimeTypeArg) => {
  1010.     mimeType = mimeTypeArg;
  1012.     let mediaSequenceTag = Utils.getFirstTagWithName(playlist.tags,
  1013.                                                      'EXT-X-MEDIA-SEQUENCE');
  1015.     let startPosition = mediaSequenceTag ? Number(mediaSequenceTag.value) : 0;
  1017.     return this.createSegments_(
  1018.         verbatimMediaPlaylistUri, playlist, startPosition, mimeType, codecs);
  1019.   }).then((segments) => {
  1020.     let minTimestamp = segments[0].startTime;
  1021.     let lastEndTime = segments[segments.length - 1].endTime;
  1022.     let duration = lastEndTime - minTimestamp;
  1023.     let segmentIndex = new shaka.media.SegmentIndex(segments);
  1025.     const initSegmentReference = this.createInitSegmentReference_(playlist);
  1027.     let kind = undefined;
  1028.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  1029.     if (type == ManifestParserUtils.ContentType.TEXT) {
  1030.       kind = ManifestParserUtils.TextStreamKind.SUBTITLE;
  1031.     }
  1032.     // TODO: CLOSED-CAPTIONS requires the parsing of CEA-608 from the video.
  1034.     let drmTags = [];
  1035.     playlist.segments.forEach(function(segment) {
  1036.       let segmentKeyTags = Utils.filterTagsByName(segment.tags,
  1037.                                                   'EXT-X-KEY');
  1038.       drmTags.push.apply(drmTags, segmentKeyTags);
  1039.     });
  1041.     let encrypted = false;
  1042.     let drmInfos = [];
  1043.     let keyId = null;
  1045.     // TODO: May still need changes to support key rotation.
  1046.     drmTags.forEach(function(drmTag) {
  1047.       let method = HlsParser.getRequiredAttributeValue_(drmTag, 'METHOD');
  1048.       if (method != 'NONE') {
  1049.         encrypted = true;
  1051.         let keyFormat =
  1052.             HlsParser.getRequiredAttributeValue_(drmTag, 'KEYFORMAT');
  1053.         let drmParser =
  1054.             shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  1056.         let drmInfo = drmParser ? drmParser(drmTag) : null;
  1057.         if (drmInfo) {
  1058.           if (drmInfo.keyIds.length) {
  1059.             keyId = drmInfo.keyIds[0];
  1060.           }
  1061.           drmInfos.push(drmInfo);
  1062.         } else {
  1063.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  1064.         }
  1065.       }
  1066.     });
  1068.     if (encrypted && !drmInfos.length) {
  1069.       throw new shaka.util.Error(
  1070.           shaka.util.Error.Severity.CRITICAL,
  1071.           shaka.util.Error.Category.MANIFEST,
  1072.           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
  1073.     }
  1075.     let stream = {
  1076.       id: this.globalId_++,
  1077.       createSegmentIndex: Promise.resolve.bind(Promise),
  1078.       findSegmentPosition: segmentIndex.find.bind(segmentIndex),
  1079.       getSegmentReference: segmentIndex.get.bind(segmentIndex),
  1080.       initSegmentReference: initSegmentReference,
  1081.       presentationTimeOffset: 0,
  1082.       mimeType: mimeType,
  1083.       codecs: codecs,
  1084.       kind: kind,
  1085.       encrypted: encrypted,
  1086.       keyId: keyId,
  1087.       language: language,
  1088.       label: name || null,
  1089.       type: type,
  1090.       primary: primary,
  1091.       // TODO: trick mode
  1092.       trickModeVideo: null,
  1093.       containsEmsgBoxes: false,
  1094.       frameRate: undefined,
  1095.       width: undefined,
  1096.       height: undefined,
  1097.       bandwidth: undefined,
  1098.       roles: [],
  1099.       channelsCount: channelsCount
  1100.     };
  1102.     return {
  1103.       stream: stream,
  1104.       segmentIndex: segmentIndex,
  1105.       drmInfos: drmInfos,
  1106.       verbatimMediaPlaylistUri: verbatimMediaPlaylistUri,
  1107.       absoluteMediaPlaylistUri: absoluteMediaPlaylistUri,
  1108.       minTimestamp: minTimestamp,
  1109.       maxTimestamp: lastEndTime,
  1110.       duration: duration
  1111.     };
  1112.   });
  1113. };
  1116. /**
  1117.  * @param {!shaka.hls.Playlist} playlist
  1118.  * @private
  1119.  */
  1120. shaka.hls.HlsParser.prototype.determinePresentationType_ = function(playlist) {
  1121.   const Utils = shaka.hls.Utils;
  1122.   const PresentationType = shaka.hls.HlsParser.PresentationType_;
  1123.   let presentationTypeTag = Utils.getFirstTagWithName(playlist.tags,
  1124.                                                       'EXT-X-PLAYLIST-TYPE');
  1125.   let endListTag = Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  1127.   let isVod = (presentationTypeTag && presentationTypeTag.value == 'VOD') ||
  1128.       endListTag;
  1129.   let isEvent = presentationTypeTag && presentationTypeTag.value == 'EVENT' &&
  1130.       !isVod;
  1131.   let isLive = !isVod && !isEvent;
  1133.   if (isVod) {
  1134.     this.setPresentationType_(PresentationType.VOD);
  1135.   } else {
  1136.     // If it's not VOD, it must be presentation type LIVE or an ongoing EVENT.
  1137.     if (isLive) {
  1138.       this.setPresentationType_(PresentationType.LIVE);
  1139.     } else {
  1140.       this.setPresentationType_(PresentationType.EVENT);
  1141.     }
  1143.     let targetDurationTag = this.getRequiredTag_(playlist.tags,
  1144.                                                  'EXT-X-TARGETDURATION');
  1145.     let targetDuration = Number(targetDurationTag.value);
  1147.     // According to the HLS spec, updates should not happen more often than
  1148.     // once in targetDuration.  It also requires us to only update the active
  1149.     // variant.  We might implement that later, but for now every variant
  1150.     // will be updated.  To get the update period, choose the smallest
  1151.     // targetDuration value across all playlists.
  1153.     // Update the longest target duration if need be to use as a presentation
  1154.     // delay later.
  1155.     this.maxTargetDuration_ = Math.max(targetDuration, this.maxTargetDuration_);
  1156.     // Update the shortest one to use as update period and segment availability
  1157.     // time (for LIVE).
  1158.     this.minTargetDuration_ = Math.min(targetDuration, this.minTargetDuration_);
  1159.   }
  1160. };
  1163. /**
  1164.  * @param {number} lastTimestamp
  1165.  * @throws shaka.util.Error
  1166.  * @private
  1167.  */
  1168. shaka.hls.HlsParser.prototype.createPresentationTimeline_ =
  1169.     function(lastTimestamp) {
  1170.   let presentationStartTime = null;
  1171.   let delay = 0;
  1173.   if (this.isLive_()) {
  1174.     presentationStartTime = (Date.now() / 1000) - lastTimestamp;
  1176.     // We should have a delay of at least 3 target durations.
  1177.     delay = this.maxTargetDuration_ * 3;
  1178.   }
  1180.   this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  1181.       presentationStartTime, delay);
  1182.   this.presentationTimeline_.setStatic(!this.isLive_());
  1183.   this.notifySegments_();
  1184. };
  1187. /**
  1188.  * @param {!shaka.hls.Playlist} playlist
  1189.  * @return {shaka.media.InitSegmentReference}
  1190.  * @private
  1191.  * @throws {shaka.util.Error}
  1192.  */
  1193. shaka.hls.HlsParser.prototype.createInitSegmentReference_ = function(playlist) {
  1194.   const Utils = shaka.hls.Utils;
  1195.   let mapTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MAP');
  1196.   // TODO: Support multiple map tags?
  1197.   // For now, we don't support multiple map tags and will throw an error.
  1198.   if (!mapTags.length) {
  1199.     return null;
  1200.   } else if (mapTags.length > 1) {
  1201.     throw new shaka.util.Error(
  1202.         shaka.util.Error.Severity.CRITICAL,
  1203.         shaka.util.Error.Category.MANIFEST,
  1204.         shaka.util.Error.Code.HLS_MULTIPLE_MEDIA_INIT_SECTIONS_FOUND);
  1205.   }
  1207.   // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
  1208.   let mapTag = mapTags[0];
  1209.   const verbatimInitSegmentUri =
  1210.       shaka.hls.HlsParser.getRequiredAttributeValue_(mapTag, 'URI');
  1211.   const absoluteInitSegmentUri =
  1212.       Utils.constructAbsoluteUri(playlist.absoluteUri, verbatimInitSegmentUri);
  1214.   let startByte = 0;
  1215.   let endByte = null;
  1216.   let byterange = mapTag.getAttributeValue('BYTERANGE');
  1217.   // If a BYTERANGE attribute is not specified, the segment consists
  1218.   // of the entire resource.
  1219.   if (byterange) {
  1220.     let blocks = byterange.split('@');
  1221.     let byteLength = Number(blocks[0]);
  1222.     startByte = Number(blocks[1]);
  1223.     endByte = startByte + byteLength - 1;
  1224.   }
  1226.   return new shaka.media.InitSegmentReference(
  1227.       () => [absoluteInitSegmentUri],
  1228.       startByte,
  1229.       endByte);
  1230. };
  1233. /**
  1234.  * Parses one shaka.hls.Segment object into a shaka.media.SegmentReference.
  1235.  *
  1236.  * @param {!shaka.hls.Playlist} playlist
  1237.  * @param {shaka.media.SegmentReference} previousReference
  1238.  * @param {!shaka.hls.Segment} hlsSegment
  1239.  * @param {number} position
  1240.  * @param {number} startTime
  1241.  * @return {!shaka.media.SegmentReference}
  1242.  * @private
  1243.  */
  1244. shaka.hls.HlsParser.prototype.createSegmentReference_ =
  1245.     function(playlist, previousReference, hlsSegment, position, startTime) {
  1246.   const Utils = shaka.hls.Utils;
  1247.   const tags = hlsSegment.tags;
  1248.   const absoluteSegmentUri = hlsSegment.absoluteUri;
  1250.   let extinfTag = this.getRequiredTag_(tags, 'EXTINF');
  1251.   // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  1252.   // We're interested in the duration part.
  1253.   let extinfValues = extinfTag.value.split(',');
  1254.   let duration = Number(extinfValues[0]);
  1255.   let endTime = startTime + duration;
  1257.   let startByte = 0;
  1258.   let endByte = null;
  1259.   let byterange = Utils.getFirstTagWithName(tags, 'EXT-X-BYTERANGE');
  1261.   // If BYTERANGE is not specified, the segment consists of the entire resource.
  1262.   if (byterange) {
  1263.     let blocks = byterange.value.split('@');
  1264.     let byteLength = Number(blocks[0]);
  1265.     if (blocks[1]) {
  1266.       startByte = Number(blocks[1]);
  1267.     } else {
  1268.       goog.asserts.assert(previousReference,
  1269.                           'Cannot refer back to previous HLS segment!');
  1270.       startByte = previousReference.endByte + 1;
  1271.     }
  1272.     endByte = startByte + byteLength - 1;
  1273.   }
  1275.   return new shaka.media.SegmentReference(
  1276.       position,
  1277.       startTime,
  1278.       endTime,
  1279.       () => [absoluteSegmentUri],
  1280.       startByte,
  1281.       endByte);
  1282. };
  1285. /** @private */
  1286. shaka.hls.HlsParser.prototype.notifySegments_ = function() {
  1287.   // The presentation timeline may or may not be set yet.
  1288.   // If it does not yet exist, hold onto the segments until it does.
  1289.   if (!this.presentationTimeline_) {
  1290.     return;
  1291.   }
  1292.   this.segmentsToNotifyByStream_.forEach((segments) => {
  1293.     // HLS doesn't have separate periods, so it's always "the first period".
  1294.     this.presentationTimeline_.notifySegments(segments, true);
  1295.   });
  1296.   this.segmentsToNotifyByStream_ = [];
  1297. };
  1300. /**
  1301.  * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences.
  1302.  *
  1303.  * @param {string} verbatimMediaPlaylistUri
  1304.  * @param {!shaka.hls.Playlist} playlist
  1305.  * @param {number} startPosition
  1306.  * @param {string} mimeType
  1307.  * @param {string} codecs
  1308.  * @return {!Promise<!Array.<!shaka.media.SegmentReference>>}
  1309.  * @private
  1310.  */
  1311. shaka.hls.HlsParser.prototype.createSegments_ = function(
  1312.     verbatimMediaPlaylistUri, playlist, startPosition, mimeType, codecs) {
  1313.   const hlsSegments = playlist.segments;
  1314.   const references = [];
  1316.   goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
  1317.   // We may need to look at the media itself to determine a segment start time.
  1318.   const firstSegmentUri = hlsSegments[0].absoluteUri;
  1319.   const firstSegmentRef =
  1320.       this.createSegmentReference_(
  1321.           playlist,
  1322.           null /* previousReference */,
  1323.           hlsSegments[0],
  1324.           startPosition,
  1325.           0 /* startTime, irrelevant */);
  1327.   const initSegmentRef = this.createInitSegmentReference_(playlist);
  1329.   return this.getStartTime_(verbatimMediaPlaylistUri, initSegmentRef,
  1330.                             firstSegmentRef, mimeType, codecs)
  1331.       .then(function(firstStartTime) {
  1332.         shaka.log.debug('First segment', firstSegmentUri.split('/').pop(),
  1333.                         'starts at', firstStartTime);
  1334.         for (let i = 0; i < hlsSegments.length; ++i) {
  1335.           let hlsSegment = hlsSegments[i];
  1336.           let previousReference = references[references.length - 1];
  1337.           let startTime = (i == 0) ? firstStartTime : previousReference.endTime;
  1338.           let position = startPosition + i;
  1340.           let reference = this.createSegmentReference_(
  1341.               playlist,
  1342.               previousReference,
  1343.               hlsSegment,
  1344.               position,
  1345.               startTime);
  1346.           references.push(reference);
  1347.         }
  1349.         this.segmentsToNotifyByStream_.push(references);
  1350.         this.notifySegments_();
  1352.         return references;
  1353.       }.bind(this));
  1354. };
  1357. /**
  1358.  * Try to fetch a partial segment, and fall back to a full segment if we have
  1359.  * to.
  1360.  *
  1361.  * @param {!shaka.media.AnySegmentReference} segmentRef
  1362.  * @return {!Promise.<shakaExtern.Response>}
  1363.  * @throws {shaka.util.Error}
  1364.  * @private
  1365.  */
  1366. shaka.hls.HlsParser.prototype.fetchPartialSegment_ = function(segmentRef) {
  1367.   let networkingEngine = this.playerInterface_.networkingEngine;
  1368.   const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1369.   let request = shaka.net.NetworkingEngine.makeRequest(
  1370.       segmentRef.getUris(), this.config_.retryParameters);
  1372.   // Try to avoid fetching the entire segment, which can be quite large.
  1373.   let partialSegmentHeaders = {};
  1374.   let startByte = segmentRef.startByte;
  1375.   let partialEndByte =
  1376.       startByte + shaka.hls.HlsParser.PARTIAL_SEGMENT_SIZE_ - 1;
  1377.   partialSegmentHeaders['Range'] = 'bytes=' + startByte + '-' + partialEndByte;
  1379.   // Prepare a fallback to the entire segment.
  1380.   let fullSegmentHeaders = {};
  1381.   if ((startByte != 0) || (segmentRef.endByte != null)) {
  1382.     let range = 'bytes=' + startByte + '-';
  1383.     if (segmentRef.endByte != null) range += segmentRef.endByte;
  1385.     fullSegmentHeaders['Range'] = range;
  1386.   }
  1388.   // Try a partial request first.
  1389.   request.headers = partialSegmentHeaders;
  1390.   let operation = networkingEngine.request(requestType, request);
  1391.   this.operationManager_.manage(operation);
  1392.   return operation.promise.catch((error) => {
  1393.     // The partial request may fail for a number of reasons.
  1394.     // Some servers do not support Range requests, and others do not support
  1395.     // the OPTIONS request which must be made before any cross-origin Range
  1396.     // request.  Since this fallback is expensive, warn the app developer.
  1397.     shaka.log.alwaysWarn('Unable to fetch a partial HLS segment! ' +
  1398.                          'Falling back to a full segment request, ' +
  1399.                          'which is expensive!  Your server should ' +
  1400.                          'support Range requests and CORS preflights.',
  1401.                          request.uris[0]);
  1402.     request.headers = fullSegmentHeaders;
  1403.     let operation = networkingEngine.request(requestType, request);
  1404.     this.operationManager_.manage(operation);
  1405.     return operation.promise;
  1406.   });
  1407. };
  1410. /**
  1411.  * Gets the start time of a segment from the existing manifest (if possible) or
  1412.  * by downloading it and parsing it otherwise.
  1413.  *
  1414.  * @param {string} verbatimMediaPlaylistUri
  1415.  * @param {shaka.media.InitSegmentReference} initSegmentRef
  1416.  * @param {!shaka.media.SegmentReference} segmentRef
  1417.  * @param {string} mimeType
  1418.  * @param {string} codecs
  1419.  * @return {!Promise.<number>}
  1420.  * @throws {shaka.util.Error}
  1421.  * @private
  1422.  */
  1423. shaka.hls.HlsParser.prototype.getStartTime_ = function(
  1424.     verbatimMediaPlaylistUri, initSegmentRef, segmentRef, mimeType, codecs) {
  1425.   // If we are updating the manifest, we can usually skip fetching the segment
  1426.   // by examining the references we already have.  This won't be possible if
  1427.   // there was some kind of lag or delay updating the manifest on the server,
  1428.   // in which extreme case we would fall back to fetching a segment.  This
  1429.   // allows us to both avoid fetching segments when possible, and recover from
  1430.   // certain server-side issues gracefully.
  1431.   if (this.manifest_) {
  1432.     const streamInfo = this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
  1433.     const segmentIndex = streamInfo.segmentIndex;
  1434.     const reference = segmentIndex.get(segmentRef.position);
  1435.     if (reference) {
  1436.       // We found it!  Avoid fetching and parsing the segment.
  1437.       shaka.log.v1('Found segment start time in previous manifest');
  1438.       return Promise.resolve(reference.startTime);
  1439.     }
  1441.     shaka.log.debug('Unable to find segment start time in previous manifest!');
  1442.   }
  1444.   // TODO: Introduce a new tag to extend HLS and provide the first segment's
  1445.   // start time.  This will avoid the need for these fetches in content packaged
  1446.   // with Shaka Packager.  This web-friendly extension to HLS can then be
  1447.   // proposed to Apple for inclusion in a future version of HLS.
  1448.   // See https://github.com/google/shaka-packager/issues/294
  1450.   shaka.log.v1('Fetching segment to find start time');
  1451.   let fetches = [this.fetchPartialSegment_(segmentRef)];
  1453.   if (mimeType == 'video/mp4' || mimeType == 'audio/mp4') {
  1454.     // We also need the init segment to get the correct timescale.
  1455.     if (initSegmentRef) {
  1456.       fetches.push(this.fetchPartialSegment_(initSegmentRef));
  1457.     } else {
  1458.       // If the stream is self-initializing, use the same response for both.
  1459.       fetches.push(fetches[0]);
  1460.     }
  1461.   }
  1463.   return Promise.all(fetches).then(function(responses) {
  1464.     if (mimeType == 'video/mp4' || mimeType == 'audio/mp4') {
  1465.       return this.getStartTimeFromMp4Segment_(
  1466.           responses[0].data, responses[1].data);
  1467.     } else if (mimeType == 'audio/mpeg') {
  1468.       // There is no standard way to embed a timestamp in an mp3 file, so the
  1469.       // start time is presumably 0.
  1470.       return 0;
  1471.     } else if (mimeType == 'video/mp2t') {
  1472.       return this.getStartTimeFromTsSegment_(responses[0].data);
  1473.     } else if (mimeType == 'application/mp4' ||
  1474.                mimeType.indexOf('text/') == 0) {
  1475.       return this.getStartTimeFromTextSegment_(
  1476.           mimeType, codecs, responses[0].data);
  1477.     } else {
  1478.       // TODO: Parse WebM?
  1479.       // TODO: Parse raw AAC?
  1480.       throw new shaka.util.Error(
  1481.           shaka.util.Error.Severity.CRITICAL,
  1482.           shaka.util.Error.Category.MANIFEST,
  1483.           shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1484.     }
  1485.   }.bind(this));
  1486. };
  1489. /**
  1490.  * Parses an mp4 segment to get its start time.
  1491.  *
  1492.  * @param {!ArrayBuffer} mediaData
  1493.  * @param {!ArrayBuffer} initData
  1494.  * @return {number}
  1495.  * @throws {shaka.util.Error}
  1496.  * @private
  1497.  */
  1498. shaka.hls.HlsParser.prototype.getStartTimeFromMp4Segment_ =
  1499.     function(mediaData, initData) {
  1500.   const Mp4Parser = shaka.util.Mp4Parser;
  1502.   let timescale = 0;
  1503.   new Mp4Parser()
  1504.       .box('moov', Mp4Parser.children)
  1505.       .box('trak', Mp4Parser.children)
  1506.       .box('mdia', Mp4Parser.children)
  1507.       .fullBox('mdhd', function(box) {
  1508.         goog.asserts.assert(
  1509.             box.version == 0 || box.version == 1,
  1510.             'MDHD version can only be 0 or 1');
  1512.         // Skip "creation_time" and "modification_time".
  1513.         // They are 4 bytes each if the mdhd box is version 0, 8 bytes each if
  1514.         // it is version 1.
  1515.         box.reader.skip(box.version == 0 ? 8 : 16);
  1517.         timescale = box.reader.readUint32();
  1518.         box.parser.stop();
  1519.       }).parse(initData, true /* partialOkay */);
  1521.   if (!timescale) {
  1522.     shaka.log.error('Unable to find timescale in init segment!');
  1523.     throw new shaka.util.Error(
  1524.         shaka.util.Error.Severity.CRITICAL,
  1525.         shaka.util.Error.Category.MANIFEST,
  1526.         shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1527.   }
  1529.   let startTime = 0;
  1530.   let parsedMedia = false;
  1531.   new Mp4Parser()
  1532.       .box('moof', Mp4Parser.children)
  1533.       .box('traf', Mp4Parser.children)
  1534.       .fullBox('tfdt', function(box) {
  1535.         goog.asserts.assert(
  1536.             box.version == 0 || box.version == 1,
  1537.             'TFDT version can only be 0 or 1');
  1538.         let baseTime = (box.version == 0) ?
  1539.             box.reader.readUint32() :
  1540.             box.reader.readUint64();
  1541.         startTime = baseTime / timescale;
  1542.         parsedMedia = true;
  1543.         box.parser.stop();
  1544.       }).parse(mediaData, true /* partialOkay */);
  1546.   if (!parsedMedia) {
  1547.     throw new shaka.util.Error(
  1548.         shaka.util.Error.Severity.CRITICAL,
  1549.         shaka.util.Error.Category.MANIFEST,
  1550.         shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1551.   }
  1552.   return startTime;
  1553. };
  1556. /**
  1557.  * Parses a TS segment to get its start time.
  1558.  *
  1559.  * @param {!ArrayBuffer} data
  1560.  * @return {number}
  1561.  * @throws {shaka.util.Error}
  1562.  * @private
  1563.  */
  1564. shaka.hls.HlsParser.prototype.getStartTimeFromTsSegment_ = function(data) {
  1565.   let reader = new shaka.util.DataViewReader(
  1566.       new DataView(data), shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  1568.   const fail = function() {
  1569.     throw new shaka.util.Error(
  1570.         shaka.util.Error.Severity.CRITICAL,
  1571.         shaka.util.Error.Category.MANIFEST,
  1572.         shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1573.   };
  1575.   let packetStart = 0;
  1576.   let syncByte = 0;
  1578.   const skipPacket = function() {
  1579.     // 188-byte packets are standard, so assume that.
  1580.     reader.seek(packetStart + 188);
  1581.     syncByte = reader.readUint8();
  1582.     if (syncByte != 0x47) {
  1583.       // We haven't found the sync byte, so try it as a 192-byte packet.
  1584.       reader.seek(packetStart + 192);
  1585.       syncByte = reader.readUint8();
  1586.     }
  1587.     if (syncByte != 0x47) {
  1588.       // We still haven't found the sync byte, so try as a 204-byte packet.
  1589.       reader.seek(packetStart + 204);
  1590.       syncByte = reader.readUint8();
  1591.     }
  1592.     if (syncByte != 0x47) {
  1593.       // We still haven't found the sync byte, so the packet was of a
  1594.       // non-standard size.
  1595.       fail();
  1596.     }
  1597.     // Put the sync byte back so we can read it in the next loop.
  1598.     reader.rewind(1);
  1599.   };
  1601.   // eslint-disable-next-line no-constant-condition
  1602.   while (true) {
  1603.     // Format reference: https://goo.gl/wk6wwu
  1604.     packetStart = reader.getPosition();
  1606.     syncByte = reader.readUint8();
  1607.     if (syncByte != 0x47) fail();
  1609.     let flagsAndPacketId = reader.readUint16();
  1610.     let hasPesPacket = flagsAndPacketId & 0x4000;
  1611.     if (!hasPesPacket) fail();
  1613.     let flags = reader.readUint8();
  1614.     let adaptationFieldControl = (flags & 0x30) >> 4;
  1615.     if (adaptationFieldControl == 0 /* reserved */ ||
  1616.         adaptationFieldControl == 2 /* adaptation field, no payload */) {
  1617.       fail();
  1618.     }
  1620.     if (adaptationFieldControl == 3) {
  1621.       // Skip over adaptation field.
  1622.       let length = reader.readUint8();
  1623.       reader.skip(length);
  1624.     }
  1626.     // Now we come to the PES header (hopefully).
  1627.     // Format reference: https://goo.gl/1166Mr
  1628.     let startCode = reader.readUint32();
  1629.     let startCodePrefix = startCode >> 8;
  1630.     if (startCodePrefix != 1) {
  1631.       // Not a PES packet yet.  Skip this TS packet and try again.
  1632.       skipPacket();
  1633.       continue;
  1634.     }
  1636.     // Skip the 16-bit PES length and the first 8 bits of the optional header.
  1637.     reader.skip(3);
  1638.     // The next 8 bits contain flags about DTS & PTS.
  1639.     let ptsDtsIndicator = reader.readUint8() >> 6;
  1640.     if (ptsDtsIndicator == 0 /* no timestamp */ ||
  1641.         ptsDtsIndicator == 1 /* forbidden */) {
  1642.       fail();
  1643.     }
  1645.     let pesHeaderLengthRemaining = reader.readUint8();
  1646.     if (pesHeaderLengthRemaining == 0) {
  1647.       fail();
  1648.     }
  1650.     if (ptsDtsIndicator == 2 /* PTS only */) {
  1651.       goog.asserts.assert(pesHeaderLengthRemaining == 5, 'Bad PES header?');
  1652.     } else if (ptsDtsIndicator == 3 /* PTS and DTS */) {
  1653.       goog.asserts.assert(pesHeaderLengthRemaining == 10, 'Bad PES header?');
  1654.     }
  1656.     let pts0 = reader.readUint8();
  1657.     let pts1 = reader.readUint16();
  1658.     let pts2 = reader.readUint16();
  1659.     // Reconstruct 33-bit PTS from the 5-byte, padded structure.
  1660.     let ptsHigh3 = (pts0 & 0x0e) >> 1;
  1661.     let ptsLow30 = ((pts1 & 0xfffe) << 14) | ((pts2 & 0xfffe) >> 1);
  1662.     // Reconstruct the PTS as a float.  Avoid bitwise operations to combine
  1663.     // because bitwise ops treat the values as 32-bit ints.
  1664.     let pts = ptsHigh3 * (1 << 30) + ptsLow30;
  1665.     return pts / shaka.hls.HlsParser.TS_TIMESCALE_;
  1666.   }
  1667. };
  1670. /**
  1671.  * Parses a text segment to get its start time.
  1672.  *
  1673.  * @param {string} mimeType
  1674.  * @param {string} codecs
  1675.  * @param {!ArrayBuffer} data
  1676.  * @return {number}
  1677.  * @throws {shaka.util.Error}
  1678.  * @private
  1679.  */
  1680. shaka.hls.HlsParser.prototype.getStartTimeFromTextSegment_ =
  1681.     function(mimeType, codecs, data) {
  1682.   let fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
  1683.   if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  1684.     // We won't be able to parse this, but it will be filtered out anyway.
  1685.     // So we don't have to care about the start time.
  1686.     return 0;
  1687.   }
  1689.   let textEngine = new shaka.text.TextEngine(/* displayer */ null);
  1690.   textEngine.initParser(fullMimeType);
  1691.   return textEngine.getStartTime(data);
  1692. };
  1695. /**
  1696.  * Attempts to guess which codecs from the codecs list belong to a given content
  1697.  * type.  Does not assume a single codec is anything special, and does not throw
  1698.  * if it fails to match.
  1699.  *
  1700.  * @param {string} contentType
  1701.  * @param {!Array.<string>} codecs
  1702.  * @return {?string} or null if no match is found
  1703.  * @private
  1704.  */
  1705. shaka.hls.HlsParser.prototype.guessCodecsSafe_ = function(contentType, codecs) {
  1706.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1707.   const HlsParser = shaka.hls.HlsParser;
  1708.   let formats = HlsParser.CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  1710.   for (let i = 0; i < formats.length; i++) {
  1711.     for (let j = 0; j < codecs.length; j++) {
  1712.       if (formats[i].test(codecs[j].trim())) {
  1713.         return codecs[j].trim();
  1714.       }
  1715.     }
  1716.   }
  1718.   // Text does not require a codec string.
  1719.   if (contentType == ContentType.TEXT) {
  1720.     return '';
  1721.   }
  1723.   return null;
  1724. };
  1727. /**
  1728.  * Attempts to guess which codecs from the codecs list belong to a given content
  1729.  * type.  Assumes that at least one codec is correct, and throws if none are.
  1730.  *
  1731.  * @param {string} contentType
  1732.  * @param {!Array.<string>} codecs
  1733.  * @return {string}
  1734.  * @private
  1735.  * @throws {shaka.util.Error}
  1736.  */
  1737. shaka.hls.HlsParser.prototype.guessCodecs_ = function(contentType, codecs) {
  1738.   if (codecs.length == 1) {
  1739.     return codecs[0];
  1740.   }
  1742.   let match = this.guessCodecsSafe_(contentType, codecs);
  1743.   // A failure is specifically denoted by null; an empty string represents a
  1744.   // valid match of no codec.
  1745.   if (match != null) {
  1746.     return match;
  1747.   }
  1749.   // Unable to guess codecs.
  1750.   throw new shaka.util.Error(
  1751.       shaka.util.Error.Severity.CRITICAL,
  1752.       shaka.util.Error.Category.MANIFEST,
  1753.       shaka.util.Error.Code.HLS_COULD_NOT_GUESS_CODECS,
  1754.       codecs);
  1755. };
  1758. /**
  1759.  * Attempts to guess stream's mime type based on content type and URI.
  1760.  *
  1761.  * @param {string} contentType
  1762.  * @param {string} codecs
  1763.  * @param {!shaka.hls.Playlist} playlist
  1764.  * @return {!Promise.<string>}
  1765.  * @private
  1766.  * @throws {shaka.util.Error}
  1767.  */
  1768. shaka.hls.HlsParser.prototype.guessMimeType_ =
  1769.     function(contentType, codecs, playlist) {
  1770.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1771.   const HlsParser = shaka.hls.HlsParser;
  1773.   goog.asserts.assert(playlist.segments.length,
  1774.                       'Playlist should have segments!');
  1775.   const firstSegmentUri = playlist.segments[0].absoluteUri;
  1777.   let parsedUri = new goog.Uri(firstSegmentUri);
  1778.   let extension = parsedUri.getPath().split('.').pop();
  1779.   let map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
  1781.   let mimeType = map[extension];
  1782.   if (mimeType) {
  1783.     return Promise.resolve(mimeType);
  1784.   }
  1786.   if (contentType == ContentType.TEXT) {
  1787.     // The extension map didn't work.
  1788.     if (!codecs || codecs == 'vtt') {
  1789.       // If codecs is 'vtt', it's WebVTT.
  1790.       // If there was no codecs string, assume HLS text streams are WebVTT.
  1791.       return Promise.resolve('text/vtt');
  1792.     } else {
  1793.       // Otherwise, assume MP4-embedded text, since text-based formats tend not
  1794.       // to have a codecs string at all.
  1795.       return Promise.resolve('application/mp4');
  1796.     }
  1797.   }
  1799.   // If unable to guess mime type, request a segment and try getting it
  1800.   // from the response.
  1801.   let headRequest = shaka.net.NetworkingEngine.makeRequest(
  1802.       [firstSegmentUri], this.config_.retryParameters);
  1803.   headRequest.method = 'HEAD';
  1804.   const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1805.   let networkingEngine = this.playerInterface_.networkingEngine;
  1806.   let operation = networkingEngine.request(requestType, headRequest);
  1807.   this.operationManager_.manage(operation);
  1809.   return operation.promise.then((response) => {
  1810.     let mimeType = response.headers['content-type'];
  1811.     if (!mimeType) {
  1812.       throw new shaka.util.Error(
  1813.           shaka.util.Error.Severity.CRITICAL,
  1814.           shaka.util.Error.Category.MANIFEST,
  1815.           shaka.util.Error.Code.HLS_COULD_NOT_GUESS_MIME_TYPE,
  1816.           extension);
  1817.     }
  1819.     // Split the MIME type in case the server sent additional parameters.
  1820.     return mimeType.split(';')[0];
  1821.   });
  1822. };
  1825. /**
  1826.  * Find the attribute and returns its value.
  1827.  * Throws an error if attribute was not found.
  1828.  *
  1829.  * @param {shaka.hls.Tag} tag
  1830.  * @param {string} attributeName
  1831.  * @return {string}
  1832.  * @private
  1833.  * @throws {shaka.util.Error}
  1834.  */
  1835. shaka.hls.HlsParser.getRequiredAttributeValue_ = function(tag, attributeName) {
  1836.   let attribute = tag.getAttribute(attributeName);
  1837.   if (!attribute) {
  1838.     throw new shaka.util.Error(
  1839.         shaka.util.Error.Severity.CRITICAL,
  1840.         shaka.util.Error.Category.MANIFEST,
  1841.         shaka.util.Error.Code.HLS_REQUIRED_ATTRIBUTE_MISSING,
  1842.         attributeName);
  1843.   }
  1845.   return attribute.value;
  1846. };
  1849. /**
  1850.  * Returns a tag with a given name.
  1851.  * Throws an error if tag was not found.
  1852.  *
  1853.  * @param {!Array.<shaka.hls.Tag>} tags
  1854.  * @param {string} tagName
  1855.  * @return {!shaka.hls.Tag}
  1856.  * @private
  1857.  * @throws {shaka.util.Error}
  1858.  */
  1859. shaka.hls.HlsParser.prototype.getRequiredTag_ = function(tags, tagName) {
  1860.   const Utils = shaka.hls.Utils;
  1861.   let tag = Utils.getFirstTagWithName(tags, tagName);
  1862.   if (!tag) {
  1863.     throw new shaka.util.Error(
  1864.         shaka.util.Error.Severity.CRITICAL,
  1865.         shaka.util.Error.Category.MANIFEST,
  1866.         shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, tagName);
  1867.   }
  1869.   return tag;
  1870. };
  1873. /**
  1874.  * @param {shakaExtern.Stream} stream
  1875.  * @param {?string} width
  1876.  * @param {?string} height
  1877.  * @param {?string} frameRate
  1878.  * @private
  1879.  */
  1880. shaka.hls.HlsParser.prototype.addVideoAttributes_ =
  1881.     function(stream, width, height, frameRate) {
  1882.   if (stream) {
  1883.     stream.width = Number(width) || undefined;
  1884.     stream.height = Number(height) || undefined;
  1885.     stream.frameRate = Number(frameRate) || undefined;
  1886.   }
  1887. };
  1890. /**
  1891.  * Makes a network request for the manifest and returns a Promise
  1892.  * with the resulting data.
  1893.  *
  1894.  * @param {string} absoluteUri
  1895.  * @return {!Promise.<!shakaExtern.Response>}
  1896.  * @private
  1897.  */
  1898. shaka.hls.HlsParser.prototype.requestManifest_ = function(absoluteUri) {
  1899.   const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  1900.   let request = shaka.net.NetworkingEngine.makeRequest(
  1901.       [absoluteUri], this.config_.retryParameters);
  1902.   let networkingEngine = this.playerInterface_.networkingEngine;
  1903.   let operation = networkingEngine.request(requestType, request);
  1904.   this.operationManager_.manage(operation);
  1905.   return operation.promise;
  1906. };
  1909. /**
  1910.  * A list of regexps to detect well-known video codecs.
  1911.  *
  1912.  * @const {!Array.<!RegExp>}
  1913.  * @private
  1914.  */
  1915. shaka.hls.HlsParser.VIDEO_CODEC_REGEXPS_ = [
  1916.   /^avc/,
  1917.   /^hev/,
  1918.   /^hvc/,
  1919.   /^vp0?[89]/,
  1920.   /^av1$/
  1921. ];
  1924. /**
  1925.  * A list of regexps to detect well-known audio codecs.
  1926.  *
  1927.  * @const {!Array.<!RegExp>}
  1928.  * @private
  1929.  */
  1930. shaka.hls.HlsParser.AUDIO_CODEC_REGEXPS_ = [
  1931.   /^vorbis$/,
  1932.   /^opus$/,
  1933.   /^flac$/,
  1934.   /^mp4a/,
  1935.   /^[ae]c-3$/
  1936. ];
  1939. /**
  1940.  * A list of regexps to detect well-known text codecs.
  1941.  *
  1942.  * @const {!Array.<!RegExp>}
  1943.  * @private
  1944.  */
  1945. shaka.hls.HlsParser.TEXT_CODEC_REGEXPS_ = [
  1946.   /^vtt$/,
  1947.   /^wvtt/,
  1948.   /^stpp/
  1949. ];
  1952. /**
  1953.  * @const {!Object.<string, !Array.<!RegExp>>}
  1954.  * @private
  1955.  */
  1956. shaka.hls.HlsParser.CODEC_REGEXPS_BY_CONTENT_TYPE_ = {
  1957.   'audio': shaka.hls.HlsParser.AUDIO_CODEC_REGEXPS_,
  1958.   'video': shaka.hls.HlsParser.VIDEO_CODEC_REGEXPS_,
  1959.   'text': shaka.hls.HlsParser.TEXT_CODEC_REGEXPS_
  1960. };
  1963. /**
  1964.  * @const {!Object.<string, string>}
  1965.  * @private
  1966.  */
  1967. shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
  1968.   'mp4': 'audio/mp4',
  1969.   'm4s': 'audio/mp4',
  1970.   'm4i': 'audio/mp4',
  1971.   'm4a': 'audio/mp4',
  1972.   // MPEG2-TS also uses video/ for audio: http://goo.gl/tYHXiS
  1973.   'ts': 'video/mp2t'
  1974. };
  1977. /**
  1978.  * @const {!Object.<string, string>}
  1979.  * @private
  1980.  */
  1981. shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = {
  1982.   'mp4': 'video/mp4',
  1983.   'm4s': 'video/mp4',
  1984.   'm4i': 'video/mp4',
  1985.   'm4v': 'video/mp4',
  1986.   'ts': 'video/mp2t'
  1987. };
  1990. /**
  1991.  * @const {!Object.<string, string>}
  1992.  * @private
  1993.  */
  1994. shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_ = {
  1995.   'mp4': 'application/mp4',
  1996.   'm4s': 'application/mp4',
  1997.   'm4i': 'application/mp4',
  1998.   'vtt': 'text/vtt',
  1999.   'ttml': 'application/ttml+xml'
  2000. };
  2003. /**
  2004.  * @const {!Object.<string, !Object.<string, string>>}
  2005.  * @private
  2006.  */
  2007. shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_ = {
  2008.   'audio': shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_,
  2009.   'video': shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_,
  2010.   'text': shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_
  2011. };
  2014. /**
  2015.  * @typedef {function(!shaka.hls.Tag):?shakaExtern.DrmInfo}
  2016.  * @private
  2017.  */
  2018. shaka.hls.HlsParser.DrmParser_;
  2021. /**
  2022.  * @param {!shaka.hls.Tag} drmTag
  2023.  * @return {?shakaExtern.DrmInfo}
  2024.  * @private
  2025.  */
  2026. shaka.hls.HlsParser.widevineDrmParser_ = function(drmTag) {
  2027.   const HlsParser = shaka.hls.HlsParser;
  2028.   let method = HlsParser.getRequiredAttributeValue_(drmTag, 'METHOD');
  2029.   // TODO: https://github.com/google/shaka-player/issues/1227
  2030.   // Keep 'SAMPLE-AES-CENC' for backward compatibility.  Deprecate it in a
  2031.   // future release.
  2032.   if (method != 'SAMPLE-AES-CENC' && method != 'SAMPLE-AES-CTR') {
  2033.     shaka.log.error(
  2034.         'Widevine in HLS is only supported with SAMPLE-AES-CTR and ' +
  2035.         'SAMPLE-AES-CENC (deprecated), not', method);
  2036.     return null;
  2037.   }
  2039.   let uri = HlsParser.getRequiredAttributeValue_(drmTag, 'URI');
  2040.   let parsedData = shaka.net.DataUriPlugin.parse(uri);
  2042.   // The data encoded in the URI is a PSSH box to be used as init data.
  2043.   let pssh = new Uint8Array(parsedData.data);
  2044.   let drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  2045.       'com.widevine.alpha', [
  2046.         {initDataType: 'cenc', initData: pssh}
  2047.       ]);
  2049.   let keyId = drmTag.getAttributeValue('KEYID');
  2050.   if (keyId) {
  2051.     // This value should begin with '0x':
  2052.     goog.asserts.assert(keyId.substr(0, 2) == '0x', 'Incorrect KEYID format!');
  2053.     // But the output should not contain the '0x':
  2054.     drmInfo.keyIds = [keyId.substr(2).toLowerCase()];
  2055.   }
  2056.   return drmInfo;
  2057. };
  2060. /**
  2061.  * Called when the update timer ticks.
  2062.  *
  2063.  * @private
  2064.  */
  2065. shaka.hls.HlsParser.prototype.onUpdate_ = function() {
  2066.   goog.asserts.assert(this.updateTimer_, 'Should only be called by timer');
  2067.   goog.asserts.assert(this.updatePeriod_ != null,
  2068.                       'There should be an update period');
  2070.   shaka.log.info('Updating manifest...');
  2072.   // Detect a call to stop()
  2073.   if (!this.playerInterface_) {
  2074.     return;
  2075.   }
  2077.   this.updateTimer_ = null;
  2078.   this.update().then(function() {
  2079.     this.setUpdateTimer_(this.updatePeriod_);
  2080.   }.bind(this)).catch(function(error) {
  2081.     goog.asserts.assert(error instanceof shaka.util.Error,
  2082.                         'Should only receive a Shaka error');
  2084.     // Try updating again, but ensure we haven't been destroyed.
  2085.     if (this.playerInterface_) {
  2086.       // We will retry updating, so override the severity of the error.
  2087.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  2088.       this.playerInterface_.onError(error);
  2090.       this.setUpdateTimer_(0);
  2091.     }
  2092.   }.bind(this));
  2093. };
  2096. /**
  2097.  * Sets the update timer.
  2098.  *
  2099.  * @param {?number} time in seconds
  2100.  * @private
  2101.  */
  2102. shaka.hls.HlsParser.prototype.setUpdateTimer_ = function(time) {
  2103.   if (this.updatePeriod_ == null || time == null) {
  2104.     return;
  2105.   }
  2106.   goog.asserts.assert(this.updateTimer_ == null,
  2107.                       'Timer should not be already set');
  2109.   let callback = this.onUpdate_.bind(this);
  2110.   this.updateTimer_ = window.setTimeout(callback, time * 1000);
  2111. };
  2114. /**
  2115.  * @return {boolean}
  2116.  * @private
  2117.  */
  2118. shaka.hls.HlsParser.prototype.isLive_ = function() {
  2119.   const PresentationType = shaka.hls.HlsParser.PresentationType_;
  2120.   return this.presentationType_ != PresentationType.VOD;
  2121. };
  2124. /**
  2125.  * @param {shaka.hls.HlsParser.PresentationType_} type
  2126.  * @private
  2127.  */
  2128. shaka.hls.HlsParser.prototype.setPresentationType_ = function(type) {
  2129.   this.presentationType_ = type;
  2131.   if (this.presentationTimeline_) {
  2132.     this.presentationTimeline_.setStatic(!this.isLive_());
  2133.   }
  2135.   if (!this.isLive_()) {
  2136.     if (this.updateTimer_ != null) {
  2137.       window.clearTimeout(this.updateTimer_);
  2138.       this.updateTimer_ = null;
  2139.       this.updatePeriod_ = null;
  2140.     }
  2141.   }
  2142. };
  2145. /**
  2146.  * @const {!Object.<string, shaka.hls.HlsParser.DrmParser_>}
  2147.  * @private
  2148.  */
  2149. shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
  2150.   /* TODO: https://github.com/google/shaka-player/issues/382
  2151.   'com.apple.streamingkeydelivery':
  2152.       shaka.hls.HlsParser.fairplayDrmParser_,
  2153.   */
  2154.   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
  2155.       shaka.hls.HlsParser.widevineDrmParser_
  2156. };
  2159. /**
  2160.  * @enum {string}
  2161.  * @private
  2162.  */
  2163. shaka.hls.HlsParser.PresentationType_ = {
  2164.   VOD: 'VOD',
  2165.   EVENT: 'EVENT',
  2166.   LIVE: 'LIVE'
  2167. };
  2170. /**
  2171.  * @const {number}
  2172.  * @private
  2173.  */
  2174. shaka.hls.HlsParser.TS_TIMESCALE_ = 90000;
  2177. /**
  2178.  * At this value, timestamps roll over in TS content.
  2179.  * @const {number}
  2180.  * @private
  2181.  */
  2182. shaka.hls.HlsParser.TS_ROLLOVER_ = 0x200000000;
  2185. /**
  2186.  * The amount of data from the start of a segment we will try to fetch when we
  2187.  * need to know the segment start time.  This allows us to avoid fetching the
  2188.  * entire segment in many cases.
  2189.  *
  2190.  * @const {number}
  2191.  * @private
  2192.  */
  2193. shaka.hls.HlsParser.PARTIAL_SEGMENT_SIZE_ = 2048;
  2196. shaka.media.ManifestParser.registerParserByExtension(
  2197.     'm3u8', shaka.hls.HlsParser);
  2198. shaka.media.ManifestParser.registerParserByMime(
  2199.     'application/x-mpegurl', shaka.hls.HlsParser);
  2200. shaka.media.ManifestParser.registerParserByMime(
  2201.     'application/vnd.apple.mpegurl', shaka.hls.HlsParser);