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.asserts');
  22. goog.require('shaka.hls.ManifestTextParser');
  23. goog.require('shaka.hls.Playlist');
  24. goog.require('shaka.hls.PlaylistType');
  25. goog.require('shaka.hls.Tag');
  26. goog.require('shaka.hls.Utils');
  27. goog.require('shaka.log');
  28. goog.require('shaka.media.DrmEngine');
  29. goog.require('shaka.media.InitSegmentReference');
  30. goog.require('shaka.media.ManifestParser');
  31. goog.require('shaka.media.PresentationTimeline');
  32. goog.require('shaka.media.SegmentIndex');
  33. goog.require('shaka.media.SegmentReference');
  34. goog.require('shaka.net.DataUriPlugin');
  35. goog.require('shaka.net.NetworkingEngine');
  36. goog.require('shaka.util.Error');
  37. goog.require('shaka.util.Functional');
  38. goog.require('shaka.util.ManifestParserUtils');
  42. /**
  43.  * Creates a new HLS parser.
  44.  *
  45.  * @struct
  46.  * @constructor
  47.  * @implements {shakaExtern.ManifestParser}
  48.  * @export
  49.  */
  50. shaka.hls.HlsParser = function() {
  51.   /** @private {?shakaExtern.ManifestParser.PlayerInterface} */
  52.   this.playerInterface_ = null;
  54.   /** @private {?shakaExtern.ManifestConfiguration} */
  55.   this.config_ = null;
  57.   /** @private {number} */
  58.   this.globalId_ = 1;
  60.   /** @private {!Object.<number, shaka.hls.HlsParser.StreamInfo>} */
  61.   this.mediaTagsToStreamInfosMap_ = {};
  63.   /** @private {!Object.<number, !shaka.media.SegmentIndex>} */
  64.   this.streamsToIndexMap_ = {};
  66.   /**
  67.    * A map from media playlists' uris to stream infos
  68.    * representing the playlists.
  69.    * @private {!Object.<string, shaka.hls.HlsParser.StreamInfo>}
  70.    */
  71.   this.uriToStreamInfosMap_ = {};
  73.   /** @private {?shaka.media.PresentationTimeline} */
  74.   this.presentationTimeline_ = null;
  76.   /** @private {string} */
  77.   this.manifestUri_ = '';
  79.   /** @private {shaka.hls.ManifestTextParser} */
  80.   this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
  82.   /**
  83.    * The update period in seconds; or null for no updates.
  84.    * @private {?number}
  85.    */
  86.   this.updatePeriod_ = null;
  88.   /** @private {?number} */
  89.   this.updateTimer_ = null;
  91.   /** @private {boolean} */
  92.   this.isLive_ = false;
  94.   /** @private {?shakaExtern.Manifest} */
  95.   this.manifest_ = null;
  97.   /** @private {number} */
  98.   this.maxTargetDuration_ = 0;
  99. };
  102. /**
  103.  * @typedef {{
  104.  *   stream: !shakaExtern.Stream,
  105.  *   segmentIndex: !shaka.media.SegmentIndex,
  106.  *   drmInfos: !Array.<shakaExtern.DrmInfo>,
  107.  *   relativeUri: !string,
  108.  *   lastSegmentSeen: !shaka.media.SegmentReference
  109.  * }}
  110.  *
  111.  * @description
  112.  * Contains a stream and information about it.
  113.  *
  114.  * @property {!shakaExtern.Stream} stream
  115.  *   The Stream itself.
  116.  * @property {!shaka.media.SegmentIndex} segmentIndex
  117.  *   SegmentIndex of the stream.
  118.  * @property {!Array.<shakaExtern.DrmInfo>} drmInfos
  119.  *   DrmInfos of the stream.  There may be multiple for multi-DRM content.
  120.  * @property {!string} relativeUri
  121.  *   The uri associated with the stream, relative to the manifest.
  122.  * @property {!shaka.media.SegmentReference} lastSegmentSeen
  123.  *   Last segment of the stream seen so far.
  124.  */
  125. shaka.hls.HlsParser.StreamInfo;
  128. /**
  129.  * @override
  130.  * @exportInterface
  131.  */
  132. shaka.hls.HlsParser.prototype.configure = function(config) {
  133.   this.config_ = config;
  134. };
  137. /**
  138.  * @override
  139.  * @exportInterface
  140.  */
  141. shaka.hls.HlsParser.prototype.start = function(uri, playerInterface) {
  142.   goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  143.   this.playerInterface_ = playerInterface;
  144.   this.manifestUri_ = uri;
  145.   return this.requestManifest_(uri).then(function(response) {
  146.     return this.parseManifest_(response.data, uri).then(function() {
  147.       this.setUpdateTimer_(this.updatePeriod_);
  148.       return this.manifest_;
  149.     }.bind(this));
  150.   }.bind(this));
  151. };
  154. /**
  155.  * @override
  156.  * @exportInterface
  157.  */
  158. shaka.hls.HlsParser.prototype.stop = function() {
  159.   this.playerInterface_ = null;
  160.   this.config_ = null;
  161.   this.mediaTagsToStreamInfosMap_ = {};
  162.   this.manifest_ = null;
  164.   return Promise.resolve();
  165. };
  168. /**
  169.  * @override
  170.  * @exportInterface
  171.  */
  172. shaka.hls.HlsParser.prototype.update = function() {
  173.   if (!this.isLive_)
  174.     return;
  176.   var promises = [];
  177.   var uris = Object.keys(this.uriToStreamInfosMap_);
  178.   for (var i = 0; i < uris.length; i++) {
  179.     var uri = uris[i];
  180.     var streamInfo = this.uriToStreamInfosMap_[uri];
  182.     promises.push(this.updateStream_(streamInfo, uri));
  183.   }
  185.   return Promise.all(promises);
  186. };
  189. /**
  190.  * Updates a stream.
  191.  *
  192.  * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  193.  * @param {string} uri
  194.  * @throws shaka.util.Error
  195.  * @private
  196.  */
  197. shaka.hls.HlsParser.prototype.updateStream_ = function(streamInfo, uri) {
  198.   this.requestManifest_(uri).then(function(response) {
  199.     var Utils = shaka.hls.Utils;
  200.     var playlistData = response.data;
  201.     var playlist = this.manifestTextParser_.parsePlaylist(playlistData,
  202.                                                           response.uri);
  203.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  204.       throw new shaka.util.Error(
  205.           shaka.util.Error.Severity.CRITICAL,
  206.           shaka.util.Error.Category.MANIFEST,
  207.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  208.     }
  210.     var mediaSequenceTag = Utils.getFirstTagWithName(playlist.tags,
  211.                                                      'EXT-X-MEDIA-SEQUENCE');
  213.     var startPosition = mediaSequenceTag ? Number(mediaSequenceTag.value) : 0;
  215.     var segments = this.createSegments_(playlist, startPosition);
  216.     segments = this.adjustSegments_(segments, streamInfo.lastSegmentSeen);
  217.     streamInfo.segmentIndex.merge(segments);
  218.     if (segments.length)
  219.       streamInfo.lastSegmentSeen = segments[segments.length - 1];
  221.     // Once the last segment has been added to the playlist, #EXT-X-ENDLIST tag
  222.     // will be appended. If that happened, treat the rest of the presentation
  223.     // as VOD.
  224.     var endlistTag = Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  225.     if (endlistTag) {
  226.       goog.asserts.assert(streamInfo.lastSegmentSeen != null,
  227.                           'Should not be null!');
  228.       var endTime = streamInfo.lastSegmentSeen.endTime;
  229.       this.setLive_(false);
  230.       this.presentationTimeline_.setDuration(endTime);
  231.     }
  232.   }.bind(this));
  233. };
  236. /**
  237.  * The manifest doesn't specify segments' start and end times.
  238.  * We assume the first segment starts at 0 and base the following
  239.  * segments on this assumption (each segment's starts when previous ends).
  240.  * This method adjusts new segments' (added on update) timeline with
  241.  * respect to previously appended segments.
  242.  *
  243.  * @param {!Array.<!shaka.media.SegmentReference>} segments
  244.  * @param {!shaka.media.SegmentReference} lastSegmentSeen
  245.  * @return {!Array.<!shaka.media.SegmentReference>}
  246.  * @private
  247.  */
  248. shaka.hls.HlsParser.prototype.adjustSegments_ =
  249.     function(segments, lastSegmentSeen) {
  250.   var adjusted = [];
  252.   var offset = lastSegmentSeen.endTime;
  253.   for (var i = 0; i < segments.length; i++) {
  254.     var segment = segments[i];
  255.     if (segment.position > lastSegmentSeen.position) {
  256.       var duration = segment.endTime - segment.startTime;
  257.       var startTime = offset;
  258.       var endTime = offset + duration;
  259.       offset += duration;
  261.       var adjustedSegment =
  262.           new shaka.media.SegmentReference(segment.position,
  263.                                            startTime,
  264.                                            endTime,
  265.                                            segment.getUris,
  266.                                            segment.startByte,
  267.                                            segment.endByte);
  268.       adjusted.push(adjustedSegment);
  269.     }
  270.   }
  272.   return adjusted;
  273. };
  276. /**
  277.  * @override
  278.  * @exportInterface
  279.  */
  280. shaka.hls.HlsParser.prototype.onExpirationUpdated = function(
  281.     sessionId, expiration) {
  282.   // No-op
  283. };
  286. /**
  287.  * Parses the manifest.
  288.  *
  289.  * @param {!ArrayBuffer} data
  290.  * @param {string} uri
  291.  * @throws shaka.util.Error When there is a parsing error.
  292.  * @return {!Promise}
  293.  * @private
  294.  */
  295. shaka.hls.HlsParser.prototype.parseManifest_ = function(data, uri) {
  296.   var playlist = this.manifestTextParser_.parsePlaylist(data, uri);
  298.   // We don't support directly providing a Media Playlist.
  299.   // See error code for details.
  300.   if (playlist.type != shaka.hls.PlaylistType.MASTER) {
  301.     throw new shaka.util.Error(
  302.         shaka.util.Error.Severity.CRITICAL,
  303.         shaka.util.Error.Category.MANIFEST,
  304.         shaka.util.Error.Code.HLS_MASTER_PLAYLIST_NOT_PROVIDED);
  305.   }
  307.   return this.createPeriod_(playlist).then(function(period) {
  308.     // HLS has no notion of periods. We're treating the whole presentation as
  309.     // one period.
  310.     this.playerInterface_.filterAllPeriods([period]);
  312.     // Update presentationDelay with the largest target duration
  313.     // across all variants.
  314.     if (this.isLive_)
  315.       this.presentationTimeline_.setDelay(this.maxTargetDuration_ * 3);
  317.     goog.asserts.assert(this.presentationTimeline_ != null,
  318.                         'presentationTimeline should already be created!');
  320.     this.manifest_ = {
  321.       presentationTimeline: this.presentationTimeline_,
  322.       periods: [period],
  323.       offlineSessionIds: [],
  324.       minBufferTime: 0
  325.     };
  326.   }.bind(this));
  327. };
  330. /**
  331.  * Parses a playlist into a Period object.
  332.  *
  333.  * @param {!shaka.hls.Playlist} playlist
  334.  * @return {!Promise.<!shakaExtern.Period>}
  335.  * @private
  336.  */
  337. shaka.hls.HlsParser.prototype.createPeriod_ = function(playlist) {
  338.   var Utils = shaka.hls.Utils;
  339.   var Functional = shaka.util.Functional;
  340.   var tags = playlist.tags;
  342.   // Create Variants for every 'EXT-X-STREAM-INF' tag.
  343.   var variantTags = Utils.filterTagsByName(tags, 'EXT-X-STREAM-INF');
  344.   var variantsPromises = variantTags.map(function(tag) {
  345.     return this.createVariantsForTag_(tag, playlist);
  346.   }.bind(this));
  348.   var mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
  349.   var textStreamTags = mediaTags.filter(function(tag) {
  350.     var type = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  351.     return type == 'SUBTITLES';
  352.   }.bind(this));
  354.   // TODO: CLOSED-CAPTIONS requires the parsing of CEA-608 from the video.
  355.   var textStreamPromises = textStreamTags.map(function(tag) {
  356.     return this.createTextStream_(tag, playlist);
  357.   }.bind(this));
  359.   return Promise.all(variantsPromises).then(function(allVariants) {
  360.     return Promise.all(textStreamPromises).then(function(textStreams) {
  361.       var variants = allVariants.reduce(Functional.collapseArrays, []);
  362.       if (!this.isLive_)
  363.         this.fitSegments_(variants);
  364.       return {
  365.         startTime: 0,
  366.         variants: variants,
  367.         textStreams: textStreams
  368.       };
  369.     }.bind(this));
  370.   }.bind(this));
  371. };
  374. /**
  375.  * @param {!shaka.hls.Tag} tag
  376.  * @param {!shaka.hls.Playlist} playlist
  377.  * @return {!Promise.<!Array.<!shakaExtern.Variant>>}
  378.  * @private
  379.  */
  380. shaka.hls.HlsParser.prototype.createVariantsForTag_ = function(tag, playlist) {
  381.   goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  382.                       'Should only be called on variant tags!');
  383.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  384.   var HlsParser = shaka.hls.HlsParser;
  385.   var Utils = shaka.hls.Utils;
  386.   var bandwidth =
  387.       Number(HlsParser.getRequiredAttributeValue_(tag, 'BANDWIDTH'));
  389.   // These are the default codecs to assume if none are specified.
  390.   //
  391.   // The video codec is H.264, with baseline profile and level 3.0.
  392.   // http://blog.pearce.org.nz/2013/11/what-does-h264avc1-codecs-parameters.html
  393.   //
  394.   // The audio codec is "low-complexity" AAC.
  395.   var defaultCodecs = 'avc1.42E01E,mp4a.40.2';
  397.   /** @type {!Array.<string>} */
  398.   var codecs = tag.getAttributeValue('CODECS', defaultCodecs).split(',');
  399.   var resolutionAttr = tag.getAttribute('RESOLUTION');
  400.   var width = null;
  401.   var height = null;
  402.   var frameRate = tag.getAttributeValue('FRAME-RATE');
  404.   if (resolutionAttr) {
  405.     var resBlocks = resolutionAttr.value.split('x');
  406.     width = resBlocks[0];
  407.     height = resBlocks[1];
  408.   }
  410.   var timeOffset = this.getTimeOffset_(playlist);
  412.   var mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
  414.   var audioGroupId = tag.getAttributeValue('AUDIO');
  415.   var videoGroupId = tag.getAttributeValue('VIDEO');
  416.   goog.asserts.assert(audioGroupId == null || videoGroupId == null,
  417.       'Unexpected: both video and audio described by media tags!');
  419.   // Find any associated audio or video groups and create streams for them.
  420.   if (audioGroupId) {
  421.     mediaTags = Utils.findMediaTags(mediaTags, 'AUDIO', audioGroupId);
  422.   } else if (videoGroupId) {
  423.     mediaTags = Utils.findMediaTags(mediaTags, 'VIDEO', videoGroupId);
  424.   }
  425.   var promises = mediaTags.map(function(tag) {
  426.     return this.createStreamInfoFromMediaTag_(tag, codecs, timeOffset);
  427.   }.bind(this));
  429.   var audioStreamInfos = [];
  430.   var videoStreamInfos = [];
  432.   return Promise.all(promises).then(function(data) {
  433.     if (audioGroupId) {
  434.       audioStreamInfos = data;
  435.     } else if (videoGroupId) {
  436.       videoStreamInfos = data;
  437.     }
  439.     // Make an educated guess about the stream type.
  440.     shaka.log.debug('Guessing stream type for', tag.toString());
  441.     var type;
  442.     if (!audioStreamInfos.length && !videoStreamInfos.length) {
  443.       // There are no associated streams.  This is either an audio-only stream,
  444.       // a video-only stream, or a multiplexed stream.
  445.       var ignoreStream = false;
  447.       if (codecs.length == 1) {
  448.         // There is only one codec, so it shouldn't be multiplexed.
  449.         if (resolutionAttr || frameRate) {
  450.           // Assume video-only.
  451.           shaka.log.debug('Guessing video-only.');
  452.           type = ContentType.VIDEO;
  453.         } else {
  454.           // Assume audio-only.
  455.           shaka.log.debug('Guessing audio-only.');
  456.           type = ContentType.AUDIO;
  457.         }
  458.       } else {
  459.         // There are multiple codecs, so assume multiplexed content.
  460.         // Note that the default used when CODECS is missing assumes multiple
  461.         // (and therefore multiplexed).
  462.         // Recombine the codec strings into one so that MediaSource isn't
  463.         // lied to later.  (That would trigger an error in Chrome.)
  464.         shaka.log.debug('Guessing multiplexed audio+video.');
  465.         type = ContentType.VIDEO;
  466.         codecs = [codecs.join(',')];
  467.       }
  468.     } else if (audioStreamInfos.length) {
  469.       var streamURI = HlsParser.getRequiredAttributeValue_(tag, 'URI');
  470.       var firstAudioStreamURI = audioStreamInfos[0].relativeUri;
  471.       if (streamURI == firstAudioStreamURI) {
  472.         // The Microsoft HLS manifest generators will make audio-only variants
  473.         // that link to their URI both directly and through an audio tag.
  474.         // In that case, ignore the local URI and use the version in the
  475.         // AUDIO tag, so you inherit its language.
  476.         // As an example, see the manifest linked in issue #860.
  477.         shaka.log.debug('Guessing audio-only.');
  478.         type = ContentType.AUDIO;
  479.         ignoreStream = true;
  480.       } else {
  481.         // There are associated audio streams.  Assume this is video.
  482.         shaka.log.debug('Guessing video.');
  483.         type = ContentType.VIDEO;
  484.       }
  485.     } else {
  486.       // There are associated video streams.  Assume this is audio.
  487.       goog.asserts.assert(videoStreamInfos.length,
  488.           'No video streams!  This should have been handled already!');
  489.       shaka.log.debug('Guessing audio.');
  490.       type = ContentType.AUDIO;
  491.     }
  493.     goog.asserts.assert(type, 'Type should have been set by now!');
  494.     if (ignoreStream)
  495.       return Promise.resolve();
  496.     return this.createStreamInfoFromVariantTag_(tag, codecs, type, timeOffset);
  497.   }.bind(this)).then(function(streamInfo) {
  498.     if (streamInfo) {
  499.       if (streamInfo.stream.type == ContentType.AUDIO) {
  500.         audioStreamInfos = [streamInfo];
  501.       } else {
  502.         videoStreamInfos = [streamInfo];
  503.       }
  504.     }
  505.     goog.asserts.assert(videoStreamInfos || audioStreamInfos,
  506.         'We should have created a stream!');
  508.     return this.createVariants_(
  509.         audioStreamInfos,
  510.         videoStreamInfos,
  511.         bandwidth,
  512.         width,
  513.         height,
  514.         frameRate);
  515.   }.bind(this));
  516. };
  519. /**
  520.  * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} audioInfos
  521.  * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} videoInfos
  522.  * @param {number} bandwidth
  523.  * @param {?string} width
  524.  * @param {?string} height
  525.  * @param {?string} frameRate
  526.  * @return {!Array.<!shakaExtern.Variant>}
  527.  * @private
  528.  */
  529. shaka.hls.HlsParser.prototype.createVariants_ =
  530.     function(audioInfos, videoInfos, bandwidth, width, height, frameRate) {
  531.   var DrmEngine = shaka.media.DrmEngine;
  533.   videoInfos.forEach(function(info) {
  534.     this.addVideoAttributes_(info.stream, width, height, frameRate);
  535.   }.bind(this));
  537.   // In case of audio-only or video-only content, we create an array of
  538.   // one item containing a null. This way, the double-loop works for all
  539.   // kinds of content.
  540.   // NOTE: we currently don't have support for audio-only content.
  541.   if (!audioInfos.length)
  542.     audioInfos = [null];
  543.   if (!videoInfos.length)
  544.     videoInfos = [null];
  546.   var variants = [];
  547.   for (var i = 0; i < audioInfos.length; i++) {
  548.     for (var j = 0; j < videoInfos.length; j++) {
  549.       var audioStream = audioInfos[i] ? audioInfos[i].stream : null;
  550.       var videoStream = videoInfos[j] ? videoInfos[j].stream : null;
  551.       var audioDrmInfos = audioInfos[i] ? audioInfos[i].drmInfos : null;
  552.       var videoDrmInfos = videoInfos[j] ? videoInfos[j].drmInfos : null;
  554.       var drmInfos;
  555.       if (audioStream && videoStream) {
  556.         if (DrmEngine.areDrmCompatible(audioDrmInfos, videoDrmInfos)) {
  557.           drmInfos = DrmEngine.getCommonDrmInfos(audioDrmInfos, videoDrmInfos);
  558.         } else {
  559.           shaka.log.warning('Incompatible DRM info in HLS variant.  Skipping.');
  560.           continue;
  561.         }
  562.       } else if (audioStream) {
  563.         drmInfos = audioDrmInfos;
  564.       } else if (videoStream) {
  565.         drmInfos = videoDrmInfos;
  566.       }
  568.       variants.push(this.createVariant_(
  569.           audioStream, videoStream, bandwidth, drmInfos));
  570.     }
  571.   }
  572.   return variants;
  573. };
  576. /**
  577.  * @param {shakaExtern.Stream} audio
  578.  * @param {shakaExtern.Stream} video
  579.  * @param {number} bandwidth
  580.  * @param {!Array.<shakaExtern.DrmInfo>} drmInfos
  581.  * @return {!shakaExtern.Variant}
  582.  * @private
  583.  */
  584. shaka.hls.HlsParser.prototype.createVariant_ =
  585.     function(audio, video, bandwidth, drmInfos) {
  586.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  588.   // Since both audio and video are of the same type, this assertion will catch
  589.   // certain mistakes at runtime that the compiler would miss.
  590.   goog.asserts.assert(!audio || audio.type == ContentType.AUDIO,
  591.                       'Audio parameter mismatch!');
  592.   goog.asserts.assert(!video || video.type == ContentType.VIDEO,
  593.                       'Video parameter mismatch!');
  595.   return {
  596.     id: this.globalId_++,
  597.     language: audio ? audio.language : 'und',
  598.     primary: (!!audio && audio.primary) || (!!video && video.primary),
  599.     audio: audio,
  600.     video: video,
  601.     bandwidth: bandwidth,
  602.     drmInfos: drmInfos,
  603.     allowedByApplication: true,
  604.     allowedByKeySystem: true
  605.   };
  606. };
  609. /**
  610.  * Parses an EXT-X-MEDIA tag with TYPE="SUBTITLES" into a text stream.
  611.  *
  612.  * @param {!shaka.hls.Tag} tag
  613.  * @param {!shaka.hls.Playlist} playlist
  614.  * @return {!Promise.<?shakaExtern.Stream>}
  615.  * @private
  616.  */
  617. shaka.hls.HlsParser.prototype.createTextStream_ = function(tag, playlist) {
  618.   goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  619.                       'Should only be called on media tags!');
  621.   var type = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'TYPE');
  622.   goog.asserts.assert(type == 'SUBTITLES',
  623.                       'Should only be called on tags with TYPE="SUBTITLES"!');
  625.   var timeOffset = this.getTimeOffset_(playlist);
  626.   return this.createStreamInfoFromMediaTag_(tag, [], timeOffset)
  627.     .then(function(streamInfo) {
  628.         return streamInfo.stream;
  629.       });
  630. };
  633. /**
  634.  * Parse EXT-X-MEDIA media tag into a Stream object.
  635.  *
  636.  * @param {shaka.hls.Tag} tag
  637.  * @param {!Array.<!string>} allCodecs
  638.  * @param {?number} timeOffset
  639.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  640.  * @private
  641.  */
  642. shaka.hls.HlsParser.prototype.createStreamInfoFromMediaTag_ =
  643.     function(tag, allCodecs, timeOffset) {
  644.   goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  645.                       'Should only be called on media tags!');
  647.   // Check if the stream has already been created as part of another Variant
  648.   // and return it if it has.
  649.   if (this.mediaTagsToStreamInfosMap_[tag.id]) {
  650.     return Promise.resolve().then(function() {
  651.       return this.mediaTagsToStreamInfosMap_[tag.id];
  652.     }.bind(this));
  653.   }
  655.   var HlsParser = shaka.hls.HlsParser;
  656.   var type = HlsParser.getRequiredAttributeValue_(tag, 'TYPE').toLowerCase();
  657.   // Shaka recognizes content types 'audio', 'video' and 'text'.
  658.   // HLS 'subtitles' type needs to be mapped to 'text'.
  659.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  660.   if (type == 'subtitles') type = ContentType.TEXT;
  662.   var LanguageUtils = shaka.util.LanguageUtils;
  663.   var language = LanguageUtils.normalize(/** @type {string} */(
  664.       tag.getAttributeValue('LANGUAGE', 'und')));
  665.   var label = tag.getAttributeValue('NAME');
  667.   var defaultAttr = tag.getAttribute('DEFAULT');
  668.   var autoselectAttr = tag.getAttribute('AUTOSELECT');
  669.   // TODO: Should we take into account some of the currently ignored attributes:
  670.   // FORCED, INSTREAM-ID, CHARACTERISTICS, CHANNELS?
  671.   // Attribute descriptions:
  672.   // https://tools.ietf.org/html/draft-pantos-http-live-streaming-20#section-4.3.4.1
  673.   var channelsAttribute = tag.getAttributeValue('CHANNELS');
  674.   var channelsCount = type == 'audio' ?
  675.       this.getChannelsCount_(channelsAttribute) : null;
  676.   var uri = HlsParser.getRequiredAttributeValue_(tag, 'URI');
  677.   uri = shaka.hls.Utils.constructAbsoluteUri(this.manifestUri_, uri);
  678.   var primary = !!defaultAttr || !!autoselectAttr;
  679.   return this.createStreamInfo_(uri, allCodecs, type, timeOffset,
  680.       language, primary, label, channelsCount).then(function(streamInfo) {
  681.     this.mediaTagsToStreamInfosMap_[tag.id] = streamInfo;
  682.     this.uriToStreamInfosMap_[uri] = streamInfo;
  683.     return streamInfo;
  684.   }.bind(this));
  685. };
  688. /**
  689.  * Get the channels count information for HLS audio track.
  690.  * The channels value is a string that specifies an ordered, "/" separated list
  691.  * of parameters. If the type is audio, the first parameter will be a decimal
  692.  * integer, as the number of independent, simultaneous audio channels.
  693.  * No other channels parameters are currently defined.
  694.  *
  695.  * @param {?string} channels
  696.  *
  697.  * @return {?number} channelcount
  698.  * @private
  699.  */
  700. shaka.hls.HlsParser.prototype.getChannelsCount_ = function(channels) {
  701.   if (!channels) return null;
  702.   var channelscountstring = channels.split('/')[0];
  703.   var count = parseInt(channelscountstring, 10);
  704.   return count;
  705. };
  708. /**
  709.  * Parse EXT-X-STREAM-INF media tag into a Stream object.
  710.  *
  711.  * @param {!shaka.hls.Tag} tag
  712.  * @param {!Array.<!string>} allCodecs
  713.  * @param {!string} type
  714.  * @param {?number} timeOffset
  715.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  716.  * @private
  717.  */
  718. shaka.hls.HlsParser.prototype.createStreamInfoFromVariantTag_ =
  719.     function(tag, allCodecs, type, timeOffset) {
  720.   goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  721.                       'Should only be called on media tags!');
  723.   var uri = shaka.hls.HlsParser.getRequiredAttributeValue_(tag, 'URI');
  724.   uri = shaka.hls.Utils.constructAbsoluteUri(this.manifestUri_, uri);
  725.   return this.createStreamInfo_(uri, allCodecs, type, timeOffset,
  726.                                 /* language */ 'und', /* primary */ false,
  727.                                 /* label */ null, /* channelcount */ null).then(
  728.       function(streamInfo) {
  729.         this.uriToStreamInfosMap_[uri] = streamInfo;
  730.         return streamInfo;
  731.       }.bind(this));
  732. };
  735. /**
  736.  * @param {!string} uri
  737.  * @param {!Array.<!string>} allCodecs
  738.  * @param {!string} type
  739.  * @param {?number} timeOffset
  740.  * @param {!string} language
  741.  * @param {boolean} primary
  742.  * @param {?string} label
  743.  * @param {?number} channelsCount
  744.  * @return {!Promise.<shaka.hls.HlsParser.StreamInfo>}
  745.  * @throws shaka.util.Error
  746.  * @private
  747.  */
  748. shaka.hls.HlsParser.prototype.createStreamInfo_ = function(uri, allCodecs,
  749.     type, timeOffset, language, primary, label, channelsCount) {
  750.   var Utils = shaka.hls.Utils;
  751.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  752.   var HlsParser = shaka.hls.HlsParser;
  753.   var relativeUri = uri;
  754.   uri = Utils.constructAbsoluteUri(this.manifestUri_, uri);
  756.   return this.requestManifest_(uri).then(function(response) {
  757.     var playlistData = response.data;
  758.     var playlist = this.manifestTextParser_.parsePlaylist(playlistData,
  759.                                                           response.uri);
  760.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  761.       // EXT-X-MEDIA tags should point to media playlists.
  762.       throw new shaka.util.Error(
  763.           shaka.util.Error.Severity.CRITICAL,
  764.           shaka.util.Error.Category.MANIFEST,
  765.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  766.     }
  768.     goog.asserts.assert(playlist.segments != null,
  769.                         'Media playlist should have segments!');
  771.     var mediaSequenceTag = Utils.getFirstTagWithName(playlist.tags,
  772.                                                      'EXT-X-MEDIA-SEQUENCE');
  774.     var startPosition = mediaSequenceTag ? Number(mediaSequenceTag.value) : 0;
  775.     var segments = this.createSegments_(playlist, startPosition);
  777.     var segmentIndex = new shaka.media.SegmentIndex(segments);
  779.     this.setPresentationType_(playlist);
  781.     if (!this.presentationTimeline_) {
  782.       // The presentation started last available segment's end time ago.
  783.       // All variants should be in sync in terms of timeline, so just grab
  784.       // this from an arbitrary stream.
  785.       this.createPresentationTimeline_(segments[segments.length - 1].endTime);
  786.     }
  789.     // Time offset can be specified on either Master or Media Playlist.
  790.     // If Media Playlist provides it's own value, use that.
  791.     // Otherwise, use value from the Master Playlist. If no offset
  792.     // has been provided it will default to
  793.     // this.config_.hls.defaultTimeOffset.
  794.     var mediaPlaylistTimeOffset = this.getTimeOffset_(playlist);
  795.     timeOffset = mediaPlaylistTimeOffset || timeOffset;
  797.     var initSegmentReference = null;
  798.     if (type != ContentType.TEXT) {
  799.       initSegmentReference = this.createInitSegmentReference_(playlist);
  800.     }
  802.     this.presentationTimeline_.notifySegments(0, segments);
  804.     if (!this.isLive_) {
  805.       var duration =
  806.           segments[segments.length - 1].endTime - segments[0].startTime;
  807.       var presentationDuration = this.presentationTimeline_.getDuration();
  808.       if (presentationDuration == Infinity || presentationDuration < duration) {
  809.         this.presentationTimeline_.setDuration(duration);
  810.       }
  811.     }
  813.     var codecs = this.guessCodecs_(type, allCodecs);
  815.     var kind = undefined;
  817.     var ManifestParserUtils = shaka.util.ManifestParserUtils;
  818.     if (type == ManifestParserUtils.ContentType.TEXT)
  819.       kind = ManifestParserUtils.TextStreamKind.SUBTITLE;
  820.     // TODO: CLOSED-CAPTIONS requires the parsing of CEA-608 from the video.
  822.     var drmTags = [];
  823.     playlist.segments.forEach(function(segment) {
  824.       var segmentKeyTags = Utils.filterTagsByName(segment.tags, 'EXT-X-KEY');
  825.       drmTags.push.apply(drmTags, segmentKeyTags);
  826.     });
  828.     var encrypted = false;
  829.     var drmInfos = [];
  830.     var keyId = null;
  832.     // TODO: may still need changes to support key rotation
  833.     drmTags.forEach(function(drmTag) {
  834.       var method = HlsParser.getRequiredAttributeValue_(drmTag, 'METHOD');
  835.       if (method != 'NONE') {
  836.         encrypted = true;
  838.         var keyFormat =
  839.             HlsParser.getRequiredAttributeValue_(drmTag, 'KEYFORMAT');
  840.         var drmParser =
  841.             shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  843.         var drmInfo = drmParser ? drmParser(drmTag) : null;
  844.         if (drmInfo) {
  845.           if (drmInfo.keyIds.length) {
  846.             keyId = drmInfo.keyIds[0];
  847.           }
  848.           drmInfos.push(drmInfo);
  849.         } else {
  850.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  851.         }
  852.       }
  853.     });
  855.     if (encrypted && !drmInfos.length) {
  856.       throw new shaka.util.Error(
  857.           shaka.util.Error.Severity.CRITICAL,
  858.           shaka.util.Error.Category.MANIFEST,
  859.           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
  860.     }
  862.     return this.guessMimeType_(type, segments[0].getUris()[0])
  863.         .then(function(mimeType) {
  864.           var stream = {
  865.             id: this.globalId_++,
  866.             createSegmentIndex: Promise.resolve.bind(Promise),
  867.             findSegmentPosition: segmentIndex.find.bind(segmentIndex),
  868.             getSegmentReference: segmentIndex.get.bind(segmentIndex),
  869.             initSegmentReference: initSegmentReference,
  870.             presentationTimeOffset: timeOffset || 0,
  871.             mimeType: mimeType,
  872.             codecs: codecs,
  873.             kind: kind,
  874.             encrypted: encrypted,
  875.             keyId: keyId,
  876.             language: language,
  877.             label: label || null,
  878.             type: type,
  879.             primary: primary,
  880.             // TODO: trick mode
  881.             trickModeVideo: null,
  882.             containsEmsgBoxes: false,
  883.             frameRate: undefined,
  884.             width: undefined,
  885.             height: undefined,
  886.             bandwidth: undefined,
  887.             roles: [],
  888.             channelsCount: channelsCount
  889.           };
  891.           this.streamsToIndexMap_[stream.id] = segmentIndex;
  893.           return {
  894.             stream: stream,
  895.             segmentIndex: segmentIndex,
  896.             drmInfos: drmInfos,
  897.             relativeUri: relativeUri,
  898.             lastSegmentSeen: segments[segments.length - 1]
  899.           };
  900.         }.bind(this));
  901.   }.bind(this));
  902. };
  905. /**
  906.  * @param {!shaka.hls.Playlist} playlist
  907.  * @throws shaka.util.Error
  908.  * @private
  909.  */
  910. shaka.hls.HlsParser.prototype.setPresentationType_ = function(playlist) {
  911.   var Utils = shaka.hls.Utils;
  912.   var presentationTypeTag = Utils.getFirstTagWithName(playlist.tags,
  913.                                                       'EXT-X-PLAYLIST-TYPE');
  914.   var endlistTag = Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  915.   var isVod = endlistTag || (presentationTypeTag &&
  916.                              presentationTypeTag.value == 'VOD');
  917.   if (isVod) {
  918.     this.setLive_(false);
  919.   } else if (!presentationTypeTag) {
  920.     throw new shaka.util.Error(
  921.         shaka.util.Error.Severity.CRITICAL,
  922.         shaka.util.Error.Category.MANIFEST,
  923.         shaka.util.Error.Code.HLS_LIVE_CONTENT_NOT_SUPPORTED);
  924.   } else {
  925.     // presentation type EVENT
  926.     var targetDurationTag = this.getRequiredTag_(playlist.tags,
  927.                                                  'EXT-X-TARGETDURATION');
  928.     var targetDuration = Number(targetDurationTag.value);
  929.     // According to HLS spec, updates should not happen more often than
  930.     // once in targetDuration. It also requires to only update the active
  931.     // variant. We might implement that later, but for now every variant
  932.     // will be updated. To get the update period, choose the smallest
  933.     // targetDuration value across all playlists.
  934.     if (!this.updatePeriod_) {
  935.       this.setLive_(true);
  936.       this.updatePeriod_ = targetDuration;
  937.     } else if (this.updatePeriod_ > targetDuration) {
  938.       this.updatePeriod_ = targetDuration;
  939.     }
  941.     // Update longest target duration if need be to use as a presentation
  942.     // delay later.
  943.     this.maxTargetDuration_ = Math.max(targetDuration, this.maxTargetDuration_);
  944.   }
  945. };
  948. /**
  949.  * @param {number} endTime
  950.  * @throws shaka.util.Error
  951.  * @private
  952.  */
  953. shaka.hls.HlsParser.prototype.createPresentationTimeline_ = function(endTime) {
  954.   var presentationStartTime = null;
  955.   var delay = 0;
  957.   if (this.isLive_) {
  958.     presentationStartTime = (Date.now() / 1000) - endTime;
  960.     // We should have a delay of at least 3 target durations.
  961.     delay = this.maxTargetDuration_ * 3;
  962.   }
  964.   this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  965.       presentationStartTime, delay);
  966.   this.presentationTimeline_.setStatic(!this.isLive_);
  967. };
  970. /**
  971.  * @param {!shaka.hls.Playlist} playlist
  972.  * @return {shaka.media.InitSegmentReference}
  973.  * @private
  974.  * @throws {shaka.util.Error}
  975.  */
  976. shaka.hls.HlsParser.prototype.createInitSegmentReference_ = function(playlist) {
  977.   var Utils = shaka.hls.Utils;
  978.   var mapTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MAP');
  979.   // TODO: Support multiple map tags?
  980.   // For now, we don't support multiple map tags and will throw an error.
  981.   if (!mapTags.length) {
  982.     return null;
  983.   } else if (mapTags.length > 1) {
  984.     throw new shaka.util.Error(
  985.         shaka.util.Error.Severity.CRITICAL,
  986.         shaka.util.Error.Category.MANIFEST,
  987.         shaka.util.Error.Code.HLS_MULTIPLE_MEDIA_INIT_SECTIONS_FOUND);
  988.   }
  990.   // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
  991.   var mapTag = mapTags[0];
  992.   var initUri = shaka.hls.HlsParser.getRequiredAttributeValue_(mapTag, 'URI');
  993.   var uri = Utils.constructAbsoluteUri(playlist.uri, initUri);
  994.   var startByte = 0;
  995.   var endByte = null;
  996.   var byterange = mapTag.getAttributeValue('BYTERANGE');
  997.   // If BYTERANGE attribute is not specified, the segment consists
  998.   // of the entire resourse.
  999.   if (byterange) {
  1000.     var blocks = byterange.split('@');
  1001.     var byteLength = Number(blocks[0]);
  1002.     startByte = Number(blocks[1]);
  1003.     endByte = startByte + byteLength - 1;
  1004.   }
  1006.   return new shaka.media.InitSegmentReference(function() { return [uri]; },
  1007.                                               startByte,
  1008.                                               endByte);
  1009. };
  1012. /**
  1013.  * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences.
  1014.  *
  1015.  * @param {!shaka.hls.Playlist} playlist
  1016.  * @param {number} startPosition
  1017.  * @return {!Array.<!shaka.media.SegmentReference>}
  1018.  * @private
  1019.  */
  1020. shaka.hls.HlsParser.prototype.createSegments_ =
  1021.     function(playlist, startPosition) {
  1022.   var hlsSegments = playlist.segments;
  1023.   var segments = [];
  1025.   hlsSegments.forEach(function(segment) {
  1026.     var Utils = shaka.hls.Utils;
  1027.     var tags = segment.tags;
  1028.     var uri = Utils.constructAbsoluteUri(playlist.uri, segment.uri);
  1030.     // Start and end times
  1031.     var extinfTag = this.getRequiredTag_(tags, 'EXTINF');
  1032.     // EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  1033.     // We're interested in the duration part.
  1034.     var extinfValues = extinfTag.value.split(',');
  1035.     var duration = Number(extinfValues[0]);
  1036.     var startTime;
  1037.     var index = hlsSegments.indexOf(segment);
  1038.     if (index == 0) {
  1039.       startTime = 0;
  1040.     } else {
  1041.       startTime = segments[index - 1].endTime;
  1042.     }
  1043.     var endTime = startTime + duration;
  1045.     // StartByte and EndByte
  1046.     var startByte = 0;
  1047.     var endByte = null;
  1048.     var byterange = Utils.getFirstTagWithName(tags, 'EXT-X-BYTERANGE');
  1049.     // If BYTERANGE is not specified, the segment consists of the
  1050.     // entire resourse.
  1051.     if (byterange) {
  1052.       var blocks = byterange.value.split('@');
  1053.       var byteLength = Number(blocks[0]);
  1054.       if (blocks[1]) {
  1055.         startByte = Number(blocks[1]);
  1056.       } else {
  1057.         startByte = segments[index - 1].endByte + 1;
  1058.       }
  1059.       endByte = startByte + byteLength - 1;
  1061.       // Last segment has endByte of null to indicate that it extends
  1062.       // to the end of the resource.
  1063.       if (index == hlsSegments.length - 1)
  1064.         endByte = null;
  1065.     }
  1066.     segments.push(new shaka.media.SegmentReference(startPosition + index,
  1067.                                                    startTime,
  1068.                                                    endTime,
  1069.                                                    function() { return [uri]; },
  1070.                                                    startByte,
  1071.                                                    endByte));
  1072.   }.bind(this));
  1074.   return segments;
  1075. };
  1078. /**
  1079.  * Adjusts segment references of every stream of every variant to the
  1080.  * timeline of the presentation.
  1081.  * @param {!Array.<!shakaExtern.Variant>} variants
  1082.  * @private
  1083.  */
  1084. shaka.hls.HlsParser.prototype.fitSegments_ = function(variants) {
  1085.   variants.forEach(function(variant) {
  1086.     var duration = this.presentationTimeline_.getDuration();
  1087.     var video = variant.video;
  1088.     var audio = variant.audio;
  1089.     if (video && this.streamsToIndexMap_[video.id]) {
  1090.       this.streamsToIndexMap_[video.id].fit(duration);
  1091.     }
  1092.     if (audio && this.streamsToIndexMap_[audio.id]) {
  1093.       this.streamsToIndexMap_[audio.id].fit(duration);
  1094.     }
  1095.   }.bind(this));
  1096. };
  1099. /**
  1100.  * Attempts to guess which codecs from the codecs list belong
  1101.  * to a given content type.
  1102.  *
  1103.  * @param {!string} contentType
  1104.  * @param {!Array.<!string>} codecs
  1105.  * @return {string}
  1106.  * @private
  1107.  * @throws {shaka.util.Error}
  1108.  */
  1109. shaka.hls.HlsParser.prototype.guessCodecs_ = function(contentType, codecs) {
  1110.   if (codecs.length == 1) {
  1111.     return codecs[0];
  1112.   }
  1114.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1115.   if (contentType == ContentType.TEXT) {
  1116.     return '';
  1117.   }
  1119.   var HlsParser = shaka.hls.HlsParser;
  1120.   var formats = HlsParser.VIDEO_CODEC_FORMATS_;
  1121.   if (contentType == ContentType.AUDIO)
  1122.     formats = HlsParser.AUDIO_CODEC_FORMATS_;
  1124.   for (var i = 0; i < formats.length; i++) {
  1125.     for (var j = 0; j < codecs.length; j++) {
  1126.       if (formats[i].test(codecs[j].trim())) {
  1127.         return codecs[j].trim();
  1128.       }
  1129.     }
  1130.   }
  1132.   // Unable to guess codecs.
  1133.   throw new shaka.util.Error(
  1134.       shaka.util.Error.Severity.CRITICAL,
  1135.       shaka.util.Error.Category.MANIFEST,
  1136.       shaka.util.Error.Code.HLS_COULD_NOT_GUESS_CODECS,
  1137.       codecs);
  1138. };
  1141. /**
  1142.  * Attempts to guess stream's mime type based on content type and uri.
  1143.  *
  1144.  * @param {!string} contentType
  1145.  * @param {!string} uri
  1146.  * @return {!Promise.<!string>}
  1147.  * @private
  1148.  * @throws {shaka.util.Error}
  1149.  */
  1150. shaka.hls.HlsParser.prototype.guessMimeType_ = function(contentType, uri) {
  1151.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1152.   var blocks = uri.split('.');
  1153.   var extension = blocks[blocks.length - 1];
  1155.   if (contentType == ContentType.TEXT) {
  1156.     // HLS only supports vtt at the moment.
  1157.     return Promise.resolve('text/vtt');
  1158.   }
  1160.   var HlsParser = shaka.hls.HlsParser;
  1161.   var map = HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_;
  1162.   if (contentType == ContentType.VIDEO)
  1163.     map = HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_;
  1165.   var mimeType = map[extension];
  1166.   if (mimeType)
  1167.     return Promise.resolve(mimeType);
  1169.   // If unable to guess mime type, request a segment and try getting it
  1170.   // from the response.
  1171.   var headRequest = shaka.net.NetworkingEngine.makeRequest(
  1172.       [uri], this.config_.retryParameters);
  1173.   headRequest.method = 'HEAD';
  1174.   var requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1175.   return this.playerInterface_.networkingEngine.request(
  1176.       requestType, headRequest)
  1177.     .then(function(response) {
  1178.         var mimeType = response.headers['content-type'];
  1179.         if (!mimeType) {
  1180.           throw new shaka.util.Error(
  1181.               shaka.util.Error.Severity.CRITICAL,
  1182.               shaka.util.Error.Category.MANIFEST,
  1183.               shaka.util.Error.Code.HLS_COULD_NOT_GUESS_MIME_TYPE,
  1184.               extension);
  1185.         }
  1187.         return mimeType;
  1188.       });
  1189. };
  1192. /**
  1193.  * Get presentation time offset of the playlist if it has been specified.
  1194.  * Return null otherwise.
  1195.  *
  1196.  * @param {!shaka.hls.Playlist} playlist
  1197.  * @return {?number}
  1198.  * @private
  1199.  */
  1200. shaka.hls.HlsParser.prototype.getTimeOffset_ = function(playlist) {
  1201.   var Utils = shaka.hls.Utils;
  1202.   var startTag = Utils.getFirstTagWithName(playlist.tags, 'EXT-X-START');
  1203.   // TODO: Should we respect the PRECISE flag?
  1204.   // https://tools.ietf.org/html/draft-pantos-http-live-streaming-20#section-4.3.5.2
  1205.   if (startTag)
  1206.     return Number(shaka.hls.HlsParser.getRequiredAttributeValue_(
  1207.         startTag, 'TIME-OFFSET'));
  1209.   return this.config_.hls.defaultTimeOffset;
  1210. };
  1213. /**
  1214.  * Find the attribute and returns its value.
  1215.  * Throws an error if attribute was not found.
  1216.  *
  1217.  * @param {shaka.hls.Tag} tag
  1218.  * @param {!string} attributeName
  1219.  * @return {!string}
  1220.  * @private
  1221.  * @throws {shaka.util.Error}
  1222.  */
  1223. shaka.hls.HlsParser.getRequiredAttributeValue_ =
  1224.     function(tag, attributeName) {
  1225.   var attribute = tag.getAttribute(attributeName);
  1226.   if (!attribute) {
  1227.     throw new shaka.util.Error(
  1228.         shaka.util.Error.Severity.CRITICAL,
  1229.         shaka.util.Error.Category.MANIFEST,
  1230.         shaka.util.Error.Code.HLS_REQUIRED_ATTRIBUTE_MISSING,
  1231.         attributeName);
  1232.   }
  1234.   return attribute.value;
  1235. };
  1238. /**
  1239.  * Returns a tag with a given name.
  1240.  * Throws an error if tag was not found.
  1241.  *
  1242.  * @param {!Array.<shaka.hls.Tag>} tags
  1243.  * @param {!string} tagName
  1244.  * @return {!shaka.hls.Tag}
  1245.  * @private
  1246.  * @throws {shaka.util.Error}
  1247.  */
  1248. shaka.hls.HlsParser.prototype.getRequiredTag_ = function(tags, tagName) {
  1249.   var Utils = shaka.hls.Utils;
  1250.   var tag = Utils.getFirstTagWithName(tags, tagName);
  1251.   if (!tag) {
  1252.     throw new shaka.util.Error(
  1253.         shaka.util.Error.Severity.CRITICAL,
  1254.         shaka.util.Error.Category.MANIFEST,
  1255.         shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, tagName);
  1256.   }
  1258.   return tag;
  1259. };
  1262. /**
  1263.  * @param {shakaExtern.Stream} stream
  1264.  * @param {?string} width
  1265.  * @param {?string} height
  1266.  * @param {?string} frameRate
  1267.  * @private
  1268.  */
  1269. shaka.hls.HlsParser.prototype.addVideoAttributes_ =
  1270.     function(stream, width, height, frameRate) {
  1271.   if (stream) {
  1272.     stream.width = Number(width) || undefined;
  1273.     stream.height = Number(height) || undefined;
  1274.     stream.frameRate = Number(frameRate) || undefined;
  1275.   }
  1276. };
  1279. /**
  1280.  * Makes a network request for the manifest and returns a Promise
  1281.  * with the resulting data.
  1282.  *
  1283.  * @param {!string} uri
  1284.  * @return {!Promise.<!shakaExtern.Response>}
  1285.  * @private
  1286.  */
  1287. shaka.hls.HlsParser.prototype.requestManifest_ = function(uri) {
  1288.   var requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  1289.   var request = shaka.net.NetworkingEngine.makeRequest(
  1290.       [uri], this.config_.retryParameters);
  1291.   return this.playerInterface_.networkingEngine.request(requestType, request);
  1292. };
  1295. /**
  1296.  * A list of well-known video codecs formats.
  1297.  *
  1298.  * @const {!Array<!RegExp>}
  1299.  * @private
  1300.  */
  1301. shaka.hls.HlsParser.VIDEO_CODEC_FORMATS_ = [
  1302.   /^(avc)/,
  1303.   /^(hvc)/,
  1304.   /^(vp[8-9])$/,
  1305.   /^(av1)$/,
  1306.   /^(mp4v)/
  1307. ];
  1310. /**
  1311.  * A list of well-known audio codecs formats.
  1312.  *
  1313.  * @const {!Array<!RegExp>}
  1314.  * @private
  1315.  */
  1316. shaka.hls.HlsParser.AUDIO_CODEC_FORMATS_ = [
  1317.   /^(vorbis)/,
  1318.   /^(opus)/,
  1319.   /^(mp4a)/,
  1320.   /^(ac-3)$/,
  1321.   /^(ec-3)$/
  1322. ];
  1325. /**
  1326.  * @const {!Object<string, string>}
  1327.  * @private
  1328.  */
  1329. shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
  1330.   'mp4': 'audio/mp4',
  1331.   'm4s': 'audio/mp4',
  1332.   'm4i': 'audio/mp4',
  1333.   'm4a': 'audio/mp4',
  1334.   // mpeg2 ts aslo uses video/ for audio: http://goo.gl/tYHXiS
  1335.   'ts': 'video/mp2t'
  1336. };
  1339. /**
  1340.  * @const {!Object<string, string>}
  1341.  * @private
  1342.  */
  1343. shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = {
  1344.   'mp4': 'video/mp4',
  1345.   'm4s': 'video/mp4',
  1346.   'm4i': 'video/mp4',
  1347.   'm4v': 'video/mp4',
  1348.   'ts': 'video/mp2t'
  1349. };
  1352. /**
  1353.  * @typedef {function(!shaka.hls.Tag):?shakaExtern.DrmInfo}
  1354.  * @private
  1355.  */
  1356. shaka.hls.HlsParser.DrmParser_;
  1359. /**
  1360.  * @param {!shaka.hls.Tag} drmTag
  1361.  * @return {?shakaExtern.DrmInfo}
  1362.  * @private
  1363.  */
  1364. shaka.hls.HlsParser.widevineDrmParser_ = function(drmTag) {
  1365.   var HlsParser = shaka.hls.HlsParser;
  1366.   var method = HlsParser.getRequiredAttributeValue_(drmTag, 'METHOD');
  1367.   if (method != 'SAMPLE-AES-CENC') {
  1368.     shaka.log.error(
  1369.         'Widevine in HLS is only supported with SAMPLE-AES-CENC, not', method);
  1370.     return null;
  1371.   }
  1373.   var uri = HlsParser.getRequiredAttributeValue_(drmTag, 'URI');
  1374.   var parsedData = shaka.net.DataUriPlugin.parse(uri);
  1376.   // The data encoded in the URI is a PSSH box to be used as init data.
  1377.   var pssh = new Uint8Array(parsedData.data);
  1378.   var drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  1379.       'com.widevine.alpha', [
  1380.         {initDataType: 'cenc', initData: pssh}
  1381.       ]);
  1383.   var keyId = drmTag.getAttributeValue('KEYID');
  1384.   if (keyId) {
  1385.     // This value begins with '0x':
  1386.     goog.asserts.assert(keyId.substr(0, 2) == '0x',
  1387.                         'Incorrect KEYID format!');
  1388.     // But the output does not contain the '0x':
  1389.     drmInfo.keyIds = [keyId.substr(2).toLowerCase()];
  1390.   }
  1391.   return drmInfo;
  1392. };
  1395. /**
  1396.  * Called when the update timer ticks.
  1397.  *
  1398.  * @private
  1399.  */
  1400. shaka.hls.HlsParser.prototype.onUpdate_ = function() {
  1401.   goog.asserts.assert(this.updateTimer_, 'Should only be called by timer');
  1402.   goog.asserts.assert(this.updatePeriod_ != null,
  1403.                       'There should be an update period');
  1405.   shaka.log.info('Updating manifest...');
  1407.   // Detect a call to stop()
  1408.   if (!this.playerInterface_)
  1409.     return;
  1411.   this.updateTimer_ = null;
  1412.   this.update().then(function() {
  1413.     this.setUpdateTimer_(this.updatePeriod_);
  1414.   }.bind(this)).catch(function(error) {
  1415.     goog.asserts.assert(error instanceof shaka.util.Error,
  1416.                         'Should only receive a Shaka error');
  1418.     // Try updating again, but ensure we haven't been destroyed.
  1419.     if (this.playerInterface_) {
  1420.       // We will retry updating, so override the severity of the error.
  1421.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  1422.       this.playerInterface_.onError(error);
  1424.       this.setUpdateTimer_(0);
  1425.     }
  1426.   }.bind(this));
  1427. };
  1430. /**
  1431.  * Sets the update timer.
  1432.  *
  1433.  * @param {?number} time in seconds
  1434.  * @private
  1435.  */
  1436. shaka.hls.HlsParser.prototype.setUpdateTimer_ = function(time) {
  1437.   if (this.updatePeriod_ == null || time == null)
  1438.     return;
  1439.   goog.asserts.assert(this.updateTimer_ == null,
  1440.                       'Timer should not be already set');
  1442.   var callback = this.onUpdate_.bind(this);
  1443.   this.updateTimer_ = window.setTimeout(callback, time * 1000);
  1444. };
  1447. /**
  1448.  * @param {boolean} live
  1449.  * @private
  1450.  */
  1451. shaka.hls.HlsParser.prototype.setLive_ = function(live) {
  1452.   this.isLive_ = live;
  1454.   if (this.presentationTimeline_)
  1455.     this.presentationTimeline_.setStatic(!live);
  1457.   if (!live) {
  1458.     if (this.updateTimer_ != null) {
  1459.       window.clearTimeout(this.updateTimer_);
  1460.       this.updateTimer_ = null;
  1461.       this.updatePeriod_ = null;
  1462.     }
  1463.   }
  1464. };
  1467. /**
  1468.  * @const {!Object.<string, shaka.hls.HlsParser.DrmParser_>}
  1469.  * @private
  1470.  */
  1471. shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
  1472.   /* TODO: https://github.com/google/shaka-player/issues/382
  1473.   'com.apple.streamingkeydelivery':
  1474.       shaka.hls.HlsParser.fairplayDrmParser_,
  1475.   */
  1476.   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
  1477.       shaka.hls.HlsParser.widevineDrmParser_
  1478. };
  1481. shaka.media.ManifestParser.registerParserByExtension(
  1482.     'm3u8', shaka.hls.HlsParser);
  1483. shaka.media.ManifestParser.registerParserByMime(
  1484.     'application/x-mpegurl', shaka.hls.HlsParser);
  1485. shaka.media.ManifestParser.registerParserByMime(
  1486.     'application/vnd.apple.mpegurl', shaka.hls.HlsParser);