Reorganized videojs-hls.js to make it a bit more readable and set it up for further simplification

Steve Heffernan
Showing 7 changed files with 430 additions and 428 deletions
example.html
src/videojs-hls.js
src/xhr.js
test/karma.conf.js
test/localkarma.conf.js
test/switcher/index.html
test/videojs-hls.html
--- a/example.html
View file @b22f4c3
+++ b/example.html
View file @b22f4c3
@@ -16,6 +16,7 @@
  <script src="src/videojs-hls.js"></script>
  <!-- segment handling -->
+  <script src="src/xhr.js"></script>
  <script src="src/flv-tag.js"></script>
  <script src="src/exp-golomb.js"></script>
  <script src="src/h264-stream.js"></script>
--- a/src/videojs-hls.js
View file @b22f4c3
+++ b/src/videojs-hls.js
View file @b22f4c3
 /*
- * video-js-hls
+ * videojs-hls
 *
- *
+ * Copyright (c) 2014 Brightcove
- * Copyright (c) 2013 Brightcove
 * All rights reserved.
 */
@@ -10,273 +9,209 @@
 'use strict';
 var
  // a fudge factor to apply to advertised playlist bitrates to account for
  // temporary flucations in client bandwidth
  bandwidthVariance = 1.1,
+  resolveUrl;
-  /**
+videojs.Hls = videojs.Flash.extend({
-   * A comparator function to sort two playlist object by bandwidth.
+  init: function(player, options, ready) {
-   * @param left {object} a media playlist object
+    var
-   * @param right {object} a media playlist object
+      source = options.source,
-   * @return {number} Greater than zero if the bandwidth attribute of
+      settings = player.options();
-   * left is greater than the corresponding attribute of right. Less
-   * than zero if the bandwidth of right is greater than left and
-   * exactly zero if the two are equal.
-   */
-  playlistBandwidth = function(left, right) {
-    var leftBandwidth, rightBandwidth;
-    if (left.attributes && left.attributes.BANDWIDTH) {
-      leftBandwidth = left.attributes.BANDWIDTH;
-    }
-    leftBandwidth = leftBandwidth || window.Number.MAX_VALUE;
-    if (right.attributes && right.attributes.BANDWIDTH) {
-      rightBandwidth = right.attributes.BANDWIDTH;
-    }
-    rightBandwidth = rightBandwidth || window.Number.MAX_VALUE;
-    return leftBandwidth - rightBandwidth;
-  },
-  /**
+    player.hls = this;
-   * A comparator function to sort two playlist object by resolution (width).
+    delete options.source;
-   * @param left {object} a media playlist object
+    options.swf = settings.flash.swf;
-   * @param right {object} a media playlist object
+    videojs.Flash.call(this, player, options, ready);
-   * @return {number} Greater than zero if the resolution.width attribute of
+    options.source = source;
-   * left is greater than the corresponding attribute of right. Less
+    this.bytesReceived = 0;
-   * than zero if the resolution.width of right is greater than left and
-   * exactly zero if the two are equal.
-   */
-  playlistResolution = function(left, right) {
-    var leftWidth, rightWidth;
-    if (left.attributes && left.attributes.RESOLUTION && left.attributes.RESOLUTION.width) {
+    // TODO: After video.js#1347 is pulled in move these to the prototype
-      leftWidth = left.attributes.RESOLUTION.width;
+    this.currentTime = function() {
+      if (this.lastSeekedTime_) {
+        return this.lastSeekedTime_;
      }
+      // currentTime is zero while the tech is initializing
-    leftWidth = leftWidth || window.Number.MAX_VALUE;
+      if (!this.el() || !this.el().vjs_getProperty) {
+        return 0;
-    if (right.attributes && right.attributes.RESOLUTION && right.attributes.RESOLUTION.width) {
-      rightWidth = right.attributes.RESOLUTION.width;
      }
+      return this.el().vjs_getProperty('currentTime');
-    rightWidth = rightWidth || window.Number.MAX_VALUE;
+    };
+    this.setCurrentTime = function(currentTime) {
-    // NOTE - Fallback to bandwidth sort as appropriate in cases where multiple renditions
+      if (!(this.playlists && this.playlists.media())) {
-    // have the same media dimensions/ resolution
+        // return immediately if the metadata is not ready yet
-    if (leftWidth === rightWidth && left.attributes.BANDWIDTH && right.attributes.BANDWIDTH) {
+        return 0;
-      return left.attributes.BANDWIDTH - right.attributes.BANDWIDTH;
-    } else {
-      return leftWidth - rightWidth;
      }
-  },
-  xhr,
+      // save the seek target so currentTime can report it correctly
+      // while the seek is pending
+      this.lastSeekedTime_ = currentTime;
-  /**
+      // determine the requested segment
-   * TODO - Document this great feature.
+      this.mediaIndex = videojs.Hls.getMediaIndexByTime(this.playlists.media(), currentTime);
-   *
-   * @param playlist
-   * @param time
-   * @returns int
-   */
-  getMediaIndexByTime = function(playlist, time) {
-    var index, counter, timeRanges, currentSegmentRange;
-    timeRanges = [];
+      // abort any segments still being decoded
-    for (index = 0; index < playlist.segments.length; index++) {
+      this.sourceBuffer.abort();
-      currentSegmentRange = {};
-      currentSegmentRange.start = (index === 0) ? 0 : timeRanges[index - 1].end;
-      currentSegmentRange.end = currentSegmentRange.start + playlist.segments[index].duration;
-      timeRanges.push(currentSegmentRange);
-    }
-    for (counter = 0; counter < timeRanges.length; counter++) {
+      // cancel outstanding requests and buffer appends
-      if (time >= timeRanges[counter].start && time < timeRanges[counter].end) {
+      if (this.segmentXhr_) {
-        return counter;
+        this.segmentXhr_.abort();
-      }
      }
-    return -1;
+      // clear out any buffered segments
+      this.segmentBuffer_ = [];
-  },
-  /**
+      // begin filling the buffer at the new position
-   * Determine the media index in one playlist that corresponds to a
+      this.fillBuffer(currentTime * 1000);
-   * specified media index in another. This function can be used to
+    };
-   * calculate a new segment position when a playlist is reloaded or a
-   * variant playlist is becoming active.
-   * @param mediaIndex {number} the index into the original playlist
-   * to translate
-   * @param original {object} the playlist to translate the media
-   * index from
-   * @param update {object} the playlist to translate the media index
-   * to
-   * @param {number} the corresponding media index in the updated
-   * playlist
-   */
-  translateMediaIndex = function(mediaIndex, original, update) {
-    var
-      i,
-      originalSegment;
-    // no segments have been loaded from the original playlist
+    videojs.Hls.prototype.src.call(this, options.source && options.source.src);
-    if (mediaIndex === 0) {
-      return 0;
-    }
-    if (!(update && update.segments)) {
-      // let the media index be zero when there are no segments defined
-      return 0;
  }
+});
-    // try to sync based on URI
+// Add HLS to the standard tech order
-    i = update.segments.length;
+videojs.options.techOrder.unshift('hls');
-    originalSegment = original.segments[mediaIndex - 1];
-    while (i--) {
-      if (originalSegment.uri === update.segments[i].uri) {
-        return i + 1;
-      }
-    }
-    // sync on media sequence
+// the desired length of video to maintain in the buffer, in seconds
-    return (original.mediaSequence + mediaIndex) - update.mediaSequence;
+videojs.Hls.GOAL_BUFFER_LENGTH = 30;
-  },
-  /**
+videojs.Hls.prototype.src = function(src) {
-   * Calculate the duration of a playlist from a given start index to a given
+  var
-   * end index.
+    self = this,
-   * @param playlist {object} a media playlist object
+    mediaSource,
-   * @param startIndex {number} an inclusive lower boundary for the playlist.
+    source;
-   * Defaults to 0.
-   * @param endIndex {number} an exclusive upper boundary for the playlist.
-   * Defaults to playlist length.
-   * @return {number} the duration between the start index and end index.
-   */
-  duration = function(playlist, startIndex, endIndex) {
-    var dur = 0,
-        segment,
-        i;
-    startIndex = startIndex || 0;
+  if (src) {
-    endIndex = endIndex !== undefined ? endIndex : (playlist.segments || []).length;
+    this.src_ = src;
-    i = endIndex - 1;
-    for (; i >= startIndex; i--) {
+    mediaSource = new videojs.MediaSource();
-      segment = playlist.segments[i];
+    source = {
-      dur += segment.duration || playlist.targetDuration || 0;
+      src: videojs.URL.createObjectURL(mediaSource),
-    }
+      type: "video/flv"
+    };
+    this.mediaSource = mediaSource;
-    return dur;
+    this.segmentBuffer_ = [];
-  },
+    this.segmentParser_ = new videojs.Hls.SegmentParser();
-  /**
+    // load the MediaSource into the player
-   * Calculate the total duration for a playlist based on segment metadata.
+    this.mediaSource.addEventListener('sourceopen', videojs.bind(this, this.handleSourceOpen));
-   * @param playlist {object} a media playlist object
-   * @return {number} the currently known duration, in seconds
-   */
-  totalDuration = function(playlist) {
-    if (!playlist) {
-      return 0;
-    }
-    // if present, use the duration specified in the playlist
+    this.player().ready(function() {
-    if (playlist.totalDuration) {
+      // do nothing if the tech has been disposed already
-      return playlist.totalDuration;
+      // this can occur if someone sets the src in player.ready(), for instance
+      if (!self.el()) {
+        return;
      }
+      self.el().vjs_src(source.src);
-    // duration should be Infinity for live playlists
+    });
-    if (!playlist.endList) {
-      return window.Infinity;
  }
+};
-    return duration(playlist);
+videojs.Hls.prototype.handleSourceOpen = function() {
-  },
+  // construct the video data buffer and set the appropriate MIME type
-  resolveUrl,
-  initSource = function(player, mediaSource, srcUrl) {
  var
-      segmentParser = new videojs.Hls.SegmentParser(),
+    player = this.player(),
-      settings = videojs.util.mergeOptions({}, player.options().hls),
+    settings = player.options().hls || {},
-      segmentBuffer = [],
+    sourceBuffer = this.mediaSource.addSourceBuffer('video/flv; codecs="vp6,aac"'),
+    oldMediaPlaylist;
-      lastSeekedTime,
+  this.sourceBuffer = sourceBuffer;
-      segmentXhr,
+  sourceBuffer.appendBuffer(this.segmentParser_.getFlvHeader());
-      fillBuffer,
-      drainBuffer,
-      updateDuration;
+  this.mediaIndex = 0;
+  this.playlists = new videojs.Hls.PlaylistLoader(this.src_, settings.withCredentials);
-    player.hls.currentTime = function() {
+  this.playlists.on('loadedmetadata', videojs.bind(this, function() {
-      if (lastSeekedTime) {
+    oldMediaPlaylist = this.playlists.media();
-        return lastSeekedTime;
-      }
-      // currentTime is zero while the tech is initializing
-      if (!this.el() || !this.el().vjs_getProperty) {
-        return 0;
-      }
-      return this.el().vjs_getProperty('currentTime');
-    };
-    player.hls.setCurrentTime = function(currentTime) {
+    // periodically check if new data needs to be downloaded or
-      if (!(this.playlists && this.playlists.media())) {
+    // buffered data should be appended to the source buffer
-        // return immediately if the metadata is not ready yet
+    this.fillBuffer();
-        return 0;
+    player.on('timeupdate', videojs.bind(this, this.fillBuffer));
-      }
+    player.on('timeupdate', videojs.bind(this, this.drainBuffer));
+    player.on('waiting', videojs.bind(this, this.drainBuffer));
-      // save the seek target so currentTime can report it correctly
+    player.trigger('loadedmetadata');
-      // while the seek is pending
+  }));
-      lastSeekedTime = currentTime;
-      // determine the requested segment
+  this.playlists.on('error', videojs.bind(this, function() {
-      this.mediaIndex =
+    player.error(this.playlists.error);
-          getMediaIndexByTime(this.playlists.media(), currentTime);
+  }));
-      // abort any segments still being decoded
+  this.playlists.on('loadedplaylist', videojs.bind(this, function() {
-      this.sourceBuffer.abort();
+    var updatedPlaylist = this.playlists.media();
-      // cancel outstanding requests and buffer appends
+    if (!updatedPlaylist) {
-      if (segmentXhr) {
+      // do nothing before an initial media playlist has been activated
-        segmentXhr.abort();
+      return;
    }
-      // clear out any buffered segments
+    this.updateDuration(this.playlists.media());
-      segmentBuffer = [];
+    this.mediaIndex = videojs.Hls.translateMediaIndex(this.mediaIndex, oldMediaPlaylist, updatedPlaylist);
+    oldMediaPlaylist = updatedPlaylist;
+  }));
-      // begin filling the buffer at the new position
+  this.playlists.on('mediachange', function() {
-      fillBuffer(currentTime * 1000);
+    player.trigger('mediachange');
-    };
+  });
+};
+videojs.Hls.prototype.duration = function() {
+  var playlists = this.playlists;
+  if (playlists) {
+    return videojs.Hls.getPlaylistTotalDuration(playlists.media());
+  }
+  return 0;
+};
-    /**
+/**
 * Update the player duration
 */
-    updateDuration = function(playlist) {
+videojs.Hls.prototype.updateDuration = function(playlist) {
-      var oldDuration = player.duration(),
+  var player = this.player(),
-          newDuration = totalDuration(playlist);
+      oldDuration = player.duration(),
+      newDuration = videojs.Hls.getPlaylistTotalDuration(playlist);
  // if the duration has changed, invalidate the cached value
  if (oldDuration !== newDuration) {
    player.trigger('durationchange');
  }
-    };
+};
-    /**
+/**
+ * Abort all outstanding work and cleanup.
+ */
+videojs.Hls.prototype.dispose = function() {
+  if (this.segmentXhr_) {
+    this.segmentXhr_.onreadystatechange = null;
+    this.segmentXhr_.abort();
+  }
+  if (this.playlists) {
+    this.playlists.dispose();
+  }
+  videojs.Flash.prototype.dispose.call(this);
+};
+/**
 * Chooses the appropriate media playlist based on the current
 * bandwidth estimate and the player size.
 * @return the highest bitrate playlist less than the currently detected
 * bandwidth, accounting for some amount of bandwidth variance
 */
-    player.hls.selectPlaylist = function () {
+videojs.Hls.prototype.selectPlaylist = function () {
  var
+    player = this.player(),
    effectiveBitrate,
-        sortedPlaylists = player.hls.playlists.master.playlists.slice(),
+    sortedPlaylists = this.playlists.master.playlists.slice(),
    bandwidthPlaylists = [],
    i = sortedPlaylists.length,
    variant,
    bandwidthBestVariant,
    resolutionBestVariant;
-      sortedPlaylists.sort(playlistBandwidth);
+  sortedPlaylists.sort(videojs.Hls.comparePlaylistBandwidth);
  // filter out any variant that has greater effective bitrate
  // than the current estimated bandwidth
@@ -304,7 +239,7 @@ var
  i = bandwidthPlaylists.length;
  // sort variants by resolution
-      bandwidthPlaylists.sort(playlistResolution);
+  bandwidthPlaylists.sort(videojs.Hls.comparePlaylistResolution);
  // iterate through the bandwidth-filtered playlists and find
  // best rendition by player dimension
@@ -331,30 +266,19 @@ var
  // fallback chain of variants
  return resolutionBestVariant || bandwidthBestVariant || sortedPlaylists[0];
-    };
+};
-    /**
-     * Abort all outstanding work and cleanup.
-     */
-    player.hls.dispose = function() {
-      if (segmentXhr) {
-        segmentXhr.onreadystatechange = null;
-        segmentXhr.abort();
-      }
-      if (this.playlists) {
-        this.playlists.dispose();
-      }
-      videojs.Flash.prototype.dispose.call(this);
-    };
-    /**
+/**
 * Determines whether there is enough video data currently in the buffer
 * and downloads a new segment if the buffered time is less than the goal.
 * @param offset (optional) {number} the offset into the downloaded segment
 * to seek to, in milliseconds
 */
-    fillBuffer = function(offset) {
+videojs.Hls.prototype.fillBuffer = function(offset) {
  var
+    self = this,
+    player = this.player(),
+    settings = player.options().hls || {},
    buffered = player.buffered(),
    bufferedTime = 0,
    segment,
@@ -362,18 +286,18 @@ var
    startTime;
  // if there is a request already in flight, do nothing
-      if (segmentXhr) {
+  if (this.segmentXhr_) {
    return;
  }
  // if no segments are available, do nothing
-      if (player.hls.playlists.state === "HAVE_NOTHING" ||
+  if (this.playlists.state === "HAVE_NOTHING" ||
-          !player.hls.playlists.media().segments) {
+      !this.playlists.media().segments) {
    return;
  }
  // if the video has finished downloading, stop trying to buffer
-      segment = player.hls.playlists.media().segments[player.hls.mediaIndex];
+  segment = this.playlists.media().segments[this.mediaIndex];
  if (!segment) {
    return;
  }
@@ -391,17 +315,17 @@ var
  }
  // resolve the segment URL relative to the playlist
-      if (player.hls.playlists.media().uri === srcUrl) {
+  if (this.playlists.media().uri === this.src_) {
-        segmentUri = resolveUrl(srcUrl, segment.uri);
+    segmentUri = resolveUrl(this.src_, segment.uri);
  } else {
-        segmentUri = resolveUrl(resolveUrl(srcUrl, player.hls.playlists.media().uri || ''),
+    segmentUri = resolveUrl(resolveUrl(this.src_, this.playlists.media().uri || ''),
                            segment.uri);
  }
  startTime = +new Date();
  // request the next segment
-      segmentXhr = xhr({
+  this.segmentXhr_ = videojs.Hls.xhr({
    url: segmentUri,
    responseType: 'arraybuffer',
    withCredentials: settings.withCredentials
@@ -409,23 +333,23 @@ var
    var tags;
    // the segment request is no longer outstanding
-        segmentXhr = null;
+    self.segmentXhr_ = null;
    if (error) {
      // if a segment request times out, we may have better luck with another playlist
      if (error === 'timeout') {
-            player.hls.bandwidth = 1;
+        self.bandwidth = 1;
-            return player.hls.playlists.media(player.hls.selectPlaylist());
+        return self.playlists.media(self.selectPlaylist());
      }
      // otherwise, try jumping ahead to the next segment
-          player.hls.error = {
+      self.error = {
        status: this.status,
        message: 'HLS segment request error at URL: ' + url,
        code: (this.status >= 500) ? 4 : 2
      };
      // try moving on to the next segment
-          player.hls.mediaIndex++;
+      self.mediaIndex++;
      return;
    }
@@ -435,39 +359,39 @@ var
    }
    // calculate the download bandwidth
-        player.hls.segmentXhrTime = (+new Date()) - startTime;
+    self.segmentXhrTime = (+new Date()) - startTime;
-        player.hls.bandwidth = (this.response.byteLength / player.hls.segmentXhrTime) * 8 * 1000;
+    self.bandwidth = (this.response.byteLength / player.hls.segmentXhrTime) * 8 * 1000;
-        player.hls.bytesReceived += this.response.byteLength;
+    self.bytesReceived += this.response.byteLength;
    // transmux the segment data from MP2T to FLV
-        segmentParser.parseSegmentBinaryData(new Uint8Array(this.response));
+    self.segmentParser_.parseSegmentBinaryData(new Uint8Array(this.response));
-        segmentParser.flushTags();
+    self.segmentParser_.flushTags();
    // package up all the work to append the segment
    // if the segment is the start of a timestamp discontinuity,
    // we have to wait until the sourcebuffer is empty before
    // aborting the source buffer processing
    tags = [];
-        while (segmentParser.tagsAvailable()) {
+    while (self.segmentParser_.tagsAvailable()) {
-          tags.push(segmentParser.getNextTag());
+      tags.push(self.segmentParser_.getNextTag());
    }
-        segmentBuffer.push({
+    self.segmentBuffer_.push({
-          mediaIndex: player.hls.mediaIndex,
+      mediaIndex: self.mediaIndex,
-          playlist: player.hls.playlists.media(),
+      playlist: self.playlists.media(),
      offset: offset,
      tags: tags
    });
-        drainBuffer();
+    self.drainBuffer();
-        player.hls.mediaIndex++;
+    self.mediaIndex++;
    // figure out what stream the next segment should be downloaded from
    // with the updated bandwidth information
-        player.hls.playlists.media(player.hls.selectPlaylist());
+    self.playlists.media(self.selectPlaylist());
  });
-    };
+};
-    drainBuffer = function(event) {
+videojs.Hls.prototype.drainBuffer = function(event) {
  var
    i = 0,
    mediaIndex,
@@ -477,7 +401,8 @@ var
    segment,
    ptsTime,
-        segmentOffset;
+    segmentOffset,
+    segmentBuffer = this.segmentBuffer_;
  if (!segmentBuffer.length) {
    return;
@@ -490,7 +415,7 @@ var
  segment = playlist.segments[mediaIndex];
  event = event || {};
-      segmentOffset = duration(playlist, 0, mediaIndex) * 1000;
+  segmentOffset = videojs.Hls.getPlaylistDuration(playlist, 0, mediaIndex) * 1000;
  // abort() clears any data queued in the source buffer so wait
  // until it empties before calling it when a discontinuity is
@@ -499,9 +424,9 @@ var
    if (event.type !== 'waiting') {
      return;
    }
-        player.hls.sourceBuffer.abort();
+    this.sourceBuffer.abort();
    // tell the SWF where playback is continuing in the stitched timeline
-        player.hls.el().vjs_setProperty('currentTime', segmentOffset * 0.001);
+    this.el().vjs_setProperty('currentTime', segmentOffset * 0.001);
  }
  // if we're refilling the buffer after a seek, scan through the muxed
@@ -515,11 +440,11 @@ var
    }
    // tell the SWF where we will be seeking to
-        player.hls.el().vjs_setProperty('currentTime', (tags[i].pts - tags[0].pts + segmentOffset) * 0.001);
+    this.el().vjs_setProperty('currentTime', (tags[i].pts - tags[0].pts + segmentOffset) * 0.001);
    tags = tags.slice(i);
-        lastSeekedTime = null;
+    this.lastSeekedTime_ = null;
  }
  for (i = 0; i < tags.length; i++) {
@@ -527,83 +452,16 @@ var
    // the queue gives control back to the browser between tags
    // so that large segments don't cause a "hiccup" in playback
-        player.hls.sourceBuffer.appendBuffer(tags[i].bytes, player);
+    this.sourceBuffer.appendBuffer(tags[i].bytes, this.player());
  }
  // we're done processing this segment
  segmentBuffer.shift();
  if (mediaIndex === playlist.segments.length) {
-        mediaSource.endOfStream();
+    this.mediaSource.endOfStream();
-      }
-    };
-    // load the MediaSource into the player
-    mediaSource.addEventListener('sourceopen', function() {
-      // construct the video data buffer and set the appropriate MIME type
-      var
-        sourceBuffer = mediaSource.addSourceBuffer('video/flv; codecs="vp6,aac"'),
-        oldMediaPlaylist;
-      player.hls.sourceBuffer = sourceBuffer;
-      sourceBuffer.appendBuffer(segmentParser.getFlvHeader());
-      player.hls.mediaIndex = 0;
-      player.hls.playlists =
-        new videojs.Hls.PlaylistLoader(srcUrl, settings.withCredentials);
-      player.hls.playlists.on('loadedmetadata', function() {
-        oldMediaPlaylist = player.hls.playlists.media();
-        // periodically check if new data needs to be downloaded or
-        // buffered data should be appended to the source buffer
-        fillBuffer();
-        player.on('timeupdate', fillBuffer);
-        player.on('timeupdate', drainBuffer);
-        player.on('waiting', drainBuffer);
-        player.trigger('loadedmetadata');
-      });
-      player.hls.playlists.on('error', function() {
-        player.error(player.hls.playlists.error);
-      });
-      player.hls.playlists.on('loadedplaylist', function() {
-        var updatedPlaylist = player.hls.playlists.media();
-        if (!updatedPlaylist) {
-          // do nothing before an initial media playlist has been activated
-          return;
  }
+};
-        updateDuration(player.hls.playlists.media());
-        player.hls.mediaIndex = translateMediaIndex(player.hls.mediaIndex,
-                                                    oldMediaPlaylist,
-                                                    updatedPlaylist);
-        oldMediaPlaylist = updatedPlaylist;
-      });
-      player.hls.playlists.on('mediachange', function() {
-        player.trigger('mediachange');
-      });
-    });
-  };
-var mpegurlRE = /^application\/(?:x-|vnd\.apple\.)mpegurl/i;
-videojs.Hls = videojs.Flash.extend({
-  init: function(player, options, ready) {
-    var
-      source = options.source,
-      settings = player.options();
-    player.hls = this;
-    delete options.source;
-    options.swf = settings.flash.swf;
-    videojs.Flash.call(this, player, options, ready);
-    options.source = source;
-    this.bytesReceived = 0;
-    videojs.Hls.prototype.src.call(this, options.source && options.source.src);
-  }
-});
 /**
 * Whether the browser has built-in HLS support.
@@ -625,43 +483,6 @@ videojs.Hls.supportsNativeHls = (function() {
    (/probably|maybe/).test(vndMpeg);
 })();
-// the desired length of video to maintain in the buffer, in seconds
-videojs.Hls.GOAL_BUFFER_LENGTH = 30;
-videojs.Hls.prototype.src = function(src) {
-  var
-    player = this.player(),
-    self = this,
-    mediaSource,
-    source;
-  if (src) {
-    mediaSource = new videojs.MediaSource();
-    source = {
-      src: videojs.URL.createObjectURL(mediaSource),
-      type: "video/flv"
-    };
-    this.mediaSource = mediaSource;
-    initSource(player, mediaSource, src);
-    this.player().ready(function() {
-      // do nothing if the tech has been disposed already
-      // this can occur if someone sets the src in player.ready(), for instance
-      if (!self.el()) {
-        return;
-      }
-      self.el().vjs_src(source.src);
-    });
-  }
-};
-videojs.Hls.prototype.duration = function() {
-  var playlists = this.playlists;
-  if (playlists) {
-    return totalDuration(playlists.media());
-  }
-  return 0;
-};
 videojs.Hls.isSupported = function() {
  return !videojs.Hls.supportsNativeHls &&
    videojs.Flash.isSupported() &&
@@ -669,89 +490,182 @@ videojs.Hls.isSupported = function() {
 };
 videojs.Hls.canPlaySource = function(srcObj) {
+  var mpegurlRE = /^application\/(?:x-|vnd\.apple\.)mpegurl/i;
  return mpegurlRE.test(srcObj.type);
 };
 /**
- * Creates and sends an XMLHttpRequest.
+ * Calculate the duration of a playlist from a given start index to a given
- * @param options {string | object} if this argument is a string, it
+ * end index.
- * is intrepreted as a URL and a simple GET request is
+ * @param playlist {object} a media playlist object
- * inititated. If it is an object, it should contain a `url`
+ * @param startIndex {number} an inclusive lower boundary for the playlist.
- * property that indicates the URL to request and optionally a
+ * Defaults to 0.
- * `method` which is the type of HTTP request to send.
+ * @param endIndex {number} an exclusive upper boundary for the playlist.
- * @param callback (optional) {function} a function to call when the
+ * Defaults to playlist length.
- * request completes. If the request was not successful, the first
+ * @return {number} the duration between the start index and end index.
- * argument will be falsey.
- * @return {object} the XMLHttpRequest that was initiated.
 */
-xhr = videojs.Hls.xhr = function(url, callback) {
+videojs.Hls.getPlaylistDuration = function(playlist, startIndex, endIndex) {
-  var
+  var dur = 0,
-    options = {
+      segment,
-      method: 'GET',
+      i;
-      timeout: 45 * 1000
-    },
-    request,
-    abortTimeout;
-  if (typeof callback !== 'function') {
+  startIndex = startIndex || 0;
-    callback = function() {};
+  endIndex = endIndex !== undefined ? endIndex : (playlist.segments || []).length;
+  i = endIndex - 1;
+  for (; i >= startIndex; i--) {
+    segment = playlist.segments[i];
+    dur += segment.duration || playlist.targetDuration || 0;
  }
-  if (typeof url === 'object') {
+  return dur;
-    options = videojs.util.mergeOptions(options, url);
+};
-    url = options.url;
+/**
+ * Calculate the total duration for a playlist based on segment metadata.
+ * @param playlist {object} a media playlist object
+ * @return {number} the currently known duration, in seconds
+ */
+videojs.Hls.getPlaylistTotalDuration = function(playlist) {
+  if (!playlist) {
+    return 0;
  }
-  request = new window.XMLHttpRequest();
+  // if present, use the duration specified in the playlist
-  request.open(options.method, url);
+  if (playlist.totalDuration) {
-  request.url = url;
+    return playlist.totalDuration;
+  }
-  if (options.responseType) {
+  // duration should be Infinity for live playlists
-    request.responseType = options.responseType;
+  if (!playlist.endList) {
+    return window.Infinity;
  }
-  if (options.withCredentials) {
-    request.withCredentials = true;
+  return videojs.Hls.getPlaylistDuration(playlist);
+};
+/**
+ * Determine the media index in one playlist that corresponds to a
+ * specified media index in another. This function can be used to
+ * calculate a new segment position when a playlist is reloaded or a
+ * variant playlist is becoming active.
+ * @param mediaIndex {number} the index into the original playlist
+ * to translate
+ * @param original {object} the playlist to translate the media
+ * index from
+ * @param update {object} the playlist to translate the media index
+ * to
+ * @param {number} the corresponding media index in the updated
+ * playlist
+ */
+videojs.Hls.translateMediaIndex = function(mediaIndex, original, update) {
+  var
+    i,
+    originalSegment;
+  // no segments have been loaded from the original playlist
+  if (mediaIndex === 0) {
+    return 0;
  }
-  if (options.timeout) {
+  if (!(update && update.segments)) {
-    if (request.timeout === 0) {
+    // let the media index be zero when there are no segments defined
-      request.timeout = options.timeout;
+    return 0;
-      request.ontimeout = function() {
-        request.timedout = true;
-      };
-    } else {
-      // polyfill XHR2 by aborting after the timeout
-      abortTimeout = window.setTimeout(function() {
-        if (request.readyState !== 4) {
-          request.timedout = true;
-          request.abort();
  }
-      }, options.timeout);
+  // try to sync based on URI
+  i = update.segments.length;
+  originalSegment = original.segments[mediaIndex - 1];
+  while (i--) {
+    if (originalSegment.uri === update.segments[i].uri) {
+      return i + 1;
    }
  }
-  request.onreadystatechange = function() {
+  // sync on media sequence
-    // wait until the request completes
+  return (original.mediaSequence + mediaIndex) - update.mediaSequence;
-    if (this.readyState !== 4) {
+};
-      return;
+/**
+ * TODO - Document this great feature.
+ *
+ * @param playlist
+ * @param time
+ * @returns int
+ */
+videojs.Hls.getMediaIndexByTime = function(playlist, time) {
+  var index, counter, timeRanges, currentSegmentRange;
+  timeRanges = [];
+  for (index = 0; index < playlist.segments.length; index++) {
+    currentSegmentRange = {};
+    currentSegmentRange.start = (index === 0) ? 0 : timeRanges[index - 1].end;
+    currentSegmentRange.end = currentSegmentRange.start + playlist.segments[index].duration;
+    timeRanges.push(currentSegmentRange);
+  }
+  for (counter = 0; counter < timeRanges.length; counter++) {
+    if (time >= timeRanges[counter].start && time < timeRanges[counter].end) {
+      return counter;
+    }
  }
-    // clear outstanding timeouts
+  return -1;
-    window.clearTimeout(abortTimeout);
+};
-    // request timeout
+/**
-    if (request.timedout) {
+ * A comparator function to sort two playlist object by bandwidth.
-      return callback.call(this, 'timeout', url);
+ * @param left {object} a media playlist object
+ * @param right {object} a media playlist object
+ * @return {number} Greater than zero if the bandwidth attribute of
+ * left is greater than the corresponding attribute of right. Less
+ * than zero if the bandwidth of right is greater than left and
+ * exactly zero if the two are equal.
+ */
+videojs.Hls.comparePlaylistBandwidth = function(left, right) {
+  var leftBandwidth, rightBandwidth;
+  if (left.attributes && left.attributes.BANDWIDTH) {
+    leftBandwidth = left.attributes.BANDWIDTH;
  }
+  leftBandwidth = leftBandwidth || window.Number.MAX_VALUE;
+  if (right.attributes && right.attributes.BANDWIDTH) {
+    rightBandwidth = right.attributes.BANDWIDTH;
+  }
+  rightBandwidth = rightBandwidth || window.Number.MAX_VALUE;
-    // request aborted or errored
+  return leftBandwidth - rightBandwidth;
-    if (this.status >= 400 || this.status === 0) {
+};
-      return callback.call(this, true, url);
+/**
+ * A comparator function to sort two playlist object by resolution (width).
+ * @param left {object} a media playlist object
+ * @param right {object} a media playlist object
+ * @return {number} Greater than zero if the resolution.width attribute of
+ * left is greater than the corresponding attribute of right. Less
+ * than zero if the resolution.width of right is greater than left and
+ * exactly zero if the two are equal.
+ */
+videojs.Hls.comparePlaylistResolution = function(left, right) {
+  var leftWidth, rightWidth;
+  if (left.attributes && left.attributes.RESOLUTION && left.attributes.RESOLUTION.width) {
+    leftWidth = left.attributes.RESOLUTION.width;
  }
-    return callback.call(this, false, url);
+  leftWidth = leftWidth || window.Number.MAX_VALUE;
-  };
-  request.send(null);
+  if (right.attributes && right.attributes.RESOLUTION && right.attributes.RESOLUTION.width) {
-  return request;
+    rightWidth = right.attributes.RESOLUTION.width;
+  }
+  rightWidth = rightWidth || window.Number.MAX_VALUE;
+  // NOTE - Fallback to bandwidth sort as appropriate in cases where multiple renditions
+  // have the same media dimensions/ resolution
+  if (leftWidth === rightWidth && left.attributes.BANDWIDTH && right.attributes.BANDWIDTH) {
+    return left.attributes.BANDWIDTH - right.attributes.BANDWIDTH;
+  } else {
+    return leftWidth - rightWidth;
+  }
 };
 /**
@@ -793,7 +707,4 @@ resolveUrl = videojs.Hls.resolveUrl = function(basePath, path) {
  return result;
 };
-// Add HLS to the standard tech order
-videojs.options.techOrder.unshift('hls');
 })(window, window.videojs, document);
--- a/src/xhr.js 0 → 100644
View file @b22f4c3
+++ b/src/xhr.js 0 → 100644
View file @b22f4c3
+(function(videojs){
+  /**
+   * Creates and sends an XMLHttpRequest.
+   * TODO - expose video.js core's XHR and use that instead
+   * 
+   * @param options {string | object} if this argument is a string, it
+   * is intrepreted as a URL and a simple GET request is
+   * inititated. If it is an object, it should contain a `url`
+   * property that indicates the URL to request and optionally a
+   * `method` which is the type of HTTP request to send.
+   * @param callback (optional) {function} a function to call when the
+   * request completes. If the request was not successful, the first
+   * argument will be falsey.
+   * @return {object} the XMLHttpRequest that was initiated.
+   */
+   videojs.Hls.xhr = function(url, callback) {
+    var
+      options = {
+        method: 'GET',
+        timeout: 45 * 1000
+      },
+      request,
+      abortTimeout;
+    if (typeof callback !== 'function') {
+      callback = function() {};
+    }
+    if (typeof url === 'object') {
+      options = videojs.util.mergeOptions(options, url);
+      url = options.url;
+    }
+    request = new window.XMLHttpRequest();
+    request.open(options.method, url);
+    request.url = url;
+    if (options.responseType) {
+      request.responseType = options.responseType;
+    }
+    if (options.withCredentials) {
+      request.withCredentials = true;
+    }
+    if (options.timeout) {
+      if (request.timeout === 0) {
+        request.timeout = options.timeout;
+        request.ontimeout = function() {
+          request.timedout = true;
+        };
+      } else {
+        // polyfill XHR2 by aborting after the timeout
+        abortTimeout = window.setTimeout(function() {
+          if (request.readyState !== 4) {
+            request.timedout = true;
+            request.abort();
+          }
+        }, options.timeout);
+      }
+    }
+    request.onreadystatechange = function() {
+      // wait until the request completes
+      if (this.readyState !== 4) {
+        return;
+      }
+      // clear outstanding timeouts
+      window.clearTimeout(abortTimeout);
+      // request timeout
+      if (request.timedout) {
+        return callback.call(this, 'timeout', url);
+      }
+      // request aborted or errored
+      if (this.status >= 400 || this.status === 0) {
+        return callback.call(this, true, url);
+      }
+      return callback.call(this, false, url);
+    };
+    request.send(null);
+    return request;
+  };
+})(window.videojs);
\ No newline at end of file
--- a/test/karma.conf.js
View file @b22f4c3
+++ b/test/karma.conf.js
View file @b22f4c3
@@ -79,6 +79,7 @@ module.exports = function(config) {
      '../node_modules/videojs-contrib-media-sources/src/videojs-media-sources.js',
      '../test/karma-qunit-shim.js',
      '../src/videojs-hls.js',
+      '../src/xhr.js',
      '../src/flv-tag.js',
      '../src/exp-golomb.js',
      '../src/h264-stream.js',
--- a/test/localkarma.conf.js
View file @b22f4c3
+++ b/test/localkarma.conf.js
View file @b22f4c3
@@ -43,6 +43,7 @@ module.exports = function(config) {
      '../node_modules/videojs-contrib-media-sources/src/videojs-media-sources.js',
      '../test/karma-qunit-shim.js',
      '../src/videojs-hls.js',
+      '../src/xhr.js',
      '../src/flv-tag.js',
      '../src/exp-golomb.js',
      '../src/h264-stream.js',
--- a/test/switcher/index.html
View file @b22f4c3
+++ b/test/switcher/index.html
View file @b22f4c3
@@ -123,6 +123,7 @@
  <script src="../../node_modules/video.js/dist/video-js/video.js"></script>
  <script src="../../node_modules/videojs-contrib-media-sources/src/videojs-media-sources.js"></script>
  <script src="../../src/videojs-hls.js"></script>
+  <script src="../../src/xhr.js"></script>
  <script src="../../src/stream.js"></script>
  <script src="../../src/m3u8/m3u8-parser.js"></script>
  <script src="../../src/playlist-loader.js"></script>
--- a/test/videojs-hls.html
View file @b22f4c3
+++ b/test/videojs-hls.html
View file @b22f4c3
@@ -20,6 +20,7 @@
  <!-- HLS plugin -->
  <script src="../src/videojs-hls.js"></script>
+  <script src="../src/xhr.js"></script>
  <script src="../src/flv-tag.js"></script>
  <script src="../src/exp-golomb.js"></script>
  <script src="../src/h264-stream.js"></script>