Source: master-playlist-controller.js

  1. /**
  2.  * @file master-playlist-controller.js
  3.  */
  4. import PlaylistLoader from './playlist-loader';
  5. import SegmentLoader from './segment-loader';
  6. import Ranges from './ranges';
  7. import videojs from 'video.js';
  8. import AdCueTags from './ad-cue-tags';
  10. // 5 minute blacklist
  11. const BLACKLIST_DURATION = 5 * 60 * 1000;
  12. let Hls;
  14. /**
  15.  * determine if an object a is differnt from
  16.  * and object b. both only having one dimensional
  17.  * properties
  18.  *
  19.  * @param {Object} a object one
  20.  * @param {Object} b object two
  21.  * @return {Boolean} if the object has changed or not
  22.  */
  23. const objectChanged = function(a, b) {
  24.   if (typeof a !== typeof b) {
  25.     return true;
  26.   }
  27.   // if we have a different number of elements
  28.   // something has changed
  29.   if (Object.keys(a).length !== Object.keys(b).length) {
  30.     return true;
  31.   }
  33.   for (let prop in a) {
  34.     if (a[prop] !== b[prop]) {
  35.       return true;
  36.     }
  37.   }
  38.   return false;
  39. };
  41. /**
  42.  * Parses a codec string to retrieve the number of codecs specified,
  43.  * the video codec and object type indicator, and the audio profile.
  44.  *
  45.  * @private
  46.  */
  47. const parseCodecs = function(codecs) {
  48.   let result = {
  49.     codecCount: 0,
  50.     videoCodec: null,
  51.     videoObjectTypeIndicator: null,
  52.     audioProfile: null
  53.   };
  54.   let parsed;
  56.   result.codecCount = codecs.split(',').length;
  57.   result.codecCount = result.codecCount || 2;
  59.   // parse the video codec
  60.   parsed = (/(^|\s|,)+(avc1)([^ ,]*)/i).exec(codecs);
  61.   if (parsed) {
  62.     result.videoCodec = parsed[2];
  63.     result.videoObjectTypeIndicator = parsed[3];
  64.   }
  66.   // parse the last field of the audio codec
  67.   result.audioProfile =
  68.     (/(^|\s|,)+mp4a.[0-9A-Fa-f]+\.([0-9A-Fa-f]+)/i).exec(codecs);
  69.   result.audioProfile = result.audioProfile && result.audioProfile[2];
  71.   return result;
  72. };
  74. /**
  75.  * Calculates the MIME type strings for a working configuration of
  76.  * SourceBuffers to play variant streams in a master playlist. If
  77.  * there is no possible working configuration, an empty array will be
  78.  * returned.
  79.  *
  80.  * @param master {Object} the m3u8 object for the master playlist
  81.  * @param media {Object} the m3u8 object for the variant playlist
  82.  * @return {Array} the MIME type strings. If the array has more than
  83.  * one entry, the first element should be applied to the video
  84.  * SourceBuffer and the second to the audio SourceBuffer.
  85.  *
  86.  * @private
  87.  */
  88. export const mimeTypesForPlaylist_ = function(master, media) {
  89.   let container = 'mp2t';
  90.   let codecs = {
  91.     videoCodec: 'avc1',
  92.     videoObjectTypeIndicator: '.4d400d',
  93.     audioProfile: '2'
  94.   };
  95.   let audioGroup = [];
  96.   let mediaAttributes;
  97.   let previousGroup = null;
  99.   if (!media) {
  100.     // not enough information, return an error
  101.     return [];
  102.   }
  103.   // An initialization segment means the media playlists is an iframe
  104.   // playlist or is using the mp4 container. We don't currently
  105.   // support iframe playlists, so assume this is signalling mp4
  106.   // fragments.
  107.   // the existence check for segments can be removed once
  108.   // https://github.com/videojs/m3u8-parser/issues/8 is closed
  109.   if (media.segments && media.segments.length && media.segments[0].map) {
  110.     container = 'mp4';
  111.   }
  113.   // if the codecs were explicitly specified, use them instead of the
  114.   // defaults
  115.   mediaAttributes = media.attributes || {};
  116.   if (mediaAttributes.CODECS) {
  117.     let parsedCodecs = parseCodecs(mediaAttributes.CODECS);
  119.     Object.keys(parsedCodecs).forEach((key) => {
  120.       codecs[key] = parsedCodecs[key] || codecs[key];
  121.     });
  122.   }
  124.   if (master.mediaGroups.AUDIO) {
  125.     audioGroup = master.mediaGroups.AUDIO[mediaAttributes.AUDIO];
  126.   }
  128.   // if audio could be muxed or unmuxed, use mime types appropriate
  129.   // for both scenarios
  130.   for (let groupId in audioGroup) {
  131.     if (previousGroup && (!!audioGroup[groupId].uri !== !!previousGroup.uri)) {
  132.       // one source buffer with muxed video and audio and another for
  133.       // the alternate audio
  134.       return [
  135.         'video/' + container + '; codecs="' +
  136.           codecs.videoCodec + codecs.videoObjectTypeIndicator + ', mp4a.40.' + codecs.audioProfile + '"',
  137.         'audio/' + container + '; codecs="mp4a.40.' + codecs.audioProfile + '"'
  138.       ];
  139.     }
  140.     previousGroup = audioGroup[groupId];
  141.   }
  142.   // if all video and audio is unmuxed, use two single-codec mime
  143.   // types
  144.   if (previousGroup && previousGroup.uri) {
  145.     return [
  146.       'video/' + container + '; codecs="' +
  147.         codecs.videoCodec + codecs.videoObjectTypeIndicator + '"',
  148.       'audio/' + container + '; codecs="mp4a.40.' + codecs.audioProfile + '"'
  149.     ];
  150.   }
  152.   // all video and audio are muxed, use a dual-codec mime type
  153.   return [
  154.     'video/' + container + '; codecs="' +
  155.       codecs.videoCodec + codecs.videoObjectTypeIndicator +
  156.       ', mp4a.40.' + codecs.audioProfile + '"'
  157.   ];
  158. };
  160. /**
  161.  * the master playlist controller controller all interactons
  162.  * between playlists and segmentloaders. At this time this mainly
  163.  * involves a master playlist and a series of audio playlists
  164.  * if they are available
  165.  *
  166.  * @class MasterPlaylistController
  167.  * @extends videojs.EventTarget
  168.  */
  169. export class MasterPlaylistController extends videojs.EventTarget {
  170.   constructor(options) {
  171.     super();
  173.     let {
  174.       url,
  175.       withCredentials,
  176.       mode,
  177.       tech,
  178.       bandwidth,
  179.       externHls,
  180.       useCueTags
  181.     } = options;
  183.     if (!url) {
  184.       throw new Error('A non-empty playlist URL is required');
  185.     }
  187.     Hls = externHls;
  189.     this.withCredentials = withCredentials;
  190.     this.tech_ = tech;
  191.     this.hls_ = tech.hls;
  192.     this.mode_ = mode;
  193.     this.useCueTags_ = useCueTags;
  194.     if (this.useCueTags_) {
  195.       this.cueTagsTrack_ = this.tech_.addTextTrack('metadata',
  196.         'ad-cues');
  197.       this.cueTagsTrack_.inBandMetadataTrackDispatchType = '';
  198.       this.tech_.textTracks().addTrack_(this.cueTagsTrack_);
  199.     }
  201.     this.audioTracks_ = [];
  202.     this.requestOptions_ = {
  203.       withCredentials: this.withCredentials,
  204.       timeout: null
  205.     };
  207.     this.audioGroups_ = {};
  209.     this.mediaSource = new videojs.MediaSource({ mode });
  210.     this.audioinfo_ = null;
  211.     this.mediaSource.on('audioinfo', this.handleAudioinfoUpdate_.bind(this));
  213.     // load the media source into the player
  214.     this.mediaSource.addEventListener('sourceopen', this.handleSourceOpen_.bind(this));
  216.     this.hasPlayed_ = () => false;
  218.     let segmentLoaderOptions = {
  219.       hls: this.hls_,
  220.       mediaSource: this.mediaSource,
  221.       currentTime: this.tech_.currentTime.bind(this.tech_),
  222.       seekable: () => this.seekable(),
  223.       seeking: () => this.tech_.seeking(),
  224.       setCurrentTime: (a) => this.tech_.setCurrentTime(a),
  225.       hasPlayed: () => this.hasPlayed_(),
  226.       bandwidth
  227.     };
  229.     // setup playlist loaders
  230.     this.masterPlaylistLoader_ = new PlaylistLoader(url, this.hls_, this.withCredentials);
  231.     this.setupMasterPlaylistLoaderListeners_();
  232.     this.audioPlaylistLoader_ = null;
  234.     // setup segment loaders
  235.     // combined audio/video or just video when alternate audio track is selected
  236.     this.mainSegmentLoader_ = new SegmentLoader(segmentLoaderOptions);
  237.     // alternate audio track
  238.     this.audioSegmentLoader_ = new SegmentLoader(segmentLoaderOptions);
  239.     this.setupSegmentLoaderListeners_();
  241.     this.masterPlaylistLoader_.start();
  242.   }
  244.   /**
  245.    * Register event handlers on the master playlist loader. A helper
  246.    * function for construction time.
  247.    *
  248.    * @private
  249.    */
  250.   setupMasterPlaylistLoaderListeners_() {
  251.     this.masterPlaylistLoader_.on('loadedmetadata', () => {
  252.       let media = this.masterPlaylistLoader_.media();
  253.       let requestTimeout = (this.masterPlaylistLoader_.targetDuration * 1.5) * 1000;
  255.       this.requestOptions_.timeout = requestTimeout;
  257.       // if this isn't a live video and preload permits, start
  258.       // downloading segments
  259.       if (media.endList && this.tech_.preload() !== 'none') {
  260.         this.mainSegmentLoader_.playlist(media, this.requestOptions_);
  261.         this.mainSegmentLoader_.load();
  262.       }
  264.       this.fillAudioTracks_();
  265.       this.setupAudio();
  267.       try {
  268.         this.setupSourceBuffers_();
  269.       } catch (e) {
  270.         videojs.log.warn('Failed to create SourceBuffers', e);
  271.         return this.mediaSource.endOfStream('decode');
  272.       }
  273.       this.setupFirstPlay();
  275.       this.trigger('audioupdate');
  276.       this.trigger('selectedinitialmedia');
  277.     });
  279.     this.masterPlaylistLoader_.on('loadedplaylist', () => {
  280.       let updatedPlaylist = this.masterPlaylistLoader_.media();
  281.       let seekable;
  283.       if (!updatedPlaylist) {
  284.         // select the initial variant
  285.         this.initialMedia_ = this.selectPlaylist();
  286.         this.masterPlaylistLoader_.media(this.initialMedia_);
  287.         return;
  288.       }
  290.       if (this.useCueTags_) {
  291.         this.updateAdCues_(updatedPlaylist,
  292.                            this.masterPlaylistLoader_.expired_);
  293.       }
  295.       // TODO: Create a new event on the PlaylistLoader that signals
  296.       // that the segments have changed in some way and use that to
  297.       // update the SegmentLoader instead of doing it twice here and
  298.       // on `mediachange`
  299.       this.mainSegmentLoader_.playlist(updatedPlaylist, this.requestOptions_);
  300.       this.updateDuration();
  302.       // update seekable
  303.       seekable = this.seekable();
  304.       if (!updatedPlaylist.endList && seekable.length !== 0) {
  305.         this.mediaSource.addSeekableRange_(seekable.start(0), seekable.end(0));
  306.       }
  307.     });
  309.     this.masterPlaylistLoader_.on('error', () => {
  310.       this.blacklistCurrentPlaylist(this.masterPlaylistLoader_.error);
  311.     });
  313.     this.masterPlaylistLoader_.on('mediachanging', () => {
  314.       this.mainSegmentLoader_.abort();
  315.       this.mainSegmentLoader_.pause();
  316.     });
  318.     this.masterPlaylistLoader_.on('mediachange', () => {
  319.       let media = this.masterPlaylistLoader_.media();
  320.       let requestTimeout = (this.masterPlaylistLoader_.targetDuration * 1.5) * 1000;
  321.       let activeAudioGroup;
  322.       let activeTrack;
  324.       // If we don't have any more available playlists, we don't want to
  325.       // timeout the request.
  326.       if (this.masterPlaylistLoader_.isLowestEnabledRendition_()) {
  327.         this.requestOptions_.timeout = 0;
  328.       } else {
  329.         this.requestOptions_.timeout = requestTimeout;
  330.       }
  332.       // TODO: Create a new event on the PlaylistLoader that signals
  333.       // that the segments have changed in some way and use that to
  334.       // update the SegmentLoader instead of doing it twice here and
  335.       // on `loadedplaylist`
  336.       this.mainSegmentLoader_.playlist(media, this.requestOptions_);
  337.       this.mainSegmentLoader_.load();
  339.       // if the audio group has changed, a new audio track has to be
  340.       // enabled
  341.       activeAudioGroup = this.activeAudioGroup();
  342.       activeTrack = activeAudioGroup.filter((track) => track.enabled)[0];
  343.       if (!activeTrack) {
  344.         this.setupAudio();
  345.         this.trigger('audioupdate');
  346.       }
  348.       this.tech_.trigger({
  349.         type: 'mediachange',
  350.         bubbles: true
  351.       });
  352.     });
  353.   }
  355.   /**
  356.    * Register event handlers on the segment loaders. A helper function
  357.    * for construction time.
  358.    *
  359.    * @private
  360.    */
  361.   setupSegmentLoaderListeners_() {
  362.     this.mainSegmentLoader_.on('progress', () => {
  363.       // figure out what stream the next segment should be downloaded from
  364.       // with the updated bandwidth information
  365.       this.masterPlaylistLoader_.media(this.selectPlaylist());
  367.       this.trigger('progress');
  368.     });
  370.     this.mainSegmentLoader_.on('error', () => {
  371.       this.blacklistCurrentPlaylist(this.mainSegmentLoader_.error());
  372.     });
  374.     this.audioSegmentLoader_.on('error', () => {
  375.       videojs.log.warn('Problem encountered with the current alternate audio track' +
  376.                        '. Switching back to default.');
  377.       this.audioSegmentLoader_.abort();
  378.       this.audioPlaylistLoader_ = null;
  379.       this.setupAudio();
  380.     });
  381.   }
  383.   handleAudioinfoUpdate_(event) {
  384.     if (Hls.supportsAudioInfoChange_() ||
  385.         !this.audioInfo_ ||
  386.         !objectChanged(this.audioInfo_, event.info)) {
  387.       this.audioInfo_ = event.info;
  388.       return;
  389.     }
  391.     let error = 'had different audio properties (channels, sample rate, etc.) ' +
  392.         'or changed in some other way.  This behavior is currently ' +
  393.         'unsupported in Firefox 48 and below due to an issue: \n\n' +
  394.         'https://bugzilla.mozilla.org/show_bug.cgi?id=1247138\n\n';
  396.     let enabledIndex =
  397.         this.activeAudioGroup()
  398.           .map((track) => track.enabled)
  399.           .indexOf(true);
  400.     let enabledTrack = this.activeAudioGroup()[enabledIndex];
  401.     let defaultTrack = this.activeAudioGroup().filter((track) => {
  402.       return track.properties_ && track.properties_.default;
  403.     })[0];
  405.     // they did not switch audiotracks
  406.     // blacklist the current playlist
  407.     if (!this.audioPlaylistLoader_) {
  408.       error = `The rendition that we tried to switch to ${error}` +
  409.         'Unfortunately that means we will have to blacklist ' +
  410.         'the current playlist and switch to another. Sorry!';
  411.       this.blacklistCurrentPlaylist();
  412.     } else {
  413.       error = `The audio track '${enabledTrack.label}' that we tried to ` +
  414.         `switch to ${error} Unfortunately this means we will have to ` +
  415.         `return you to the main track '${defaultTrack.label}'. Sorry!`;
  416.       defaultTrack.enabled = true;
  417.       this.activeAudioGroup().splice(enabledIndex, 1);
  418.       this.trigger('audioupdate');
  419.     }
  421.     videojs.log.warn(error);
  422.     this.setupAudio();
  423.   }
  425.   /**
  426.    * get the total number of media requests from the `audiosegmentloader_`
  427.    * and the `mainSegmentLoader_`
  428.    *
  429.    * @private
  430.    */
  431.   mediaRequests_() {
  432.     return this.audioSegmentLoader_.mediaRequests +
  433.            this.mainSegmentLoader_.mediaRequests;
  434.   }
  436.   /**
  437.    * get the total time that media requests have spent trnasfering
  438.    * from the `audiosegmentloader_` and the `mainSegmentLoader_`
  439.    *
  440.    * @private
  441.    */
  442.   mediaTransferDuration_() {
  443.     return this.audioSegmentLoader_.mediaTransferDuration +
  444.            this.mainSegmentLoader_.mediaTransferDuration;
  446.   }
  448.   /**
  449.    * get the total number of bytes transfered during media requests
  450.    * from the `audiosegmentloader_` and the `mainSegmentLoader_`
  451.    *
  452.    * @private
  453.    */
  454.   mediaBytesTransferred_() {
  455.     return this.audioSegmentLoader_.mediaBytesTransferred +
  456.            this.mainSegmentLoader_.mediaBytesTransferred;
  457.   }
  459.   mediaSecondsLoaded_() {
  460.     return Math.max(this.audioSegmentLoader_.mediaSecondsLoaded +
  461.                     this.mainSegmentLoader_.mediaSecondsLoaded);
  462.   }
  464.   /**
  465.    * fill our internal list of HlsAudioTracks with data from
  466.    * the master playlist or use a default
  467.    *
  468.    * @private
  469.    */
  470.   fillAudioTracks_() {
  471.     let master = this.master();
  472.     let mediaGroups = master.mediaGroups || {};
  474.     // force a default if we have none or we are not
  475.     // in html5 mode (the only mode to support more than one
  476.     // audio track)
  477.     if (!mediaGroups ||
  478.         !mediaGroups.AUDIO ||
  479.         Object.keys(mediaGroups.AUDIO).length === 0 ||
  480.         this.mode_ !== 'html5') {
  481.       // "main" audio group, track name "default"
  482.       mediaGroups.AUDIO = { main: { default: { default: true }}};
  483.     }
  485.     for (let mediaGroup in mediaGroups.AUDIO) {
  486.       if (!this.audioGroups_[mediaGroup]) {
  487.         this.audioGroups_[mediaGroup] = [];
  488.       }
  490.       for (let label in mediaGroups.AUDIO[mediaGroup]) {
  491.         let properties = mediaGroups.AUDIO[mediaGroup][label];
  492.         let track = new videojs.AudioTrack({
  493.           id: label,
  494.           kind: properties.default ? 'main' : 'alternative',
  495.           enabled: false,
  496.           language: properties.language,
  497.           label
  498.         });
  500.         track.properties_ = properties;
  501.         this.audioGroups_[mediaGroup].push(track);
  502.       }
  503.     }
  505.     // enable the default active track
  506.     (this.activeAudioGroup().filter((audioTrack) => {
  507.       return audioTrack.properties_.default;
  508.     })[0] || this.activeAudioGroup()[0]).enabled = true;
  509.   }
  511.   /**
  512.    * Call load on our SegmentLoaders
  513.    */
  514.   load() {
  515.     this.mainSegmentLoader_.load();
  516.     if (this.audioPlaylistLoader_) {
  517.       this.audioSegmentLoader_.load();
  518.     }
  519.   }
  521.   /**
  522.    * Returns the audio group for the currently active primary
  523.    * media playlist.
  524.    */
  525.   activeAudioGroup() {
  526.     let videoPlaylist = this.masterPlaylistLoader_.media();
  527.     let result;
  529.     if (videoPlaylist.attributes && videoPlaylist.attributes.AUDIO) {
  530.       result = this.audioGroups_[videoPlaylist.attributes.AUDIO];
  531.     }
  533.     return result || this.audioGroups_.main;
  534.   }
  536.   /**
  537.    * Determine the correct audio rendition based on the active
  538.    * AudioTrack and initialize a PlaylistLoader and SegmentLoader if
  539.    * necessary. This method is called once automatically before
  540.    * playback begins to enable the default audio track and should be
  541.    * invoked again if the track is changed.
  542.    */
  543.   setupAudio() {
  544.     // determine whether seperate loaders are required for the audio
  545.     // rendition
  546.     let audioGroup = this.activeAudioGroup();
  547.     let track = audioGroup.filter((audioTrack) => {
  548.       return audioTrack.enabled;
  549.     })[0];
  551.     if (!track) {
  552.       track = audioGroup.filter((audioTrack) => {
  553.         return audioTrack.properties_.default;
  554.       })[0] || audioGroup[0];
  555.       track.enabled = true;
  556.     }
  558.     // stop playlist and segment loading for audio
  559.     if (this.audioPlaylistLoader_) {
  560.       this.audioPlaylistLoader_.dispose();
  561.       this.audioPlaylistLoader_ = null;
  562.     }
  563.     this.audioSegmentLoader_.pause();
  565.     if (!track.properties_.resolvedUri) {
  566.       this.mainSegmentLoader_.resetEverything();
  567.       return;
  568.     }
  569.     this.audioSegmentLoader_.resetEverything();
  571.     // startup playlist and segment loaders for the enabled audio
  572.     // track
  573.     this.audioPlaylistLoader_ = new PlaylistLoader(track.properties_.resolvedUri,
  574.                                                    this.hls_,
  575.                                                    this.withCredentials);
  576.     this.audioPlaylistLoader_.start();
  578.     this.audioPlaylistLoader_.on('loadedmetadata', () => {
  579.       let audioPlaylist = this.audioPlaylistLoader_.media();
  581.       this.audioSegmentLoader_.playlist(audioPlaylist, this.requestOptions_);
  583.       // if the video is already playing, or if this isn't a live video and preload
  584.       // permits, start downloading segments
  585.       if (!this.tech_.paused() ||
  586.           (audioPlaylist.endList && this.tech_.preload() !== 'none')) {
  587.         this.audioSegmentLoader_.load();
  588.       }
  590.       if (!audioPlaylist.endList) {
  591.         // trigger the playlist loader to start "expired time"-tracking
  592.         this.audioPlaylistLoader_.trigger('firstplay');
  593.       }
  594.     });
  596.     this.audioPlaylistLoader_.on('loadedplaylist', () => {
  597.       let updatedPlaylist;
  599.       if (this.audioPlaylistLoader_) {
  600.         updatedPlaylist = this.audioPlaylistLoader_.media();
  601.       }
  603.       if (!updatedPlaylist) {
  604.         // only one playlist to select
  605.         this.audioPlaylistLoader_.media(
  606.           this.audioPlaylistLoader_.playlists.master.playlists[0]);
  607.         return;
  608.       }
  610.       this.audioSegmentLoader_.playlist(updatedPlaylist, this.requestOptions_);
  611.     });
  613.     this.audioPlaylistLoader_.on('error', () => {
  614.       videojs.log.warn('Problem encountered loading the alternate audio track' +
  615.                        '. Switching back to default.');
  616.       this.audioSegmentLoader_.abort();
  617.       this.setupAudio();
  618.     });
  619.   }
  621.   /**
  622.    * Re-tune playback quality level for the current player
  623.    * conditions. This method may perform destructive actions, like
  624.    * removing already buffered content, to readjust the currently
  625.    * active playlist quickly.
  626.    *
  627.    * @private
  628.    */
  629.   fastQualityChange_() {
  630.     let media = this.selectPlaylist();
  632.     if (media !== this.masterPlaylistLoader_.media()) {
  633.       this.masterPlaylistLoader_.media(media);
  635.       this.mainSegmentLoader_.resetLoader();
  636.       if (this.audiosegmentloader_) {
  637.         this.audioSegmentLoader_.resetLoader();
  638.       }
  639.     }
  640.   }
  642.   /**
  643.    * Begin playback.
  644.    */
  645.   play() {
  646.     if (this.setupFirstPlay()) {
  647.       return;
  648.     }
  650.     if (this.tech_.ended()) {
  651.       this.tech_.setCurrentTime(0);
  652.     }
  654.     if (this.hasPlayed_()) {
  655.       this.load();
  656.     }
  658.     // if the viewer has paused and we fell out of the live window,
  659.     // seek forward to the earliest available position
  660.     if (this.tech_.duration() === Infinity) {
  661.       if (this.tech_.currentTime() < this.tech_.seekable().start(0)) {
  662.         return this.tech_.setCurrentTime(this.tech_.seekable().start(0));
  663.       }
  664.     }
  665.   }
  667.   /**
  668.    * Seek to the latest media position if this is a live video and the
  669.    * player and video are loaded and initialized.
  670.    */
  671.   setupFirstPlay() {
  672.     let seekable;
  673.     let media = this.masterPlaylistLoader_.media();
  675.     // check that everything is ready to begin buffering in the live
  676.     // scenario
  677.     // 1) the active media playlist is available
  678.     if (media &&
  679.         // 2) the player is not paused
  680.         !this.tech_.paused() &&
  681.         // 3) the player has not started playing
  682.         !this.hasPlayed_()) {
  684.       // when the video is a live stream
  685.       if (!media.endList) {
  686.         // trigger the playlist loader to start "expired time"-tracking
  687.         this.masterPlaylistLoader_.trigger('firstplay');
  688.         this.trigger('firstplay');
  689.         // seek to the latest media position for live videos
  690.         seekable = this.seekable();
  691.         if (seekable.length) {
  692.           this.tech_.setCurrentTime(seekable.end(0));
  693.         }
  694.       }
  695.       this.hasPlayed_ = () => true;
  696.       // now that we are ready, load the segment
  697.       this.load();
  698.       return true;
  699.     }
  700.     return false;
  701.   }
  703.   /**
  704.    * handle the sourceopen event on the MediaSource
  705.    *
  706.    * @private
  707.    */
  708.   handleSourceOpen_() {
  709.     // Only attempt to create the source buffer if none already exist.
  710.     // handleSourceOpen is also called when we are "re-opening" a source buffer
  711.     // after `endOfStream` has been called (in response to a seek for instance)
  712.     try {
  713.       this.setupSourceBuffers_();
  714.     } catch (e) {
  715.       videojs.log.warn('Failed to create Source Buffers', e);
  716.       return this.mediaSource.endOfStream('decode');
  717.     }
  719.     // if autoplay is enabled, begin playback. This is duplicative of
  720.     // code in video.js but is required because play() must be invoked
  721.     // *after* the media source has opened.
  722.     if (this.tech_.autoplay()) {
  723.       this.tech_.play();
  724.     }
  726.     this.trigger('sourceopen');
  727.   }
  729.   /**
  730.    * Blacklists a playlist when an error occurs for a set amount of time
  731.    * making it unavailable for selection by the rendition selection algorithm
  732.    * and then forces a new playlist (rendition) selection.
  733.    *
  734.    * @param {Object=} error an optional error that may include the playlist
  735.    * to blacklist
  736.    */
  737.   blacklistCurrentPlaylist(error = {}) {
  738.     let currentPlaylist;
  739.     let nextPlaylist;
  741.     // If the `error` was generated by the playlist loader, it will contain
  742.     // the playlist we were trying to load (but failed) and that should be
  743.     // blacklisted instead of the currently selected playlist which is likely
  744.     // out-of-date in this scenario
  745.     currentPlaylist = error.playlist || this.masterPlaylistLoader_.media();
  747.     // If there is no current playlist, then an error occurred while we were
  748.     // trying to load the master OR while we were disposing of the tech
  749.     if (!currentPlaylist) {
  750.       this.error = error;
  751.       return this.mediaSource.endOfStream('network');
  752.     }
  754.     // Blacklist this playlist
  755.     currentPlaylist.excludeUntil = Date.now() + BLACKLIST_DURATION;
  757.     // Select a new playlist
  758.     nextPlaylist = this.selectPlaylist();
  760.     if (nextPlaylist) {
  761.       videojs.log.warn('Problem encountered with the current ' +
  762.                        'HLS playlist. Switching to another playlist.');
  764.       return this.masterPlaylistLoader_.media(nextPlaylist);
  765.     }
  766.     videojs.log.warn('Problem encountered with the current ' +
  767.                      'HLS playlist. No suitable alternatives found.');
  768.     // We have no more playlists we can select so we must fail
  769.     this.error = error;
  770.     return this.mediaSource.endOfStream('network');
  771.   }
  773.   /**
  774.    * Pause all segment loaders
  775.    */
  776.   pauseLoading() {
  777.     this.mainSegmentLoader_.pause();
  778.     if (this.audioPlaylistLoader_) {
  779.       this.audioSegmentLoader_.pause();
  780.     }
  781.   }
  783.   /**
  784.    * set the current time on all segment loaders
  785.    *
  786.    * @param {TimeRange} currentTime the current time to set
  787.    * @return {TimeRange} the current time
  788.    */
  789.   setCurrentTime(currentTime) {
  790.     let buffered = Ranges.findRange(this.tech_.buffered(), currentTime);
  792.     if (!(this.masterPlaylistLoader_ && this.masterPlaylistLoader_.media())) {
  793.       // return immediately if the metadata is not ready yet
  794.       return 0;
  795.     }
  797.     // it's clearly an edge-case but don't thrown an error if asked to
  798.     // seek within an empty playlist
  799.     if (!this.masterPlaylistLoader_.media().segments) {
  800.       return 0;
  801.     }
  803.     // if the seek location is already buffered, continue buffering as
  804.     // usual
  805.     if (buffered && buffered.length) {
  806.       return currentTime;
  807.     }
  809.     // cancel outstanding requests so we begin buffering at the new
  810.     // location
  811.     this.mainSegmentLoader_.abort();
  812.     this.mainSegmentLoader_.resetEverything();
  813.     if (this.audioPlaylistLoader_) {
  814.       this.audioSegmentLoader_.abort();
  815.       this.audioSegmentLoader_.resetEverything();
  816.     }
  818.     if (!this.tech_.paused()) {
  819.       this.mainSegmentLoader_.load();
  820.       if (this.audioPlaylistLoader_) {
  821.         this.audioSegmentLoader_.load();
  822.       }
  823.     }
  824.   }
  826.   /**
  827.    * get the current duration
  828.    *
  829.    * @return {TimeRange} the duration
  830.    */
  831.   duration() {
  832.     if (!this.masterPlaylistLoader_) {
  833.       return 0;
  834.     }
  836.     if (this.mediaSource) {
  837.       return this.mediaSource.duration;
  838.     }
  840.     return Hls.Playlist.duration(this.masterPlaylistLoader_.media());
  841.   }
  843.   /**
  844.    * check the seekable range
  845.    *
  846.    * @return {TimeRange} the seekable range
  847.    */
  848.   seekable() {
  849.     let media;
  850.     let mainSeekable;
  851.     let audioSeekable;
  853.     if (!this.masterPlaylistLoader_) {
  854.       return videojs.createTimeRanges();
  855.     }
  856.     media = this.masterPlaylistLoader_.media();
  857.     if (!media) {
  858.       return videojs.createTimeRanges();
  859.     }
  861.     mainSeekable = Hls.Playlist.seekable(media,
  862.                                          this.masterPlaylistLoader_.expired_);
  863.     if (mainSeekable.length === 0) {
  864.       return mainSeekable;
  865.     }
  867.     if (this.audioPlaylistLoader_) {
  868.       audioSeekable = Hls.Playlist.seekable(this.audioPlaylistLoader_.media(),
  869.                                             this.audioPlaylistLoader_.expired_);
  870.       if (audioSeekable.length === 0) {
  871.         return audioSeekable;
  872.       }
  873.     }
  875.     if (!audioSeekable) {
  876.       // seekable has been calculated based on buffering video data so it
  877.       // can be returned directly
  878.       return mainSeekable;
  879.     }
  881.     return videojs.createTimeRanges([[
  882.       (audioSeekable.start(0) > mainSeekable.start(0)) ? audioSeekable.start(0) :
  883.                                                          mainSeekable.start(0),
  884.       (audioSeekable.end(0) < mainSeekable.end(0)) ? audioSeekable.end(0) :
  885.                                                      mainSeekable.end(0)
  886.     ]]);
  887.   }
  889.   /**
  890.    * Update the player duration
  891.    */
  892.   updateDuration() {
  893.     let oldDuration = this.mediaSource.duration;
  894.     let newDuration = Hls.Playlist.duration(this.masterPlaylistLoader_.media());
  895.     let buffered = this.tech_.buffered();
  896.     let setDuration = () => {
  897.       this.mediaSource.duration = newDuration;
  898.       this.tech_.trigger('durationchange');
  900.       this.mediaSource.removeEventListener('sourceopen', setDuration);
  901.     };
  903.     if (buffered.length > 0) {
  904.       newDuration = Math.max(newDuration, buffered.end(buffered.length - 1));
  905.     }
  907.     // if the duration has changed, invalidate the cached value
  908.     if (oldDuration !== newDuration) {
  909.       // update the duration
  910.       if (this.mediaSource.readyState !== 'open') {
  911.         this.mediaSource.addEventListener('sourceopen', setDuration);
  912.       } else {
  913.         setDuration();
  914.       }
  915.     }
  916.   }
  918.   /**
  919.    * dispose of the MasterPlaylistController and everything
  920.    * that it controls
  921.    */
  922.   dispose() {
  923.     this.masterPlaylistLoader_.dispose();
  924.     this.mainSegmentLoader_.dispose();
  926.     this.audioSegmentLoader_.dispose();
  927.   }
  929.   /**
  930.    * return the master playlist object if we have one
  931.    *
  932.    * @return {Object} the master playlist object that we parsed
  933.    */
  934.   master() {
  935.     return this.masterPlaylistLoader_.master;
  936.   }
  938.   /**
  939.    * return the currently selected playlist
  940.    *
  941.    * @return {Object} the currently selected playlist object that we parsed
  942.    */
  943.   media() {
  944.     // playlist loader will not return media if it has not been fully loaded
  945.     return this.masterPlaylistLoader_.media() || this.initialMedia_;
  946.   }
  948.   /**
  949.    * setup our internal source buffers on our segment Loaders
  950.    *
  951.    * @private
  952.    */
  953.   setupSourceBuffers_() {
  954.     let media = this.masterPlaylistLoader_.media();
  955.     let mimeTypes;
  957.     // wait until a media playlist is available and the Media Source is
  958.     // attached
  959.     if (!media || this.mediaSource.readyState !== 'open') {
  960.       return;
  961.     }
  963.     mimeTypes = mimeTypesForPlaylist_(this.masterPlaylistLoader_.master, media);
  964.     if (mimeTypes.length < 1) {
  965.       this.error =
  966.         'No compatible SourceBuffer configuration for the variant stream:' +
  967.         media.resolvedUri;
  968.       return this.mediaSource.endOfStream('decode');
  969.     }
  970.     this.mainSegmentLoader_.mimeType(mimeTypes[0]);
  971.     if (mimeTypes[1]) {
  972.       this.audioSegmentLoader_.mimeType(mimeTypes[1]);
  973.     }
  975.     // exclude any incompatible variant streams from future playlist
  976.     // selection
  977.     this.excludeIncompatibleVariants_(media);
  978.   }
  980.   /**
  981.    * Blacklist playlists that are known to be codec or
  982.    * stream-incompatible with the SourceBuffer configuration. For
  983.    * instance, Media Source Extensions would cause the video element to
  984.    * stall waiting for video data if you switched from a variant with
  985.    * video and audio to an audio-only one.
  986.    *
  987.    * @param {Object} media a media playlist compatible with the current
  988.    * set of SourceBuffers. Variants in the current master playlist that
  989.    * do not appear to have compatible codec or stream configurations
  990.    * will be excluded from the default playlist selection algorithm
  991.    * indefinitely.
  992.    * @private
  993.    */
  994.   excludeIncompatibleVariants_(media) {
  995.     let master = this.masterPlaylistLoader_.master;
  996.     let codecCount = 2;
  997.     let videoCodec = null;
  998.     let audioProfile = null;
  999.     let codecs;
  1001.     if (media.attributes && media.attributes.CODECS) {
  1002.       codecs = parseCodecs(media.attributes.CODECS);
  1003.       videoCodec = codecs.videoCodec;
  1004.       audioProfile = codecs.audioProfile;
  1005.       codecCount = codecs.codecCount;
  1006.     }
  1007.     master.playlists.forEach(function(variant) {
  1008.       let variantCodecs = {
  1009.         codecCount: 2,
  1010.         videoCodec: null,
  1011.         audioProfile: null
  1012.       };
  1014.       if (variant.attributes && variant.attributes.CODECS) {
  1015.         let codecString = variant.attributes.CODECS;
  1017.         variantCodecs = parseCodecs(codecString);
  1018.         if (window.MediaSource &&
  1019.             window.MediaSource.isTypeSupported &&
  1020.             !window.MediaSource.isTypeSupported('video/mp4; codecs="' + codecString + '"')) {
  1021.           variant.excludeUntil = Infinity;
  1022.         }
  1023.       }
  1025.       // if the streams differ in the presence or absence of audio or
  1026.       // video, they are incompatible
  1027.       if (variantCodecs.codecCount !== codecCount) {
  1028.         variant.excludeUntil = Infinity;
  1029.       }
  1031.       // if h.264 is specified on the current playlist, some flavor of
  1032.       // it must be specified on all compatible variants
  1033.       if (variantCodecs.videoCodec !== videoCodec) {
  1034.         variant.excludeUntil = Infinity;
  1035.       }
  1036.       // HE-AAC ("mp4a.40.5") is incompatible with all other versions of
  1037.       // AAC audio in Chrome 46. Don't mix the two.
  1038.       if ((variantCodecs.audioProfile === '5' && audioProfile !== '5') ||
  1039.           (audioProfile === '5' && variantCodecs.audioProfile !== '5')) {
  1040.         variant.excludeUntil = Infinity;
  1041.       }
  1043.     });
  1044.   }
  1046.   updateAdCues_(media, offset = 0) {
  1047.     AdCueTags.updateAdCues(media, this.cueTagsTrack_, offset);
  1048.   }
  1049. }