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.ManifestParserUtils');
  42. goog.require('shaka.util.MimeUtils');
  46. /**
  47.  * Creates a new HLS parser.
  48.  *
  49.  * @struct
  50.  * @constructor
  51.  * @implements {shakaExtern.ManifestParser}
  52.  * @export
  53.  */
  54. shaka.hls.HlsParser = function() {
  55.   /** @private {?shakaExtern.ManifestParser.PlayerInterface} */
  56.   this.playerInterface_ = null;
  58.   /** @private {?shakaExtern.ManifestConfiguration} */
  59.   this.config_ = null;
  61.   /** @private {number} */
  62.   this.globalId_ = 1;
  64.   /**
  65.    * TODO: this is now only used for text codec detection, try to remove
  66.    * @private {!Object.<number, shaka.hls.HlsParser.StreamInfo>}
  67.    */
  68.   this.mediaTagsToStreamInfosMap_ = {};
  70.   /**
  71.    * The key is a string of the form "<VIDEO URI> - <AUDIO URI>".
  72.    * TODO: should use original, resolved URIs, before redirects
  73.    * @private {!Object.<string, shakaExtern.Variant>}
  74.    */
  75.   this.urisToVariantsMap_ = {};
  77.   /** @private {!Object.<number, !shaka.media.SegmentIndex>} */
  78.   this.streamsToIndexMap_ = {};
  80.   /**
  81.    * A map from media playlists' uris to stream infos
  82.    * representing the playlists.
  83.    * TODO: should use original, resolved URIs, before redirects
  84.    * @private {!Object.<string, shaka.hls.HlsParser.StreamInfo>}
  85.    */
  86.   this.uriToStreamInfosMap_ = {};
  88.   /** @private {?shaka.media.PresentationTimeline} */
  89.   this.presentationTimeline_ = null;
  91.   /**
  92.    * TODO: should be resolved, post-redirect URI, so that media playlist URIs
  93.    * respect master playlist redirects
  94.    * @private {string}
  95.    */
  96.   this.manifestUri_ = '';
  98.   /** @private {shaka.hls.ManifestTextParser} */
  99.   this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
  101.   /**
  102.    * The update period in seconds; or null for no updates.
  103.    * @private {?number}
  104.    */
  105.   this.updatePeriod_ = null;
  107.   /** @private {?number} */
  108.   this.updateTimer_ = null;
  110.   /** @private {shaka.hls.HlsParser.PresentationType_} */
  111.   this.presentationType_ = shaka.hls.HlsParser.PresentationType_.VOD;
  113.   /** @private {?shakaExtern.Manifest} */
  114.   this.manifest_ = null;
  116.   /** @private {number} */
  117.   this.maxTargetDuration_ = 0;
  119.   /** @private {number} */
  120.   this.minTargetDuration_ = Infinity;
  121. };
  124. /**
  125.  * @typedef {{
  126.  *   stream: !shakaExtern.Stream,
  127.  *   segmentIndex: !shaka.media.SegmentIndex,
  128.  *   drmInfos: !Array.<shakaExtern.DrmInfo>,
  129.  *   relativeUri: string,
  130.  *   minTimestamp: number,
  131.  *   duration: number
  132.  * }}
  133.  *
  134.  * @description
  135.  * Contains a stream and information about it.
  136.  *
  137.  * @property {!shakaExtern.Stream} stream
  138.  *   The Stream itself.
  139.  * @property {!shaka.media.SegmentIndex} segmentIndex
  140.  *   SegmentIndex of the stream.
  141.  * @property {!Array.<shakaExtern.DrmInfo>} drmInfos
  142.  *   DrmInfos of the stream.  There may be multiple for multi-DRM content.
  143.  * @property {string} relativeUri
  144.  *   The uri associated with the stream, relative to the manifest.
  145.  * @property {number} minTimestamp
  146.  *   The minimum timestamp found in the stream.  Used for VOD only.
  147.  * @property {number} duration
  148.  *   The duration of the playlist.  Used for VOD only.
  149.  */
  150. shaka.hls.HlsParser.StreamInfo;
  153. /**
  154.  * @override
  155.  * @exportInterface
  156.  */
  157. shaka.hls.HlsParser.prototype.configure = function(config) {
  158.   this.config_ = config;
  159. };
  162. /**
  163.  * @override
  164.  * @exportInterface
  165.  */
  166. shaka.hls.HlsParser.prototype.start = function(uri, playerInterface) {
  167.   goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  168.   this.playerInterface_ = playerInterface;
  169.   this.manifestUri_ = uri;
  170.   return this.requestManifest_(uri).then(function(response) {
  171.     return this.parseManifest_(response.data, uri).then(function() {
  172.       this.setUpdateTimer_(this.updatePeriod_);
  173.       return this.manifest_;
  174.     }.bind(this));
  175.   }.bind(this));
  176. };
  179. /**
  180.  * @override
  181.  * @exportInterface
  182.  */
  183. shaka.hls.HlsParser.prototype.stop = function() {
  184.   this.playerInterface_ = null;
  185.   this.config_ = null;
  186.   this.mediaTagsToStreamInfosMap_ = {};
  187.   this.urisToVariantsMap_ = {};
  188.   this.manifest_ = null;
  190.   return Promise.resolve();
  191. };
  194. /**
  195.  * @override
  196.  * @exportInterface
  197.  */
  198. shaka.hls.HlsParser.prototype.update = function() {
  199.   if (!this.isLive_())
  200.     return;
  202.   var promises = [];
  203.   for (var uri in this.uriToStreamInfosMap_) {
  204.     var streamInfo = this.uriToStreamInfosMap_[uri];
  206.     promises.push(this.updateStream_(streamInfo, uri));
  207.   }
  209.   return Promise.all(promises);
  210. };
  213. /**
  214.  * Updates a stream.
  215.  *
  216.  * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  217.  * @param {string} uri
  218.  * @throws shaka.util.Error
  219.  * @private
  220.  */
  221. shaka.hls.HlsParser.prototype.updateStream_ = function(streamInfo, uri) {
  222.   this.requestManifest_(uri).then(function(response) {
  223.     var Utils = shaka.hls.Utils;
  224.     var PresentationType = shaka.hls.HlsParser.PresentationType_;
  225.     var playlist = this.manifestTextParser_.parsePlaylist(response.data, uri);
  226.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  227.       throw new shaka.util.Error(
  228.           shaka.util.Error.Severity.CRITICAL,
  229.           shaka.util.Error.Category.MANIFEST,
  230.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  231.     }
  233.     var mediaSequenceTag = Utils.getFirstTagWithName(playlist.tags,
  234.                                                      'EXT-X-MEDIA-SEQUENCE');
  236.     var startPosition = mediaSequenceTag ? Number(mediaSequenceTag.value) : 0;
  237.     var stream = streamInfo.stream;
  238.     this.createSegments_(playlist, startPosition,
  239.                          stream.mimeType, stream.codecs)
  240.         .then(function(segments) {
  241.           streamInfo.segmentIndex.replace(segments);
  243.           var newestSegment = segments[segments.length - 1];
  244.           goog.asserts.assert(newestSegment, 'Should have segments!');
  246.           // Once the last segment has been added to the playlist,
  247.           // #EXT-X-ENDLIST tag will be appended.
  248.           // If that happened, treat the rest of the EVENT presentation
  249.           // as VOD.
  250.           var endListTag = Utils.getFirstTagWithName(playlist.tags,
  251.                                                      'EXT-X-ENDLIST');
  252.           if (endListTag) {
  253.             // Convert the presentation to VOD and set the duration to the last
  254.             // segment's end time.
  255.             this.setPresentationType_(PresentationType.VOD);
  256.             this.presentationTimeline_.setDuration(newestSegment.endTime);
  257.           }
  258.         }.bind(this));
  259.   }.bind(this));
  260. };
  263. /**
  264.  * @override
  265.  * @exportInterface
  266.  */
  267. shaka.hls.HlsParser.prototype.onExpirationUpdated = function(
  268.     sessionId, expiration) {
  269.   // No-op
  270. };
  273. /**
  274.  * Parses the manifest.
  275.  *
  276.  * @param {!ArrayBuffer} data
  277.  * @param {string} uri
  278.  * @throws shaka.util.Error When there is a parsing error.
  279.  * @return {!Promise}
  280.  * @private
  281.  */
  282. shaka.hls.HlsParser.prototype.parseManifest_ = function(data, uri) {
  283.   var playlist = this.manifestTextParser_.parsePlaylist(data, uri);
  285.   // We don't support directly providing a Media Playlist.
  286.   // See error code for details.
  287.   if (playlist.type != shaka.hls.PlaylistType.MASTER) {
  288.     throw new shaka.util.Error(
  289.         shaka.util.Error.Severity.CRITICAL,
  290.         shaka.util.Error.Category.MANIFEST,
  291.         shaka.util.Error.Code.HLS_MASTER_PLAYLIST_NOT_PROVIDED);
  292.   }
  294.   return this.createPeriod_(playlist).then(function(period) {
  295.     // HLS has no notion of periods. We're treating the whole presentation as
  296.     // one period.
  297.     this.playerInterface_.filterAllPeriods([period]);
  299.     if (this.isLive_()) {
  300.       // The HLS spec (RFC 8216) states in 6.3.3:
  301.       //
  302.       // "The client SHALL choose which Media Segment to play first ... the
  303.       // client SHOULD NOT choose a segment that starts less than three target
  304.       // durations from the end of the Playlist file.  Doing so can trigger
  305.       // playback stalls."
  306.       //
  307.       // We accomplish this in our DASH-y model by setting a presentation delay
  308.       // of 3 segments.  This will be the "live edge" of the presentation.
  309.       var threeSegmentDurations = this.maxTargetDuration_ * 3;
  310.       this.presentationTimeline_.setDelay(threeSegmentDurations);
  312.       // The HLS spec (RFC 8216) states in 6.3.4:
  313.       // "the client MUST wait for at least the target duration before
  314.       // attempting to reload the Playlist file again"
  315.       this.updatePeriod_ = this.minTargetDuration_;
  317.       // The spec says nothing much about seeking, but Safari's built-in HLS
  318.       // implementation does not allow it.  Therefore we will set the
  319.       // availability window equal to the presentation delay.  The player will
  320.       // be able to buffer ahead three segments, but the seek window will be
  321.       // zero-sized.
  322.       var PresentationType = shaka.hls.HlsParser.PresentationType_;
  323.       if (this.presentationType_ == PresentationType.LIVE) {
  324.         this.presentationTimeline_.setSegmentAvailabilityDuration(
  325.             threeSegmentDurations);
  326.       }
  327.     } else {
  328.       // For VOD/EVENT content, offset everything back to 0.
  329.       // Find the minimum timestamp in all streams, and use that as the
  330.       // presentationTimeOffset for all streams.
  331.       // Find the minimum duration, and use that as the presentation duration.
  332.       var minFirstTimestamp = Infinity;
  333.       var minDuration = Infinity;
  335.       for (var uri in this.uriToStreamInfosMap_) {
  336.         var streamInfo = this.uriToStreamInfosMap_[uri];
  337.         minFirstTimestamp =
  338.             Math.min(minFirstTimestamp, streamInfo.minTimestamp);
  339.         minDuration = Math.min(minDuration, streamInfo.duration);
  340.       }
  342.       this.presentationTimeline_.setDuration(minDuration);
  344.       for (var uri in this.uriToStreamInfosMap_) {
  345.         var streamInfo = this.uriToStreamInfosMap_[uri];
  346.         // This is the offset that StreamingEngine must apply to align the
  347.         // actual segment times with the period.
  348.         streamInfo.stream.presentationTimeOffset = minFirstTimestamp;
  349.         // The segments were created with actual media times, rather than
  350.         // period-aligned times, so offset them all now.
  351.         streamInfo.segmentIndex.offset(-minFirstTimestamp);
  352.         // Finally, fit the segments to the period duration.
  353.         streamInfo.segmentIndex.fit(minDuration);
  354.       }
  355.     }
  357.     goog.asserts.assert(this.presentationTimeline_ != null,
  358.                         'presentationTimeline should already be created!');
  360.     this.manifest_ = {
  361.       presentationTimeline: this.presentationTimeline_,
  362.       periods: [period],
  363.       offlineSessionIds: [],
  364.       minBufferTime: 0
  365.     };
  366.   }.bind(this));
  367. };
  370. /**
  371.  * Parses a playlist into a Period object.
  372.  *
  373.  * @param {!shaka.hls.Playlist} playlist
  374.  * @return {!Promise.<!shakaExtern.Period>}
  375.  * @private
  376.  */
  377. shaka.hls.HlsParser.prototype.createPeriod_ = function(playlist) {
  378.   var Utils = shaka.hls.Utils;
  379.   var Functional = shaka.util.Functional;
  380.   var tags = playlist.tags;
  382.   var mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
  383.   var textStreamTags = mediaTags.filter(function(tag) {
  384.     var type = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  385.     return type == 'SUBTITLES';
  386.   }.bind(this));
  388.   // TODO: CLOSED-CAPTIONS requires the parsing of CEA-608 from the video.
  389.   var textStreamPromises = textStreamTags.map(function(tag) {
  390.     return this.createTextStream_(tag, playlist);
  391.   }.bind(this));
  393.   return Promise.all(textStreamPromises).then(function(textStreams) {
  394.     // Create Variants for every 'EXT-X-STREAM-INF' tag.  Do this after text
  395.     // streams have been created, so that we can push text codecs found on the
  396.     // variant tag back into the created text streams.
  397.     var variantTags = Utils.filterTagsByName(tags, 'EXT-X-STREAM-INF');
  398.     var variantsPromises = variantTags.map(function(tag) {
  399.       return this.createVariantsForTag_(tag, playlist);
  400.     }.bind(this));
  402.     return Promise.all(variantsPromises).then(function(allVariants) {
  403.       var variants = allVariants.reduce(Functional.collapseArrays, []);
  404.       return {
  405.         startTime: 0,
  406.         variants: variants,
  407.         textStreams: textStreams
  408.       };
  409.     }.bind(this));
  410.   }.bind(this));
  411. };
  414. /**
  415.  * @param {!shaka.hls.Tag} tag
  416.  * @param {!shaka.hls.Playlist} playlist
  417.  * @return {!Promise.<!Array.<!shakaExtern.Variant>>}
  418.  * @private
  419.  */
  420. shaka.hls.HlsParser.prototype.createVariantsForTag_ = function(tag, playlist) {
  421.   goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  422.                       'Should only be called on variant tags!');
  423.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  424.   var HlsParser = shaka.hls.HlsParser;
  425.   var Utils = shaka.hls.Utils;
  427.   // These are the default codecs to assume if none are specified.
  428.   //
  429.   // The video codec is H.264, with baseline profile and level 3.0.
  430.   // http://blog.pearce.org.nz/2013/11/what-does-h264avc1-codecs-parameters.html
  431.   //
  432.   // The audio codec is "low-complexity" AAC.
  433.   var defaultCodecs = 'avc1.42E01E,mp4a.40.2';
  435.   /** @type {!Array.<string>} */
  436.   var codecs = tag.getAttributeValue('CODECS', defaultCodecs).split(',');
  437.   var resolutionAttr = tag.getAttribute('RESOLUTION');
  438.   var width = null;
  439.   var height = null;
  440.   var frameRate = tag.getAttributeValue('FRAME-RATE');
  441.   var bandwidth =
  442.       Number(HlsParser.getRequiredAttributeValue_(tag, 'BANDWIDTH'));
  444.   if (resolutionAttr) {
  445.     var resBlocks = resolutionAttr.value.split('x');
  446.     width = resBlocks[0];
  447.     height = resBlocks[1];
  448.   }
  450.   // After filtering, this is a list of the media tags we will process to
  451.   // combine with the variant tag (EXT-X-STREAM-INF) we are working on.
  452.   var mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
  454.   var audioGroupId = tag.getAttributeValue('AUDIO');
  455.   var videoGroupId = tag.getAttributeValue('VIDEO');
  456.   goog.asserts.assert(audioGroupId == null || videoGroupId == null,
  457.       'Unexpected: both video and audio described by media tags!');
  459.   // Find any associated audio or video groups and create streams for them.
  460.   if (audioGroupId) {
  461.     mediaTags = Utils.findMediaTags(mediaTags, 'AUDIO', audioGroupId);
  462.   } else if (videoGroupId) {
  463.     mediaTags = Utils.findMediaTags(mediaTags, 'VIDEO', videoGroupId);
  464.   }
  466.   // There may be a codec string for the text stream.  We should identify it,
  467.   // add it to the appropriate stream, then strip it out of the variant to
  468.   // avoid confusing our multiplex detection below.
  469.   var textCodecs = this.guessCodecsSafe_(ContentType.TEXT, codecs);
  470.   if (textCodecs) {
  471.     // We found a text codec in the list, so look for an associated text stream.
  472.     var subGroupId = tag.getAttributeValue('SUBTITLES');
  473.     if (subGroupId) {
  474.       var textTags = Utils.findMediaTags(mediaTags, 'SUBTITLES', subGroupId);
  475.       goog.asserts.assert(textTags.length == 1,
  476.                           'Exactly one text tag expected!');
  477.       if (textTags.length) {
  478.         // We found a text codec and text stream, so make sure the codec is
  479.         // attached to the stream.
  480.         var textStreamInfo = this.mediaTagsToStreamInfosMap_[textTags[0].id];
  481.         textStreamInfo.stream.codecs = textCodecs;
  482.       }
  483.     }
  485.     // Remove this entry from the list of codecs that belong to audio/video.
  486.     codecs.splice(codecs.indexOf(textCodecs), 1);
  487.   }
  489.   var promises = mediaTags.map(function(tag) {
  490.     return this.createStreamInfoFromMediaTag_(tag, codecs);
  491.   }.bind(this));
  493.   var audioStreamInfos = [];
  494.   var videoStreamInfos = [];
  496.   return Promise.all(promises).then(function(data) {
  497.     if (audioGroupId) {
  498.       audioStreamInfos = data;
  499.     } else if (videoGroupId) {
  500.       videoStreamInfos = data;
  501.     }
  503.     // Make an educated guess about the stream type.
  504.     shaka.log.debug('Guessing stream type for', tag.toString());
  505.     var type;
  506.     if (!audioStreamInfos.length && !videoStreamInfos.length) {
  507.       // There are no associated streams.  This is either an audio-only stream,
  508.       // a video-only stream, or a multiplexed stream.
  509.       var ignoreStream = false;
  511.       if (codecs.length == 1) {
  512.         // There is only one codec, so it shouldn't be multiplexed.
  514.         var videoCodecs = this.guessCodecsSafe_(ContentType.VIDEO, codecs);
  515.         if (resolutionAttr || frameRate || videoCodecs) {
  516.           // Assume video-only.
  517.           shaka.log.debug('Guessing video-only.');
  518.           type = ContentType.VIDEO;
  519.         } else {
  520.           // Assume audio-only.
  521.           shaka.log.debug('Guessing audio-only.');
  522.           type = ContentType.AUDIO;
  523.         }
  524.       } else {
  525.         // There are multiple codecs, so assume multiplexed content.
  526.         // Note that the default used when CODECS is missing assumes multiple
  527.         // (and therefore multiplexed).
  528.         // Recombine the codec strings into one so that MediaSource isn't
  529.         // lied to later.  (That would trigger an error in Chrome.)
  530.         shaka.log.debug('Guessing multiplexed audio+video.');
  531.         type = ContentType.VIDEO;
  532.         codecs = [codecs.join(',')];
  533.       }
  534.     } else if (audioStreamInfos.length) {
  535.       var streamURI = HlsParser.getRequiredAttributeValue_(tag, 'URI');
  536.       var firstAudioStreamURI = audioStreamInfos[0].relativeUri;
  537.       if (streamURI == firstAudioStreamURI) {
  538.         // The Microsoft HLS manifest generators will make audio-only variants
  539.         // that link to their URI both directly and through an audio tag.
  540.         // In that case, ignore the local URI and use the version in the
  541.         // AUDIO tag, so you inherit its language.
  542.         // As an example, see the manifest linked in issue #860.
  543.         shaka.log.debug('Guessing audio-only.');
  544.         type = ContentType.AUDIO;
  545.         ignoreStream = true;
  546.       } else {
  547.         // There are associated audio streams.  Assume this is video.
  548.         shaka.log.debug('Guessing video.');
  549.         type = ContentType.VIDEO;
  550.       }
  551.     } else {
  552.       // There are associated video streams.  Assume this is audio.
  553.       goog.asserts.assert(videoStreamInfos.length,
  554.           'No video streams!  This should have been handled already!');
  555.       shaka.log.debug('Guessing audio.');
  556.       type = ContentType.AUDIO;
  557.     }
  559.     goog.asserts.assert(type, 'Type should have been set by now!');
  560.     if (ignoreStream)
  561.       return Promise.resolve();
  562.     return this.createStreamInfoFromVariantTag_(tag, codecs, type);
  563.   }.bind(this)).then(function(streamInfo) {
  564.     if (streamInfo) {
  565.       if (streamInfo.stream.type == ContentType.AUDIO) {
  566.         audioStreamInfos = [streamInfo];
  567.       } else {
  568.         videoStreamInfos = [streamInfo];
  569.       }
  570.     }
  571.     goog.asserts.assert(videoStreamInfos || audioStreamInfos,
  572.         'We should have created a stream!');
  574.     return this.createVariants_(
  575.         audioStreamInfos,
  576.         videoStreamInfos,
  577.         bandwidth,
  578.         width,
  579.         height,
  580.         frameRate);
  581.   }.bind(this));
  582. };
  585. /**
  586.  * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} audioInfos
  587.  * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} videoInfos
  588.  * @param {number} bandwidth
  589.  * @param {?string} width
  590.  * @param {?string} height
  591.  * @param {?string} frameRate
  592.  * @return {!Array.<!shakaExtern.Variant>}
  593.  * @private
  594.  */
  595. shaka.hls.HlsParser.prototype.createVariants_ =
  596.     function(audioInfos, videoInfos, bandwidth, width, height, frameRate) {
  597.   var DrmEngine = shaka.media.DrmEngine;
  599.   videoInfos.forEach(function(info) {
  600.     this.addVideoAttributes_(info.stream, width, height, frameRate);
  601.   }.bind(this));
  603.   // In case of audio-only or video-only content, we create an array of
  604.   // one item containing a null. This way, the double-loop works for all
  605.   // kinds of content.
  606.   // NOTE: we currently don't have support for audio-only content.
  607.   if (!audioInfos.length)
  608.     audioInfos = [null];
  609.   if (!videoInfos.length)
  610.     videoInfos = [null];
  612.   var variants = [];
  613.   for (var i = 0; i < audioInfos.length; i++) {
  614.     for (var j = 0; j < videoInfos.length; j++) {
  615.       var audioStream = audioInfos[i] ? audioInfos[i].stream : null;
  616.       var videoStream = videoInfos[j] ? videoInfos[j].stream : null;
  617.       var audioDrmInfos = audioInfos[i] ? audioInfos[i].drmInfos : null;
  618.       var videoDrmInfos = videoInfos[j] ? videoInfos[j].drmInfos : null;
  620.       var drmInfos;
  621.       if (audioStream && videoStream) {
  622.         if (DrmEngine.areDrmCompatible(audioDrmInfos, videoDrmInfos)) {
  623.           drmInfos = DrmEngine.getCommonDrmInfos(audioDrmInfos, videoDrmInfos);
  624.         } else {
  625.           shaka.log.warning('Incompatible DRM info in HLS variant.  Skipping.');
  626.           continue;
  627.         }
  628.       } else if (audioStream) {
  629.         drmInfos = audioDrmInfos;
  630.       } else if (videoStream) {
  631.         drmInfos = videoDrmInfos;
  632.       }
  634.       var videoStreamUri = videoInfos[i] ? videoInfos[i].relativeUri : '';
  635.       var audioStreamUri = audioInfos[i] ? audioInfos[i].relativeUri : '';
  636.       var variantMapKey = videoStreamUri + ' - ' + audioStreamUri;
  637.       if (this.urisToVariantsMap_[variantMapKey]) {
  638.         // This happens when two variants only differ in their text streams.
  639.         shaka.log.debug('Skipping variant which only differs in text streams.');
  640.         continue;
  641.       }
  643.       var variant = this.createVariant_(
  644.           audioStream, videoStream, bandwidth, drmInfos);
  645.       variants.push(variant);
  646.       this.urisToVariantsMap_[variantMapKey] = variant;
  647.     }
  648.   }
  649.   return variants;
  650. };
  653. /**
  654.  * @param {shakaExtern.Stream} audio
  655.  * @param {shakaExtern.Stream} video
  656.  * @param {number} bandwidth
  657.  * @param {!Array.<shakaExtern.DrmInfo>} drmInfos
  658.  * @return {!shakaExtern.Variant}
  659.  * @private
  660.  */
  661. shaka.hls.HlsParser.prototype.createVariant_ =
  662.     function(audio, video, bandwidth, drmInfos) {
  663.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  665.   // Since both audio and video are of the same type, this assertion will catch
  666.   // certain mistakes at runtime that the compiler would miss.
  667.   goog.asserts.assert(!audio || audio.type == ContentType.AUDIO,
  668.                       'Audio parameter mismatch!');
  669.   goog.asserts.assert(!video || video.type == ContentType.VIDEO,
  670.                       'Video parameter mismatch!');
  672.   return {
  673.     id: this.globalId_++,
  674.     language: audio ? audio.language : 'und',
  675.     primary: (!!audio && audio.primary) || (!!video && video.primary),
  676.     audio: audio,
  677.     video: video,
  678.     bandwidth: bandwidth,
  679.     drmInfos: drmInfos,
  680.     allowedByApplication: true,
  681.     allowedByKeySystem: true
  682.   };
  683. };
  686. /**
  687.  * Parses an EXT-X-MEDIA tag with TYPE="SUBTITLES" into a text stream.
  688.  *
  689.  * @param {!shaka.hls.Tag} tag
  690.  * @param {!shaka.hls.Playlist} playlist
  691.  * @return {!Promise.<?shakaExtern.Stream>}
  692.  * @private
  693.  */
  694. shaka.hls.HlsParser.prototype.createTextStream_ = function(tag, playlist) {
  695.   goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  696.                       'Should only be called on media tags!');
  698.   var type = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  699.   goog.asserts.assert(type == 'SUBTITLES',
  700.                       'Should only be called on tags with TYPE="SUBTITLES"!');
  702.   return this.createStreamInfoFromMediaTag_(tag, [])
  703.     .then(function(streamInfo) {
  704.         return streamInfo.stream;
  705.       });
  706. };
  709. /**
  710.  * Parse EXT-X-MEDIA media tag into a Stream object.
  711.  *
  712.  * @param {shaka.hls.Tag} tag
  713.  * @param {!Array.<!string>} allCodecs
  714.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  715.  * @private
  716.  */
  717. shaka.hls.HlsParser.prototype.createStreamInfoFromMediaTag_ =
  718.     function(tag, allCodecs) {
  719.   goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  720.                       'Should only be called on media tags!');
  722.   var HlsParser = shaka.hls.HlsParser;
  723.   var uri = HlsParser.getRequiredAttributeValue_(tag, 'URI');
  724.   uri = shaka.hls.Utils.constructAbsoluteUri(this.manifestUri_, uri);
  726.   // Check if the stream has already been created as part of another Variant
  727.   // and return it if it has.
  728.   if (this.uriToStreamInfosMap_[uri]) {
  729.     return Promise.resolve(this.uriToStreamInfosMap_[uri]);
  730.   }
  732.   var type = HlsParser.getRequiredAttributeValue_(tag, 'TYPE').toLowerCase();
  733.   // Shaka recognizes content types 'audio', 'video' and 'text'.
  734.   // HLS 'subtitles' type needs to be mapped to 'text'.
  735.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  736.   if (type == 'subtitles') type = ContentType.TEXT;
  738.   var LanguageUtils = shaka.util.LanguageUtils;
  739.   var language = LanguageUtils.normalize(/** @type {string} */(
  740.       tag.getAttributeValue('LANGUAGE', 'und')));
  741.   var label = tag.getAttributeValue('NAME');
  743.   var defaultAttr = tag.getAttribute('DEFAULT');
  744.   var autoselectAttr = tag.getAttribute('AUTOSELECT');
  745.   // TODO: Should we take into account some of the currently ignored attributes:
  746.   // FORCED, INSTREAM-ID, CHARACTERISTICS, CHANNELS?
  747.   // Attribute descriptions:
  748.   // https://tools.ietf.org/html/draft-pantos-http-live-streaming-20#section-4.3.4.1
  749.   var channelsAttribute = tag.getAttributeValue('CHANNELS');
  750.   var channelsCount = type == 'audio' ?
  751.       this.getChannelsCount_(channelsAttribute) : null;
  752.   var primary = !!defaultAttr || !!autoselectAttr;
  753.   return this.createStreamInfo_(uri, allCodecs, type,
  754.       language, primary, label, channelsCount).then(function(streamInfo) {
  756.     // TODO: This check is necessary because of the possibility of multiple
  757.     // calls to createStreamInfoFromMediaTag_ before either has resolved.
  758.     if (this.uriToStreamInfosMap_[uri])
  759.       return this.uriToStreamInfosMap_[uri];
  761.     this.mediaTagsToStreamInfosMap_[tag.id] = streamInfo;
  762.     this.uriToStreamInfosMap_[uri] = streamInfo;
  763.     return streamInfo;
  764.   }.bind(this));
  765. };
  768. /**
  769.  * Get the channels count information for HLS audio track.
  770.  * The channels value is a string that specifies an ordered, "/" separated list
  771.  * of parameters. If the type is audio, the first parameter will be a decimal
  772.  * integer, as the number of independent, simultaneous audio channels.
  773.  * No other channels parameters are currently defined.
  774.  *
  775.  * @param {?string} channels
  776.  *
  777.  * @return {?number} channelcount
  778.  * @private
  779.  */
  780. shaka.hls.HlsParser.prototype.getChannelsCount_ = function(channels) {
  781.   if (!channels) return null;
  782.   var channelscountstring = channels.split('/')[0];
  783.   var count = parseInt(channelscountstring, 10);
  784.   return count;
  785. };
  788. /**
  789.  * Parse EXT-X-STREAM-INF media tag into a Stream object.
  790.  *
  791.  * @param {!shaka.hls.Tag} tag
  792.  * @param {!Array.<!string>} allCodecs
  793.  * @param {!string} type
  794.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  795.  * @private
  796.  */
  797. shaka.hls.HlsParser.prototype.createStreamInfoFromVariantTag_ =
  798.     function(tag, allCodecs, type) {
  799.   goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  800.                       'Should only be called on media tags!');
  802.   var uri = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'URI');
  803.   uri = shaka.hls.Utils.constructAbsoluteUri(this.manifestUri_, uri);
  805.   if (this.uriToStreamInfosMap_[uri]) {
  806.     return Promise.resolve(this.uriToStreamInfosMap_[uri]);
  807.   }
  809.   return this.createStreamInfo_(uri, allCodecs, type,
  810.                                 /* language */ 'und', /* primary */ false,
  811.                                 /* label */ null, /* channelcount */ null).then(
  812.       function(streamInfo) {
  813.         // TODO: This check is necessary because of the possibility of multiple
  814.         // calls to createStreamInfoFromVariantTag_ before either has resolved.
  815.         if (this.uriToStreamInfosMap_[uri])
  816.           return this.uriToStreamInfosMap_[uri];
  818.         this.uriToStreamInfosMap_[uri] = streamInfo;
  819.         return streamInfo;
  820.       }.bind(this));
  821. };
  824. /**
  825.  * @param {!string} uri
  826.  * @param {!Array.<!string>} allCodecs
  827.  * @param {!string} type
  828.  * @param {!string} language
  829.  * @param {boolean} primary
  830.  * @param {?string} label
  831.  * @param {?number} channelsCount
  832.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  833.  * @throws shaka.util.Error
  834.  * @private
  835.  */
  836. shaka.hls.HlsParser.prototype.createStreamInfo_ = function(uri, allCodecs,
  837.     type, language, primary, label, channelsCount) {
  838.   var Utils = shaka.hls.Utils;
  839.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  840.   var HlsParser = shaka.hls.HlsParser;
  842.   var relativeUri = uri;
  843.   uri = Utils.constructAbsoluteUri(this.manifestUri_, uri);
  845.   /** @type {!shaka.hls.Playlist} */
  846.   var playlist;
  847.   /** @type {string} */
  848.   var codecs = '';
  849.   /** @type {string} */
  850.   var mimeType;
  852.   return this.requestManifest_(uri).then(function(response) {
  853.     playlist = this.manifestTextParser_.parsePlaylist(response.data, uri);
  854.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  855.       // EXT-X-MEDIA tags should point to media playlists.
  856.       throw new shaka.util.Error(
  857.           shaka.util.Error.Severity.CRITICAL,
  858.           shaka.util.Error.Category.MANIFEST,
  859.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  860.     }
  862.     goog.asserts.assert(playlist.segments != null,
  863.                         'Media playlist should have segments!');
  865.     this.determinePresentationType_(playlist);
  867.     codecs = this.guessCodecs_(type, allCodecs);
  868.     return this.guessMimeType_(type, codecs, playlist);
  869.   }.bind(this)).then(function(mimeTypeArg) {
  870.     mimeType = mimeTypeArg;
  872.     var mediaSequenceTag = Utils.getFirstTagWithName(playlist.tags,
  873.                                                      'EXT-X-MEDIA-SEQUENCE');
  875.     var startPosition = mediaSequenceTag ? Number(mediaSequenceTag.value) : 0;
  877.     return this.createSegments_(playlist, startPosition, mimeType, codecs);
  878.   }.bind(this)).then(function(segments) {
  879.     var minTimestamp = segments[0].startTime;
  880.     var lastEndTime = segments[segments.length - 1].endTime;
  881.     var duration = lastEndTime - minTimestamp;
  882.     var segmentIndex = new shaka.media.SegmentIndex(segments);
  884.     if (!this.presentationTimeline_) {
  885.       // The presentation started last available segment's end time ago.
  886.       // All variants should be in sync in terms of timeline, so just grab
  887.       // this from an arbitrary stream.
  888.       this.createPresentationTimeline_(lastEndTime);
  889.     }
  891.     var initSegmentReference = null;
  893.     if (type != ContentType.TEXT) {
  894.       initSegmentReference = this.createInitSegmentReference_(playlist);
  895.     }
  897.     this.presentationTimeline_.notifySegments(0, segments);
  899.     var kind = undefined;
  900.     var ManifestParserUtils = shaka.util.ManifestParserUtils;
  901.     if (type == ManifestParserUtils.ContentType.TEXT)
  902.       kind = ManifestParserUtils.TextStreamKind.SUBTITLE;
  903.     // TODO: CLOSED-CAPTIONS requires the parsing of CEA-608
  904.     // from the video.
  906.     var drmTags = [];
  907.     playlist.segments.forEach(function(segment) {
  908.       var segmentKeyTags = Utils.filterTagsByName(segment.tags,
  909.                                                   'EXT-X-KEY');
  910.       drmTags.push.apply(drmTags, segmentKeyTags);
  911.     });
  913.     var encrypted = false;
  914.     var drmInfos = [];
  915.     var keyId = null;
  917.     // TODO: may still need changes to support key rotation
  918.     drmTags.forEach(function(drmTag) {
  919.       var method = HlsParser.getRequiredAttributeValue_(drmTag, 'METHOD');
  920.       if (method != 'NONE') {
  921.         encrypted = true;
  923.         var keyFormat =
  924.             HlsParser.getRequiredAttributeValue_(drmTag, 'KEYFORMAT');
  925.         var drmParser =
  926.             shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  928.         var drmInfo = drmParser ? drmParser(drmTag) : null;
  929.         if (drmInfo) {
  930.           if (drmInfo.keyIds.length) {
  931.             keyId = drmInfo.keyIds[0];
  932.           }
  933.           drmInfos.push(drmInfo);
  934.         } else {
  935.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  936.         }
  937.       }
  938.     });
  940.     if (encrypted && !drmInfos.length) {
  941.       throw new shaka.util.Error(
  942.           shaka.util.Error.Severity.CRITICAL,
  943.           shaka.util.Error.Category.MANIFEST,
  944.           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
  945.     }
  947.     var stream = {
  948.       id: this.globalId_++,
  949.       createSegmentIndex: Promise.resolve.bind(Promise),
  950.       findSegmentPosition: segmentIndex.find.bind(segmentIndex),
  951.       getSegmentReference: segmentIndex.get.bind(segmentIndex),
  952.       initSegmentReference: initSegmentReference,
  953.       presentationTimeOffset: 0,
  954.       mimeType: mimeType,
  955.       codecs: codecs,
  956.       kind: kind,
  957.       encrypted: encrypted,
  958.       keyId: keyId,
  959.       language: language,
  960.       label: label || null,
  961.       type: type,
  962.       primary: primary,
  963.       // TODO: trick mode
  964.       trickModeVideo: null,
  965.       containsEmsgBoxes: false,
  966.       frameRate: undefined,
  967.       width: undefined,
  968.       height: undefined,
  969.       bandwidth: undefined,
  970.       roles: [],
  971.       channelsCount: channelsCount
  972.     };
  974.     this.streamsToIndexMap_[stream.id] = segmentIndex;
  976.     return {
  977.       stream: stream,
  978.       segmentIndex: segmentIndex,
  979.       drmInfos: drmInfos,
  980.       relativeUri: relativeUri,
  981.       minTimestamp: minTimestamp,
  982.       duration: duration
  983.     };
  984.   }.bind(this));
  985. };
  988. /**
  989.  * @param {!shaka.hls.Playlist} playlist
  990.  * @private
  991.  */
  992. shaka.hls.HlsParser.prototype.determinePresentationType_ = function(playlist) {
  993.   var Utils = shaka.hls.Utils;
  994.   var PresentationType = shaka.hls.HlsParser.PresentationType_;
  995.   var presentationTypeTag = Utils.getFirstTagWithName(playlist.tags,
  996.                                                       'EXT-X-PLAYLIST-TYPE');
  997.   var endListTag = Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  999.   var isVod = (presentationTypeTag && presentationTypeTag.value == 'VOD') ||
  1000.       endListTag;
  1001.   var isEvent = presentationTypeTag && presentationTypeTag.value == 'EVENT' &&
  1002.       !isVod;
  1003.   var isLive = !isVod && !isEvent;
  1005.   if (isVod) {
  1006.     this.setPresentationType_(PresentationType.VOD);
  1007.   } else {
  1008.     // presentation type LIVE or an ongoing EVENT
  1009.     if (isLive) {
  1010.       this.setPresentationType_(PresentationType.LIVE);
  1011.     } else {
  1012.       this.setPresentationType_(PresentationType.EVENT);
  1013.     }
  1015.     var targetDurationTag = this.getRequiredTag_(playlist.tags,
  1016.                                                  'EXT-X-TARGETDURATION');
  1017.     var targetDuration = Number(targetDurationTag.value);
  1019.     // According to HLS spec, updates should not happen more often than
  1020.     // once in targetDuration. It also requires to only update the active
  1021.     // variant. We might implement that later, but for now every variant
  1022.     // will be updated. To get the update period, choose the smallest
  1023.     // targetDuration value across all playlists.
  1025.     // Update longest target duration if need be to use as a presentation
  1026.     // delay later.
  1027.     this.maxTargetDuration_ = Math.max(targetDuration, this.maxTargetDuration_);
  1028.     // Update the shortest one to use as update period and segment availability
  1029.     // time (for LIVE).
  1030.     this.minTargetDuration_ = Math.min(targetDuration, this.minTargetDuration_);
  1031.   }
  1032. };
  1035. /**
  1036.  * @param {number} endTime
  1037.  * @throws shaka.util.Error
  1038.  * @private
  1039.  */
  1040. shaka.hls.HlsParser.prototype.createPresentationTimeline_ = function(endTime) {
  1041.   var presentationStartTime = null;
  1042.   var delay = 0;
  1044.   if (this.isLive_()) {
  1045.     presentationStartTime = (Date.now() / 1000) - endTime;
  1047.     // We should have a delay of at least 3 target durations.
  1048.     delay = this.maxTargetDuration_ * 3;
  1049.   }
  1051.   this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  1052.       presentationStartTime, delay);
  1053.   this.presentationTimeline_.setStatic(!this.isLive_());
  1054. };
  1057. /**
  1058.  * @param {!shaka.hls.Playlist} playlist
  1059.  * @return {shaka.media.InitSegmentReference}
  1060.  * @private
  1061.  * @throws {shaka.util.Error}
  1062.  */
  1063. shaka.hls.HlsParser.prototype.createInitSegmentReference_ = function(playlist) {
  1064.   var Utils = shaka.hls.Utils;
  1065.   var mapTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MAP');
  1066.   // TODO: Support multiple map tags?
  1067.   // For now, we don't support multiple map tags and will throw an error.
  1068.   if (!mapTags.length) {
  1069.     return null;
  1070.   } else if (mapTags.length > 1) {
  1071.     throw new shaka.util.Error(
  1072.         shaka.util.Error.Severity.CRITICAL,
  1073.         shaka.util.Error.Category.MANIFEST,
  1074.         shaka.util.Error.Code.HLS_MULTIPLE_MEDIA_INIT_SECTIONS_FOUND);
  1075.   }
  1077.   // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
  1078.   var mapTag = mapTags[0];
  1079.   var initUri = shaka.hls.HlsParser.getRequiredAttributeValue_(mapTag, 'URI');
  1080.   var uri = Utils.constructAbsoluteUri(playlist.uri, initUri);
  1081.   var startByte = 0;
  1082.   var endByte = null;
  1083.   var byterange = mapTag.getAttributeValue('BYTERANGE');
  1084.   // If BYTERANGE attribute is not specified, the segment consists
  1085.   // of the entire resourse.
  1086.   if (byterange) {
  1087.     var blocks = byterange.split('@');
  1088.     var byteLength = Number(blocks[0]);
  1089.     startByte = Number(blocks[1]);
  1090.     endByte = startByte + byteLength - 1;
  1091.   }
  1093.   return new shaka.media.InitSegmentReference(function() { return [uri]; },
  1094.                                               startByte,
  1095.                                               endByte);
  1096. };
  1099. /**
  1100.  * Parses one shaka.hls.Segment object into a shaka.media.SegmentReference.
  1101.  *
  1102.  * @param {!shaka.hls.Playlist} playlist
  1103.  * @param {shaka.media.SegmentReference} previousReference
  1104.  * @param {!shaka.hls.Segment} hlsSegment
  1105.  * @param {number} position
  1106.  * @param {number} startTime
  1107.  * @return {!shaka.media.SegmentReference}
  1108.  * @private
  1109.  */
  1110. shaka.hls.HlsParser.prototype.createSegmentReference_ =
  1111.     function(playlist, previousReference, hlsSegment, position, startTime) {
  1112.   var Utils = shaka.hls.Utils;
  1113.   var tags = hlsSegment.tags;
  1114.   var uri = Utils.constructAbsoluteUri(playlist.uri, hlsSegment.uri);
  1116.   var extinfTag = this.getRequiredTag_(tags, 'EXTINF');
  1117.   // EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  1118.   // We're interested in the duration part.
  1119.   var extinfValues = extinfTag.value.split(',');
  1120.   var duration = Number(extinfValues[0]);
  1121.   var endTime = startTime + duration;
  1123.   var startByte = 0;
  1124.   var endByte = null;
  1125.   var byterange = Utils.getFirstTagWithName(tags, 'EXT-X-BYTERANGE');
  1127.   // If BYTERANGE is not specified, the segment consists of the
  1128.   // entire resourse.
  1129.   if (byterange) {
  1130.     var blocks = byterange.value.split('@');
  1131.     var byteLength = Number(blocks[0]);
  1132.     if (blocks[1]) {
  1133.       startByte = Number(blocks[1]);
  1134.     } else {
  1135.       goog.asserts.assert(previousReference,
  1136.                           'Cannot refer back to previous HLS segment!');
  1137.       startByte = previousReference.endByte + 1;
  1138.     }
  1139.     endByte = startByte + byteLength - 1;
  1140.   }
  1142.   return new shaka.media.SegmentReference(
  1143.       position,
  1144.       startTime,
  1145.       endTime,
  1146.       function() { return [uri]; },
  1147.       startByte,
  1148.       endByte);
  1149. };
  1152. /**
  1153.  * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences.
  1154.  *
  1155.  * @param {!shaka.hls.Playlist} playlist
  1156.  * @param {number} startPosition
  1157.  * @param {string} mimeType
  1158.  * @param {string} codecs
  1159.  * @return {!Promise<!Array.<!shaka.media.SegmentReference>>}
  1160.  * @private
  1161.  */
  1162. shaka.hls.HlsParser.prototype.createSegments_ =
  1163.     function(playlist, startPosition, mimeType, codecs) {
  1164.   var Utils = shaka.hls.Utils;
  1165.   var hlsSegments = playlist.segments;
  1166.   var references = [];
  1168.   goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
  1169.   // We may need to look at the media itself to determine a segment start time.
  1170.   var firstSegmentUri = Utils.constructAbsoluteUri(playlist.uri,
  1171.                                                    hlsSegments[0].uri);
  1172.   var firstSegmentRef =
  1173.       this.createSegmentReference_(
  1174.           playlist,
  1175.           null /* previousReference */,
  1176.           hlsSegments[0],
  1177.           startPosition,
  1178.           0 /* startTime, irrelevant */);
  1180.   return this.getStartTime_(playlist.uri, firstSegmentRef, mimeType, codecs)
  1181.       .then(function(firstStartTime) {
  1182.         shaka.log.debug('First segment', firstSegmentUri.split('/').pop(),
  1183.                         'starts at', firstStartTime);
  1184.         for (var i = 0; i < hlsSegments.length; ++i) {
  1185.           var hlsSegment = hlsSegments[i];
  1186.           var previousReference = references[references.length - 1];
  1187.           var startTime = (i == 0) ? firstStartTime : previousReference.endTime;
  1188.           var position = startPosition + i;
  1190.           var reference = this.createSegmentReference_(
  1191.               playlist,
  1192.               previousReference,
  1193.               hlsSegment,
  1194.               position,
  1195.               startTime);
  1196.           references.push(reference);
  1197.         }
  1199.         return references;
  1200.       }.bind(this));
  1201. };
  1204. /**
  1205.  * Try to fetch a partial segment, and fall back to a full segment if we have
  1206.  * to.
  1207.  *
  1208.  * @param {!shaka.media.SegmentReference} segmentRef
  1209.  * @return {!Promise.<shakaExtern.Response>}
  1210.  * @throws {shaka.util.Error}
  1211.  * @private
  1212.  */
  1213. shaka.hls.HlsParser.prototype.fetchPartialSegment_ = function(segmentRef) {
  1214.   var networkingEngine = this.playerInterface_.networkingEngine;
  1215.   var requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1216.   var request = shaka.net.NetworkingEngine.makeRequest(
  1217.       segmentRef.getUris(), this.config_.retryParameters);
  1219.   // Try to avoid fetching the entire segment, which can be quite large.
  1220.   var partialSegmentHeaders = {};
  1221.   var startByte = segmentRef.startByte;
  1222.   var partialEndByte =
  1223.       startByte + shaka.hls.HlsParser.PARTIAL_SEGMENT_SIZE_ - 1;
  1224.   partialSegmentHeaders['Range'] = 'bytes=' + startByte + '-' + partialEndByte;
  1226.   // Prepare a fallback to the entire segment.
  1227.   var fullSegmentHeaders = {};
  1228.   if ((startByte != 0) || (segmentRef.endByte != null)) {
  1229.     var range = 'bytes=' + startByte + '-';
  1230.     if (segmentRef.endByte != null) range += segmentRef.endByte;
  1232.     fullSegmentHeaders['Range'] = range;
  1233.   }
  1235.   // Try a partial request first.
  1236.   request.headers = partialSegmentHeaders;
  1237.   return networkingEngine.request(requestType, request).catch(function(error) {
  1238.     // The partial request may fail for a number of reasons.
  1239.     // Some servers do not support Range requests, and others do not support the
  1240.     // OPTIONS request which must be made before any cross-origin Range request.
  1241.     // Since this fallback is expensive, warn the app developer.
  1242.     shaka.log.alwaysWarn('Unable to fetch a partial HLS segment! ' +
  1243.                          'Falling back to a full segment request, ' +
  1244.                          'which is expensive!  Your server should support ' +
  1245.                          'Range requests and CORS preflights.',
  1246.                          request.uris[0]);
  1247.     request.headers = fullSegmentHeaders;
  1248.     return networkingEngine.request(requestType, request);
  1249.   });
  1250. };
  1253. /**
  1254.  * Gets start time of a segment from the existing manifest (if possible) or by
  1255.  * downloading it and parsing it otherwise.
  1256.  *
  1257.  * @param {string} playlistUri
  1258.  * @param {!shaka.media.SegmentReference} segmentRef
  1259.  * @param {string} mimeType
  1260.  * @param {string} codecs
  1261.  * @return {!Promise.<number>}
  1262.  * @throws {shaka.util.Error}
  1263.  * @private
  1264.  */
  1265. shaka.hls.HlsParser.prototype.getStartTime_ =
  1266.     function(playlistUri, segmentRef, mimeType, codecs) {
  1267.   // If we are updating the manifest, we can usually skip fetching the segment
  1268.   // by examining the references we already have.  This won't be possible if
  1269.   // there was some kind of lag or delay updating the manifest on the server,
  1270.   // in which extreme case we would fall back to fetching a segment.  This
  1271.   // allows us to both avoid fetching segments when possible, and recover from
  1272.   // certain server-side issues gracefully.
  1273.   if (this.manifest_) {
  1274.     var streamInfo = this.uriToStreamInfosMap_[playlistUri];
  1275.     var segmentIndex = streamInfo.segmentIndex;
  1276.     var reference = segmentIndex.get(segmentRef.position);
  1277.     if (reference) {
  1278.       // We found it!  Avoid fetching and parsing the segment.
  1279.       shaka.log.v1('Found segment start time in previous manifest');
  1280.       return Promise.resolve(reference.startTime);
  1281.     }
  1283.     shaka.log.debug('Unable to find segment start time in previous manifest!');
  1284.   }
  1286.   // TODO: Introduce a new tag to extend HLS and provide the first segment's
  1287.   // start time.  This will avoid the need for these fetches in content packaged
  1288.   // with Shaka Packager.  This web-friendly extension to HLS can then be
  1289.   // proposed to Apple for inclusion in a future version of HLS.
  1290.   // See https://github.com/google/shaka-packager/issues/294
  1292.   shaka.log.v1('Fetching segment to find start time');
  1293.   return this.fetchPartialSegment_(segmentRef).then(function(response) {
  1294.     if (mimeType == 'video/mp4' || mimeType == 'audio/mp4') {
  1295.       return this.getStartTimeFromMp4Segment_(response.data);
  1296.     } else if (mimeType == 'video/mp2t') {
  1297.       return this.getStartTimeFromTsSegment_(response.data);
  1298.     } else if (mimeType == 'application/mp4' ||
  1299.                mimeType.indexOf('text/') == 0) {
  1300.       return this.getStartTimeFromTextSegment_(
  1301.           mimeType, codecs, response.data);
  1302.     } else {
  1303.       // TODO: Parse WebM?
  1304.       // TODO: Parse raw AAC?
  1305.       throw new shaka.util.Error(
  1306.           shaka.util.Error.Severity.CRITICAL,
  1307.           shaka.util.Error.Category.MANIFEST,
  1308.           shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1309.     }
  1310.   }.bind(this));
  1311. };
  1314. /**
  1315.  * Parses an mp4 segment to get its start time.
  1316.  *
  1317.  * @param {!ArrayBuffer} data
  1318.  * @return {number}
  1319.  * @throws {shaka.util.Error}
  1320.  * @private
  1321.  */
  1322. shaka.hls.HlsParser.prototype.getStartTimeFromMp4Segment_ = function(data) {
  1323.   var startTime = 0;
  1324.   var Mp4Parser = shaka.util.Mp4Parser;
  1325.   var parsed = false;
  1326.   new Mp4Parser()
  1327.       .box('moof', Mp4Parser.children)
  1328.       .box('traf', Mp4Parser.children)
  1329.       .fullBox('tfdt', function(box) {
  1330.         goog.asserts.assert(
  1331.             box.version == 0 || box.version == 1,
  1332.             'TFDT version can only be 0 or 1');
  1333.         var baseTime = (box.version == 0) ?
  1334.             box.reader.readUint32() :
  1335.             box.reader.readUint64();
  1336.         startTime = baseTime / shaka.hls.HlsParser.TS_TIMESCALE_;
  1337.         parsed = true;
  1338.         box.parser.stop();
  1339.       }).parse(data, true /* partialOkay */);
  1341.   if (!parsed) {
  1342.     throw new shaka.util.Error(
  1343.         shaka.util.Error.Severity.CRITICAL,
  1344.         shaka.util.Error.Category.MANIFEST,
  1345.         shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1346.   }
  1347.   return startTime;
  1348. };
  1351. /**
  1352.  * Parses a TS segment to get its start time.
  1353.  *
  1354.  * @param {!ArrayBuffer} data
  1355.  * @return {number}
  1356.  * @throws {shaka.util.Error}
  1357.  * @private
  1358.  */
  1359. shaka.hls.HlsParser.prototype.getStartTimeFromTsSegment_ = function(data) {
  1360.   var reader = new shaka.util.DataViewReader(
  1361.       new DataView(data), shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  1363.   var fail = function() {
  1364.     throw new shaka.util.Error(
  1365.         shaka.util.Error.Severity.CRITICAL,
  1366.         shaka.util.Error.Category.MANIFEST,
  1367.         shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME);
  1368.   };
  1370.   var packetStart = 0;
  1372.   var skipPacket = function() {
  1373.     // 188-byte packets are standard, so assume that.
  1374.     reader.seek(packetStart + 188);
  1375.     syncByte = reader.readUint8();
  1376.     if (syncByte != 0x47) {
  1377.       // We haven't found the sync byte, so try it as a 192-byte packet.
  1378.       reader.seek(packetStart + 192);
  1379.       syncByte = reader.readUint8();
  1380.     }
  1381.     if (syncByte != 0x47) {
  1382.       // We still haven't found the sync byte, so try as a 204-byte packet.
  1383.       reader.seek(packetStart + 204);
  1384.       syncByte = reader.readUint8();
  1385.     }
  1386.     if (syncByte != 0x47) {
  1387.       fail();
  1388.     }
  1389.     // Put the sync byte back so we can read it in the next loop.
  1390.     reader.rewind(1);
  1391.   };
  1393.   while (true) {
  1394.     // Format reference: https://goo.gl/wk6wwu
  1395.     packetStart = reader.getPosition();
  1397.     var syncByte = reader.readUint8();
  1398.     if (syncByte != 0x47) fail();
  1400.     var flagsAndPacketId = reader.readUint16();
  1401.     var hasPesPacket = flagsAndPacketId & 0x4000;
  1402.     if (!hasPesPacket) fail();
  1404.     var flags = reader.readUint8();
  1405.     var adaptationFieldControl = (flags & 0x30) >> 4;
  1406.     if (adaptationFieldControl == 0 /* reserved */ ||
  1407.         adaptationFieldControl == 2 /* adaptation field, no payload */) {
  1408.       fail();
  1409.     }
  1411.     if (adaptationFieldControl == 3) {
  1412.       // Skip over adaptation field.
  1413.       var length = reader.readUint8();
  1414.       reader.skip(length);
  1415.     }
  1417.     // Now we come to the PES header (hopefully).
  1418.     // Format reference: https://goo.gl/1166Mr
  1419.     var startCode = reader.readUint32();
  1420.     var startCodePrefix = startCode >> 8;
  1421.     if (startCodePrefix != 1) {
  1422.       // Not a PES packet yet.  Skip this TS packet and try again.
  1423.       skipPacket();
  1424.       continue;
  1425.     }
  1427.     // Skip the 16-bit PES length and the first 8 bits of the optional header.
  1428.     reader.skip(3);
  1429.     // The next 8 bits contain flags about DTS & PTS.
  1430.     var ptsDtsIndicator = reader.readUint8() >> 6;
  1431.     if (ptsDtsIndicator == 0 /* no timestamp */ ||
  1432.         ptsDtsIndicator == 1 /* forbidden */) {
  1433.       fail();
  1434.     }
  1436.     var pesHeaderLengthRemaining = reader.readUint8();
  1437.     if (pesHeaderLengthRemaining == 0) {
  1438.       fail();
  1439.     }
  1441.     if (ptsDtsIndicator == 2 /* PTS only */) {
  1442.       goog.asserts.assert(pesHeaderLengthRemaining == 5, 'Bad PES header?');
  1443.     } else if (ptsDtsIndicator == 3 /* PTS and DTS */) {
  1444.       goog.asserts.assert(pesHeaderLengthRemaining == 10, 'Bad PES header?');
  1445.     }
  1447.     var pts0 = reader.readUint8();
  1448.     var pts1 = reader.readUint16();
  1449.     var pts2 = reader.readUint16();
  1450.     // Reconstruct 33-bit PTS from the 5-byte, padded structure.
  1451.     var ptsHigh3 = (pts0 & 0x0e) >> 1;
  1452.     var ptsLow30 = ((pts1 & 0xfffe) << 14) | ((pts2 & 0xfffe) >> 1);
  1453.     // Reconstruct the PTS as a float.  Avoid bitwise operations to combine
  1454.     // because bitwise ops treat the values as 32-bit ints.
  1455.     var pts = ptsHigh3 * (1 << 30) + ptsLow30;
  1456.     return pts / shaka.hls.HlsParser.TS_TIMESCALE_;
  1457.   }
  1458. };
  1461. /**
  1462.  * Parses a text segment to get its start time.
  1463.  *
  1464.  * @param {string} mimeType
  1465.  * @param {string} codecs
  1466.  * @param {!ArrayBuffer} data
  1467.  * @return {number}
  1468.  * @throws {shaka.util.Error}
  1469.  * @private
  1470.  */
  1471. shaka.hls.HlsParser.prototype.getStartTimeFromTextSegment_ =
  1472.     function(mimeType, codecs, data) {
  1473.   var fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
  1474.   if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  1475.     // We won't be able to parse this, but it will be filtered out anyway.
  1476.     // So we don't have to care about the start time.
  1477.     return 0;
  1478.   }
  1480.   var textEngine = new shaka.text.TextEngine(/* displayer */ null);
  1481.   textEngine.initParser(fullMimeType);
  1482.   return textEngine.getStartTime(data);
  1483. };
  1486. /**
  1487.  * Attempts to guess which codecs from the codecs list belong to a given content
  1488.  * type.  Does not assume a single codec is anything special, and does not throw
  1489.  * if it fails to match.
  1490.  *
  1491.  * @param {!string} contentType
  1492.  * @param {!Array.<!string>} codecs
  1493.  * @return {?string} or null if no match is found
  1494.  * @private
  1495.  */
  1496. shaka.hls.HlsParser.prototype.guessCodecsSafe_ = function(contentType, codecs) {
  1497.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1498.   var HlsParser = shaka.hls.HlsParser;
  1499.   var formats = HlsParser.CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  1501.   for (var i = 0; i < formats.length; i++) {
  1502.     for (var j = 0; j < codecs.length; j++) {
  1503.       if (formats[i].test(codecs[j].trim())) {
  1504.         return codecs[j].trim();
  1505.       }
  1506.     }
  1507.   }
  1509.   // Text does not require a codec string.
  1510.   if (contentType == ContentType.TEXT) {
  1511.     return '';
  1512.   }
  1514.   return null;
  1515. };
  1518. /**
  1519.  * Attempts to guess which codecs from the codecs list belong to a given content
  1520.  * type.  Assumes a single codec is correct, and throws if not found.
  1521.  *
  1522.  * @param {!string} contentType
  1523.  * @param {!Array.<!string>} codecs
  1524.  * @return {string}
  1525.  * @private
  1526.  * @throws {shaka.util.Error}
  1527.  */
  1528. shaka.hls.HlsParser.prototype.guessCodecs_ = function(contentType, codecs) {
  1529.   if (codecs.length == 1) {
  1530.     return codecs[0];
  1531.   }
  1533.   var match = this.guessCodecsSafe_(contentType, codecs);
  1534.   if (match != null) {
  1535.     return match;
  1536.   }
  1538.   // Unable to guess codecs.
  1539.   throw new shaka.util.Error(
  1540.       shaka.util.Error.Severity.CRITICAL,
  1541.       shaka.util.Error.Category.MANIFEST,
  1542.       shaka.util.Error.Code.HLS_COULD_NOT_GUESS_CODECS,
  1543.       codecs);
  1544. };
  1547. /**
  1548.  * Attempts to guess stream's mime type based on content type and uri.
  1549.  *
  1550.  * @param {!string} contentType
  1551.  * @param {!string} codecs
  1552.  * @param {!shaka.hls.Playlist} playlist
  1553.  * @return {!Promise.<!string>}
  1554.  * @private
  1555.  * @throws {shaka.util.Error}
  1556.  */
  1557. shaka.hls.HlsParser.prototype.guessMimeType_ =
  1558.     function(contentType, codecs, playlist) {
  1559.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1560.   var HlsParser = shaka.hls.HlsParser;
  1561.   var Utils = shaka.hls.Utils;
  1563.   goog.asserts.assert(playlist.segments.length,
  1564.                       'Playlist should have segments!');
  1565.   var firstSegmentUri = Utils.constructAbsoluteUri(playlist.uri,
  1566.                                                    playlist.segments[0].uri);
  1568.   var parsedUri = new goog.Uri(firstSegmentUri);
  1569.   var extension = parsedUri.getPath().split('.').pop();
  1570.   var map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
  1572.   var mimeType = map[extension];
  1573.   if (mimeType)
  1574.     return Promise.resolve(mimeType);
  1576.   if (contentType == ContentType.TEXT) {
  1577.     // The extension map didn't work.
  1578.     if (!codecs || codecs == 'vtt') {
  1579.       // If codecs is 'vtt', it's WebVTT.
  1580.       // If there was no codecs string, assume HLS text streams are WebVTT.
  1581.       return Promise.resolve('text/vtt');
  1582.     } else {
  1583.       // Otherwise, assume MP4-embedded text, since text-based formats tend not
  1584.       // to have a codecs string at all.
  1585.       return Promise.resolve('application/mp4');
  1586.     }
  1587.   }
  1589.   // If unable to guess mime type, request a segment and try getting it
  1590.   // from the response.
  1591.   var headRequest = shaka.net.NetworkingEngine.makeRequest(
  1592.       [firstSegmentUri], this.config_.retryParameters);
  1593.   headRequest.method = 'HEAD';
  1594.   var requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1595.   var networkingEngine = this.playerInterface_.networkingEngine;
  1596.   return networkingEngine.request(requestType, headRequest)
  1597.       .then(function(response) {
  1598.         var mimeType = response.headers['content-type'];
  1599.         if (!mimeType) {
  1600.           throw new shaka.util.Error(
  1601.               shaka.util.Error.Severity.CRITICAL,
  1602.               shaka.util.Error.Category.MANIFEST,
  1603.               shaka.util.Error.Code.HLS_COULD_NOT_GUESS_MIME_TYPE,
  1604.               extension);
  1605.         }
  1607.         // Split the MIME type in case the server sent additional parameters.
  1608.         return mimeType.split(';')[0];
  1609.       });
  1610. };
  1613. /**
  1614.  * Find the attribute and returns its value.
  1615.  * Throws an error if attribute was not found.
  1616.  *
  1617.  * @param {shaka.hls.Tag} tag
  1618.  * @param {!string} attributeName
  1619.  * @return {!string}
  1620.  * @private
  1621.  * @throws {shaka.util.Error}
  1622.  */
  1623. shaka.hls.HlsParser.getRequiredAttributeValue_ =
  1624.     function(tag, attributeName) {
  1625.   var attribute = tag.getAttribute(attributeName);
  1626.   if (!attribute) {
  1627.     throw new shaka.util.Error(
  1628.         shaka.util.Error.Severity.CRITICAL,
  1629.         shaka.util.Error.Category.MANIFEST,
  1630.         shaka.util.Error.Code.HLS_REQUIRED_ATTRIBUTE_MISSING,
  1631.         attributeName);
  1632.   }
  1634.   return attribute.value;
  1635. };
  1638. /**
  1639.  * Returns a tag with a given name.
  1640.  * Throws an error if tag was not found.
  1641.  *
  1642.  * @param {!Array.<shaka.hls.Tag>} tags
  1643.  * @param {!string} tagName
  1644.  * @return {!shaka.hls.Tag}
  1645.  * @private
  1646.  * @throws {shaka.util.Error}
  1647.  */
  1648. shaka.hls.HlsParser.prototype.getRequiredTag_ = function(tags, tagName) {
  1649.   var Utils = shaka.hls.Utils;
  1650.   var tag = Utils.getFirstTagWithName(tags, tagName);
  1651.   if (!tag) {
  1652.     throw new shaka.util.Error(
  1653.         shaka.util.Error.Severity.CRITICAL,
  1654.         shaka.util.Error.Category.MANIFEST,
  1655.         shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, tagName);
  1656.   }
  1658.   return tag;
  1659. };
  1662. /**
  1663.  * @param {shakaExtern.Stream} stream
  1664.  * @param {?string} width
  1665.  * @param {?string} height
  1666.  * @param {?string} frameRate
  1667.  * @private
  1668.  */
  1669. shaka.hls.HlsParser.prototype.addVideoAttributes_ =
  1670.     function(stream, width, height, frameRate) {
  1671.   if (stream) {
  1672.     stream.width = Number(width) || undefined;
  1673.     stream.height = Number(height) || undefined;
  1674.     stream.frameRate = Number(frameRate) || undefined;
  1675.   }
  1676. };
  1679. /**
  1680.  * Makes a network request for the manifest and returns a Promise
  1681.  * with the resulting data.
  1682.  *
  1683.  * @param {!string} uri
  1684.  * @return {!Promise.<!shakaExtern.Response>}
  1685.  * @private
  1686.  */
  1687. shaka.hls.HlsParser.prototype.requestManifest_ = function(uri) {
  1688.   var requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  1689.   var request = shaka.net.NetworkingEngine.makeRequest(
  1690.       [uri], this.config_.retryParameters);
  1691.   var networkingEngine = this.playerInterface_.networkingEngine;
  1692.   var isCanceled = (function() {
  1693.     return !this.playerInterface_;
  1694.   }).bind(this);
  1695.   return networkingEngine.request(requestType, request, isCanceled);
  1696. };
  1699. /**
  1700.  * A list of regexps to detect well-known video codecs.
  1701.  *
  1702.  * @const {!Array.<!RegExp>}
  1703.  * @private
  1704.  */
  1705. shaka.hls.HlsParser.VIDEO_CODEC_REGEXPS_ = [
  1706.   /^avc/,
  1707.   /^hev/,
  1708.   /^hvc/,
  1709.   /^vp0?[89]/,
  1710.   /^av1$/
  1711. ];
  1714. /**
  1715.  * A list of regexps to detect well-known audio codecs.
  1716.  *
  1717.  * @const {!Array.<!RegExp>}
  1718.  * @private
  1719.  */
  1720. shaka.hls.HlsParser.AUDIO_CODEC_REGEXPS_ = [
  1721.   /^vorbis$/,
  1722.   /^opus$/,
  1723.   /^flac$/,
  1724.   /^mp4a/,
  1725.   /^[ae]c-3$/
  1726. ];
  1729. /**
  1730.  * A list of regexps to detect well-known text codecs.
  1731.  *
  1732.  * @const {!Array.<!RegExp>}
  1733.  * @private
  1734.  */
  1735. shaka.hls.HlsParser.TEXT_CODEC_REGEXPS_ = [
  1736.   /^vtt$/,
  1737.   /^wvtt/,
  1738.   /^stpp/
  1739. ];
  1742. /**
  1743.  * @const {!Object.<string, !Array.<!RegExp>>}
  1744.  * @private
  1745.  */
  1746. shaka.hls.HlsParser.CODEC_REGEXPS_BY_CONTENT_TYPE_ = {
  1747.   'audio': shaka.hls.HlsParser.AUDIO_CODEC_REGEXPS_,
  1748.   'video': shaka.hls.HlsParser.VIDEO_CODEC_REGEXPS_,
  1749.   'text': shaka.hls.HlsParser.TEXT_CODEC_REGEXPS_
  1750. };
  1753. /**
  1754.  * @const {!Object.<string, string>}
  1755.  * @private
  1756.  */
  1757. shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
  1758.   'mp4': 'audio/mp4',
  1759.   'm4s': 'audio/mp4',
  1760.   'm4i': 'audio/mp4',
  1761.   'm4a': 'audio/mp4',
  1762.   // mpeg2 ts aslo uses video/ for audio: http://goo.gl/tYHXiS
  1763.   'ts': 'video/mp2t'
  1764. };
  1767. /**
  1768.  * @const {!Object.<string, string>}
  1769.  * @private
  1770.  */
  1771. shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = {
  1772.   'mp4': 'video/mp4',
  1773.   'm4s': 'video/mp4',
  1774.   'm4i': 'video/mp4',
  1775.   'm4v': 'video/mp4',
  1776.   'ts': 'video/mp2t'
  1777. };
  1780. /**
  1781.  * @const {!Object.<string, string>}
  1782.  * @private
  1783.  */
  1784. shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_ = {
  1785.   'mp4': 'application/mp4',
  1786.   'm4s': 'application/mp4',
  1787.   'm4i': 'application/mp4',
  1788.   'vtt': 'text/vtt',
  1789.   'ttml': 'application/ttml+xml'
  1790. };
  1793. /**
  1794.  * @const {!Object.<string, !Object.<string, string>>}
  1795.  * @private
  1796.  */
  1797. shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_ = {
  1798.   'audio': shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_,
  1799.   'video': shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_,
  1800.   'text': shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_
  1801. };
  1804. /**
  1805.  * @typedef {function(!shaka.hls.Tag):?shakaExtern.DrmInfo}
  1806.  * @private
  1807.  */
  1808. shaka.hls.HlsParser.DrmParser_;
  1811. /**
  1812.  * @param {!shaka.hls.Tag} drmTag
  1813.  * @return {?shakaExtern.DrmInfo}
  1814.  * @private
  1815.  */
  1816. shaka.hls.HlsParser.widevineDrmParser_ = function(drmTag) {
  1817.   var HlsParser = shaka.hls.HlsParser;
  1818.   var method = HlsParser.getRequiredAttributeValue_(drmTag, 'METHOD');
  1819.   if (method != 'SAMPLE-AES-CENC') {
  1820.     shaka.log.error(
  1821.         'Widevine in HLS is only supported with SAMPLE-AES-CENC, not', method);
  1822.     return null;
  1823.   }
  1825.   var uri = HlsParser.getRequiredAttributeValue_(drmTag, 'URI');
  1826.   var parsedData = shaka.net.DataUriPlugin.parse(uri);
  1828.   // The data encoded in the URI is a PSSH box to be used as init data.
  1829.   var pssh = new Uint8Array(parsedData.data);
  1830.   var drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  1831.       'com.widevine.alpha', [
  1832.         {initDataType: 'cenc', initData: pssh}
  1833.       ]);
  1835.   var keyId = drmTag.getAttributeValue('KEYID');
  1836.   if (keyId) {
  1837.     // This value begins with '0x':
  1838.     goog.asserts.assert(keyId.substr(0, 2) == '0x',
  1839.                         'Incorrect KEYID format!');
  1840.     // But the output does not contain the '0x':
  1841.     drmInfo.keyIds = [keyId.substr(2).toLowerCase()];
  1842.   }
  1843.   return drmInfo;
  1844. };
  1847. /**
  1848.  * Called when the update timer ticks.
  1849.  *
  1850.  * @private
  1851.  */
  1852. shaka.hls.HlsParser.prototype.onUpdate_ = function() {
  1853.   goog.asserts.assert(this.updateTimer_, 'Should only be called by timer');
  1854.   goog.asserts.assert(this.updatePeriod_ != null,
  1855.                       'There should be an update period');
  1857.   shaka.log.info('Updating manifest...');
  1859.   // Detect a call to stop()
  1860.   if (!this.playerInterface_)
  1861.     return;
  1863.   this.updateTimer_ = null;
  1864.   this.update().then(function() {
  1865.     this.setUpdateTimer_(this.updatePeriod_);
  1866.   }.bind(this)).catch(function(error) {
  1867.     goog.asserts.assert(error instanceof shaka.util.Error,
  1868.                         'Should only receive a Shaka error');
  1870.     // Try updating again, but ensure we haven't been destroyed.
  1871.     if (this.playerInterface_) {
  1872.       // We will retry updating, so override the severity of the error.
  1873.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  1874.       this.playerInterface_.onError(error);
  1876.       this.setUpdateTimer_(0);
  1877.     }
  1878.   }.bind(this));
  1879. };
  1882. /**
  1883.  * Sets the update timer.
  1884.  *
  1885.  * @param {?number} time in seconds
  1886.  * @private
  1887.  */
  1888. shaka.hls.HlsParser.prototype.setUpdateTimer_ = function(time) {
  1889.   if (this.updatePeriod_ == null || time == null)
  1890.     return;
  1891.   goog.asserts.assert(this.updateTimer_ == null,
  1892.                       'Timer should not be already set');
  1894.   var callback = this.onUpdate_.bind(this);
  1895.   this.updateTimer_ = window.setTimeout(callback, time * 1000);
  1896. };
  1899. /**
  1900.  * @return {boolean}
  1901.  * @private
  1902.  */
  1903. shaka.hls.HlsParser.prototype.isLive_ = function() {
  1904.   var PresentationType = shaka.hls.HlsParser.PresentationType_;
  1905.   return this.presentationType_ != PresentationType.VOD;
  1906. };
  1909. /**
  1910.  * @param {shaka.hls.HlsParser.PresentationType_} type
  1911.  * @private
  1912.  */
  1913. shaka.hls.HlsParser.prototype.setPresentationType_ = function(type) {
  1914.   this.presentationType_ = type;
  1916.   if (this.presentationTimeline_)
  1917.     this.presentationTimeline_.setStatic(!this.isLive_());
  1919.   if (!this.isLive_()) {
  1920.     if (this.updateTimer_ != null) {
  1921.       window.clearTimeout(this.updateTimer_);
  1922.       this.updateTimer_ = null;
  1923.       this.updatePeriod_ = null;
  1924.     }
  1925.   }
  1926. };
  1929. /**
  1930.  * @const {!Object.<string, shaka.hls.HlsParser.DrmParser_>}
  1931.  * @private
  1932.  */
  1933. shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
  1934.   /* TODO: https://github.com/google/shaka-player/issues/382
  1935.   'com.apple.streamingkeydelivery':
  1936.       shaka.hls.HlsParser.fairplayDrmParser_,
  1937.   */
  1938.   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
  1939.       shaka.hls.HlsParser.widevineDrmParser_
  1940. };
  1943. /**
  1944.  * @enum {string}
  1945.  * @private
  1946.  */
  1947. shaka.hls.HlsParser.PresentationType_ = {
  1948.   VOD: 'VOD',
  1949.   EVENT: 'EVENT',
  1950.   LIVE: 'LIVE'
  1951. };
  1954. /**
  1955.  * @const {number}
  1956.  * @private
  1957.  */
  1958. shaka.hls.HlsParser.TS_TIMESCALE_ = 90000;
  1959. // TODO: Consider extracting this from the MP4 instead of assuming a
  1960. // TS-compatible timescale in fMP4 HLS content.
  1963. /**
  1964.  * The amount of data from the start of a segment we will try to fetch when we
  1965.  * need to know the segment start time.  This allows us to avoid fetching the
  1966.  * entire segment in many cases.
  1967.  *
  1968.  * @const {number}
  1969.  * @private
  1970.  */
  1971. shaka.hls.HlsParser.PARTIAL_SEGMENT_SIZE_ = 2048;
  1974. shaka.media.ManifestParser.registerParserByExtension(
  1975.     'm3u8', shaka.hls.HlsParser);
  1976. shaka.media.ManifestParser.registerParserByMime(
  1977.     'application/x-mpegurl', shaka.hls.HlsParser);
  1978. shaka.media.ManifestParser.registerParserByMime(
  1979.     'application/vnd.apple.mpegurl', shaka.hls.HlsParser);