Merge pull request #411 from dmlap/next-segment-calculation

Determine the segment to load by looking at buffered

 (function(window) {
+  var textRange = function(range, i) {
+    return range.start(i) + '-' + range.end(i);
+  };
   var module = {
     hexDump: function(data) {
       var
@@ -26,6 +29,13 @@
     },
     tagDump: function(tag) {
       return module.hexDump(tag.bytes);
+    },
+    textRanges: function(ranges) {
+      var result = '', i;
+      for (i = 0; i < ranges.length; i++) {
+        result += textRange(ranges, i) + ' ';
+      }
+      return result;
     }
   };
 

@@ -2,13 +2,7 @@
  * playlist-loader
  *
  * A state machine that manages the loading, caching, and updating of
- * M3U8 playlists. When tracking a live playlist, loaders will keep
- * track of the duration of content that expired since the loader was
- * initialized and when the current discontinuity sequence was
- * encountered. A complete media timeline for a live playlist with
- * expiring segments looks like this:
- *
- * |-- expired --|-- segments --|
+ * M3U8 playlists.
  *
  */
 (function(window, videojs) {
@@ -16,7 +10,6 @@
   var
     resolveUrl = videojs.Hls.resolveUrl,
     xhr = videojs.Hls.xhr,
-    Playlist = videojs.Hls.Playlist,
     mergeOptions = videojs.mergeOptions,
 
     /**
@@ -158,14 +151,6 @@
       // initialize the loader state
       loader.state = 'HAVE_NOTHING';
 
-      // The total duration of all segments that expired and have been
-      // removed from the current playlist, in seconds. This property
-      // should always be zero for non-live playlists. In a live
-      // playlist, this is the total amount of time that has been
-      // removed from the stream since the playlist loader began
-      // tracking it.
-      loader.expired_ = 0;
-
       // capture the prototype dispose function
       dispose = this.dispose;
 
@@ -187,20 +172,20 @@
        * active media playlist. When called with a single argument,
        * triggers the playlist loader to asynchronously switch to the
        * specified media playlist. Calling this method while the
-       * loader is in the HAVE_NOTHING or HAVE_MASTER states causes an
-       * error to be emitted but otherwise has no effect.
+       * loader is in the HAVE_NOTHING causes an error to be emitted
+       * but otherwise has no effect.
        * @param playlist (optional) {object} the parsed media playlist
        * object to switch to
        */
       loader.media = function(playlist) {
-        var mediaChange = false;
+        var startingState = loader.state, mediaChange;
         // getter
         if (!playlist) {
           return loader.media_;
         }
 
         // setter
-        if (loader.state === 'HAVE_NOTHING' || loader.state === 'HAVE_MASTER') {
+        if (loader.state === 'HAVE_NOTHING') {
           throw new Error('Cannot switch media playlist from ' + loader.state);
         }
 
@@ -213,7 +198,7 @@
           playlist = loader.master.playlists[playlist];
         }
 
-        mediaChange = playlist.uri !== loader.media_.uri;
+        mediaChange = !loader.media_ || playlist.uri !== loader.media_.uri;
 
         // switch to fully loaded playlists immediately
         if (loader.master.playlists[playlist.uri].endList) {
@@ -258,7 +243,17 @@
           withCredentials: withCredentials
         }, function(error, request) {
           haveMetadata(error, request, playlist.uri);
+
+          if (error) {
+            return;
+          }
+
+          // fire loadedmetadata the first time a media playlist is loaded
+          if (startingState === 'HAVE_MASTER') {
+            loader.trigger('loadedmetadata');
+          } else {
             loader.trigger('mediachange');
+          }
         });
       };
 
@@ -320,19 +315,13 @@
             loader.master.playlists[loader.master.playlists[i].uri] = loader.master.playlists[i];
           }
 
-          request = xhr({
-            uri: resolveUrl(srcUrl, parser.manifest.playlists[0].uri),
-            withCredentials: withCredentials
-          }, function(error, request) {
-            // pass along the URL specified in the master playlist
-            haveMetadata(error,
-                         request,
-                         parser.manifest.playlists[0].uri);
-            if (!error) {
-              loader.trigger('loadedmetadata');
+          loader.trigger('loadedplaylist');
+          if (!request) {
+            // no media playlist was specifically selected so start
+            // from the first listed one
+            loader.media(parser.manifest.playlists[0]);
           }
-          });
-          return loader.trigger('loadedplaylist');
+          return;
         }
 
         // loaded a media playlist
@@ -356,43 +345,10 @@
    * @param update {object} the updated media playlist object
    */
   PlaylistLoader.prototype.updateMediaPlaylist_ = function(update) {
-    var expiredCount;
-
-    if (this.media_) {
-      expiredCount = update.mediaSequence - this.media_.mediaSequence;
-
-      // update the expired time count
-      this.expired_ += Playlist.duration(this.media_,
-                                         this.media_.mediaSequence,
-                                         update.mediaSequence);
-    }
-
     this.media_ = this.master.playlists[update.uri];
   };
 
   /**
-   * When switching variant playlists in a live stream, the player may
-   * discover that the new set of available segments is shifted in
-   * time relative to the old playlist. If that is the case, you can
-   * call this method to synchronize the playlist loader so that
-   * subsequent calls to getMediaIndexForTime_() return values
-   * appropriate for the new playlist.
-   *
-   * @param mediaIndex {integer} the index of the segment that will be
-   * the used to base timeline calculations on
-   * @param startTime {number} the media timeline position of the
-   * first moment of video data for the specified segment. That is,
-   * data from the specified segment will first be displayed when
-   * `currentTime` is equal to `startTime`.
-   */
-  PlaylistLoader.prototype.updateTimelineOffset = function(mediaIndex, startingTime) {
-    var segmentOffset = Playlist.duration(this.media_,
-                                          this.media_.mediaSequence,
-                                          this.media_.mediaSequence + mediaIndex);
-    this.expired_ = startingTime - segmentOffset;
-  };
-
-  /**
    * Determine the index of the segment that contains a specified
    * playback position in the current media playlist. Early versions
    * of the HLS specification require segment durations to be rounded
@@ -411,7 +367,7 @@
    * closest playback position that is currently available.
    */
   PlaylistLoader.prototype.getMediaIndexForTime_ = function(time) {
-    var i;
+    var i, j, segment, targetDuration;
 
     if (!this.media_) {
       return 0;
@@ -419,28 +375,61 @@
 
     // when the requested position is earlier than the current set of
     // segments, return the earliest segment index
-    time -= this.expired_;
     if (time < 0) {
       return 0;
     }
 
-    for (i = 0; i < this.media_.segments.length; i++) {
-      time -= Playlist.duration(this.media_,
-                                this.media_.mediaSequence + i,
-                                this.media_.mediaSequence + i + 1,
-                                false);
+    // 1) Walk backward until we find the latest segment with timeline
+    // information that is earlier than `time`
+    targetDuration = this.media_.targetDuration || 10;
+    i = this.media_.segments.length;
+    while (i--) {
+      segment = this.media_.segments[i];
+      if (segment.end !== undefined && segment.end <= time) {
+        time -= segment.end;
+        break;
+      }
+      if (segment.start !== undefined && segment.start < time) {
+
+        if (segment.end !== undefined && segment.end > time) {
+          // we've found the target segment exactly
+          return i;
+        }
 
-      // HLS version 3 and lower round segment durations to the
-      // nearest decimal integer. When the correct media index is
-      // ambiguous, prefer the higher one.
-      if (time <= 0) {
+        time -= segment.start;
+        time -= segment.duration || targetDuration;
+        if (time < 0) {
+          // the segment with start information is also our best guess
+          // for the momment
           return i;
         }
+        break;
+      }
+    }
+    i++;
+
+    // 2) Walk forward, testing each segment to see if `time` falls within it
+    for (j = i; j < this.media_.segments.length; j++) {
+      segment = this.media_.segments[j];
+      time -= segment.duration || targetDuration;
+
+      if (time < 0) {
+        return j;
+      }
+
+      // 2a) If we discover a segment that has timeline information
+      // before finding the result segment, the playlist information
+      // must have been inaccurate. Start a binary search for the
+      // segment which contains `time`. If the guess turns out to be
+      // incorrect, we'll have more info to work with next time.
+      if (segment.start !== undefined || segment.end !== undefined) {
+        return Math.floor((j - i) * 0.5);
+      }
     }
 
     // the playback position is outside the range of available
-    // segments so return the last one
-    return this.media_.segments.length - 1;
+    // segments so return the length
+    return this.media_.segments.length;
   };
 
   videojs.Hls.PlaylistLoader = PlaylistLoader;

@@ -53,15 +53,6 @@
     strictEqual(loader.state, 'HAVE_NOTHING', 'no metadata has loaded yet');
   });
 
-  test('starts with no expired time', function() {
-    var loader = new videojs.Hls.PlaylistLoader('media.m3u8');
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXTINF:10,\n' +
-                           '0.ts\n');
-    equal(loader.expired_, 0, 'zero seconds expired');
-  });
-
   test('requests the initial playlist immediately', function() {
     new videojs.Hls.PlaylistLoader('master.m3u8');
     strictEqual(requests.length, 1, 'made a request');
@@ -69,13 +60,16 @@
   });
 
   test('moves to HAVE_MASTER after loading a master playlist', function() {
-    var loader = new videojs.Hls.PlaylistLoader('master.m3u8');
+    var loader = new videojs.Hls.PlaylistLoader('master.m3u8'), state;
+    loader.on('loadedplaylist', function() {
+      state = loader.state;
+    });
     requests.pop().respond(200, null,
                            '#EXTM3U\n' +
                            '#EXT-X-STREAM-INF:\n' +
                            'media.m3u8\n');
     ok(loader.master, 'the master playlist is available');
-    strictEqual(loader.state, 'HAVE_MASTER', 'the state is correct');
+    strictEqual(state, 'HAVE_MASTER', 'the state at loadedplaylist correct');
   });
 
   test('jumps to HAVE_METADATA when initialized with a media playlist', function() {
@@ -172,101 +166,6 @@
     strictEqual(loader.state, 'HAVE_METADATA', 'the state is correct');
   });
 
-  test('increments expired seconds after a segment is removed', function() {
-    var loader = new videojs.Hls.PlaylistLoader('live.m3u8');
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:0\n' +
-                           '#EXTINF:10,\n' +
-                           '0.ts\n' +
-                           '#EXTINF:10,\n' +
-                           '1.ts\n' +
-                           '#EXTINF:10,\n' +
-                           '2.ts\n' +
-                           '#EXTINF:10,\n' +
-                           '3.ts\n');
-    clock.tick(10 * 1000); // 10s, one target duration
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:1\n' +
-                           '#EXTINF:10,\n' +
-                           '1.ts\n' +
-                           '#EXTINF:10,\n' +
-                           '2.ts\n' +
-                           '#EXTINF:10,\n' +
-                           '3.ts\n' +
-                           '#EXTINF:10,\n' +
-                           '4.ts\n');
-    equal(loader.expired_, 10, 'expired one segment');
-  });
-
-  test('increments expired seconds after a discontinuity', function() {
-    var loader = new videojs.Hls.PlaylistLoader('live.m3u8');
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:0\n' +
-                           '#EXTINF:10,\n' +
-                           '0.ts\n' +
-                           '#EXTINF:3,\n' +
-                           '1.ts\n' +
-                           '#EXT-X-DISCONTINUITY\n' +
-                           '#EXTINF:4,\n' +
-                           '2.ts\n');
-    clock.tick(10 * 1000); // 10s, one target duration
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:1\n' +
-                           '#EXTINF:3,\n' +
-                           '1.ts\n' +
-                           '#EXT-X-DISCONTINUITY\n' +
-                           '#EXTINF:4,\n' +
-                           '2.ts\n');
-    equal(loader.expired_, 10, 'expired one segment');
-
-    clock.tick(10 * 1000); // 10s, one target duration
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:2\n' +
-                           '#EXT-X-DISCONTINUITY\n' +
-                           '#EXTINF:4,\n' +
-                           '2.ts\n');
-    equal(loader.expired_, 13, 'no expirations after the discontinuity yet');
-
-    clock.tick(10 * 1000); // 10s, one target duration
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:3\n' +
-                           '#EXT-X-DISCONTINUITY-SEQUENCE:1\n' +
-                           '#EXTINF:10,\n' +
-                           '3.ts\n');
-    equal(loader.expired_, 13 + 4, 'tracked expired prior to the discontinuity');
-  });
-
-  test('tracks expired seconds properly when two discontinuities expire at once', function() {
-    var loader = new videojs.Hls.PlaylistLoader('live.m3u8');
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:0\n' +
-                           '#EXTINF:4,\n' +
-                           '0.ts\n' +
-                           '#EXT-X-DISCONTINUITY\n' +
-                           '#EXTINF:5,\n' +
-                           '1.ts\n' +
-                           '#EXT-X-DISCONTINUITY\n' +
-                           '#EXTINF:6,\n' +
-                           '2.ts\n' +
-                           '#EXTINF:7,\n' +
-                           '3.ts\n');
-    clock.tick(10 * 1000);
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:3\n' +
-                           '#EXT-X-DISCONTINUITY-SEQUENCE:2\n' +
-                           '#EXTINF:7,\n' +
-                           '3.ts\n');
-    equal(loader.expired_, 4 + 5 + 6, 'tracked both expired discontinuities');
-  });
-
   test('emits an error when an initial playlist request fails', function() {
     var
       errors = [],
@@ -453,6 +352,20 @@
                 'updated the active media');
   });
 
+  test('can switch playlists immediately after the master is downloaded', function() {
+    var loader = new videojs.Hls.PlaylistLoader('master.m3u8');
+    loader.on('loadedplaylist', function() {
+      loader.media('high.m3u8');
+    });
+    requests.pop().respond(200, null,
+                           '#EXTM3U\n' +
+                           '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
+                           'low.m3u8\n' +
+                           '#EXT-X-STREAM-INF:BANDWIDTH=2\n' +
+                           'high.m3u8\n');
+    equal(requests[0].url, urlTo('high.m3u8'), 'switched variants immediately');
+  });
+
   test('can switch media playlists based on URI', function() {
     var loader = new videojs.Hls.PlaylistLoader('master.m3u8');
     requests.pop().respond(200, null,
@@ -624,9 +537,6 @@
                            'low.m3u8\n' +
                            '#EXT-X-STREAM-INF:BANDWIDTH=2\n' +
                            'high.m3u8\n');
-    throws(function() {
-      loader.media('high.m3u8');
-    }, 'throws an error from HAVE_MASTER');
   });
 
   test('throws an error if a switch to an unrecognized playlist is requested', function() {
@@ -743,8 +653,8 @@
     equal(loader.getMediaIndexForTime_(3), 0, 'time three is index zero');
     equal(loader.getMediaIndexForTime_(10), 2, 'time 10 is index 2');
     equal(loader.getMediaIndexForTime_(22),
-          2,
-          'the index is never greater than the length');
+          3,
+          'time greater than the length is index 3');
   });
 
   test('returns the lower index when calculating for a segment boundary', function() {
@@ -757,10 +667,8 @@
                              '#EXTINF:5,\n' +
                              '1.ts\n' +
                              '#EXT-X-ENDLIST\n');
-    equal(loader.getMediaIndexForTime_(4), 0, 'rounds down exact matches');
+    equal(loader.getMediaIndexForTime_(4), 1, 'rounds up exact matches');
     equal(loader.getMediaIndexForTime_(3.7), 0, 'rounds down');
-    // FIXME: the test below should pass for HLSv3
-    //equal(loader.getMediaIndexForTime_(4.2), 0, 'rounds down');
     equal(loader.getMediaIndexForTime_(4.5), 1, 'rounds up at 0.5');
   });
 
@@ -773,7 +681,7 @@
                              '1001.ts\n' +
                              '#EXTINF:5,\n' +
                              '1002.ts\n');
-    loader.expired_ = 150;
+    loader.media().segments[0].start = 150;
 
     equal(loader.getMediaIndexForTime_(0), 0, 'the lowest returned value is zero');
     equal(loader.getMediaIndexForTime_(45), 0, 'expired content returns zero');
@@ -785,30 +693,6 @@
     equal(loader.getMediaIndexForTime_(50 + 100 + 6), 1, 'calculates within the second segment');
   });
 
-  test('updating the timeline offset adjusts results from getMediaIndexForTime_', function() {
-    var loader = new videojs.Hls.PlaylistLoader('live.m3u8');
-    requests.pop().respond(200, null,
-                           '#EXTM3U\n' +
-                           '#EXT-X-MEDIA-SEQUENCE:23\n' +
-                           '#EXTINF:4,\n' +
-                           '23.ts\n' +
-                           '#EXTINF:5,\n' +
-                           '24.ts\n' +
-                           '#EXTINF:6,\n' +
-                           '25.ts\n' +
-                           '#EXTINF:7,\n' +
-                           '26.ts\n');
-    loader.updateTimelineOffset(0, 150);
-    equal(loader.getMediaIndexForTime_(150), 0, 'translated the first segment');
-    equal(loader.getMediaIndexForTime_(130), 0, 'clamps the index to zero');
-    equal(loader.getMediaIndexForTime_(155), 1, 'translated the second segment');
-
-    loader.updateTimelineOffset(2, 30);
-    equal(loader.getMediaIndexForTime_(30 - 5 - 1), 0, 'translated the first segment');
-    equal(loader.getMediaIndexForTime_(30 + 7), 3, 'translated the last segment');
-    equal(loader.getMediaIndexForTime_(30 - 3), 1, 'translated an earlier segment');
-  });
-
   test('does not misintrepret playlists missing newlines at the end', function() {
     var loader = new videojs.Hls.PlaylistLoader('media.m3u8');
     requests.shift().respond(200, null,

@@ -18,27 +18,6 @@
 
   module('Playlist Interval Duration');
 
-  test('accounts expired duration for live playlists', function() {
-    var duration = Playlist.duration({
-      mediaSequence: 10,
-      segments: [{
-        duration: 10,
-        uri: '10.ts'
-      }, {
-        duration: 10,
-        uri: '11.ts'
-      }, {
-        duration: 10,
-        uri: '12.ts'
-      }, {
-        duration: 10,
-        uri: '13.ts'
-      }]
-    }, 0, 14);
-
-    equal(duration, 14 * 10, 'duration includes dropped segments');
-  });
-
   test('accounts for non-zero starting VOD media sequences', function() {
     var duration = Playlist.duration({
       mediaSequence: 10,
@@ -61,47 +40,37 @@
     equal(duration, 4 * 10, 'includes only listed segments');
   });
 
-  test('uses PTS values when available', function() {
+  test('uses timeline values when available', function() {
     var duration = Playlist.duration({
       mediaSequence: 0,
       endList: true,
       segments: [{
-        minVideoPts: 1,
-        minAudioPts: 2,
+        start: 0,
         uri: '0.ts'
       }, {
         duration: 10,
-        maxVideoPts: 2 * 10 * 1000 + 1,
-        maxAudioPts: 2 * 10 * 1000 + 2,
+        end: 2 * 10 + 2,
         uri: '1.ts'
       }, {
         duration: 10,
-        maxVideoPts: 3 * 10 * 1000 + 1,
-        maxAudioPts: 3 * 10 * 1000 + 2,
+        end: 3 * 10 + 2,
         uri: '2.ts'
       }, {
         duration: 10,
-        maxVideoPts: 4 * 10 * 1000 + 1,
-        maxAudioPts: 4 * 10 * 1000 + 2,
+        end: 4 * 10 + 2,
         uri: '3.ts'
       }]
-    }, 0, 4);
+    }, 4);
 
-    equal(duration, ((4 * 10 * 1000 + 2) - 1) * 0.001, 'used PTS values');
+    equal(duration, 4 * 10 + 2, 'used timeline values');
   });
 
-  test('works when partial PTS information is available', function() {
+  test('works when partial timeline information is available', function() {
     var duration = Playlist.duration({
       mediaSequence: 0,
       endList: true,
       segments: [{
-        minVideoPts: 1,
-        minAudioPts: 2,
-        maxVideoPts: 10 * 1000 + 1,
-
-        // intentionally less duration than video
-        // the max stream duration should be used
-        maxAudioPts: 10 * 1000 + 1,
+        start: 0,
         uri: '0.ts'
       }, {
         duration: 9,
@@ -111,67 +80,17 @@
         uri: '2.ts'
       }, {
         duration: 10,
-        minVideoPts: 30 * 1000 + 7,
-        minAudioPts: 30 * 1000 + 10,
-        maxVideoPts: 40 * 1000 + 1,
-        maxAudioPts: 40 * 1000 + 2,
+        start: 30.007,
+        end: 40.002,
         uri: '3.ts'
       }, {
         duration: 10,
-        maxVideoPts: 50 * 1000 + 1,
-        maxAudioPts: 50 * 1000 + 2,
+        end: 50.0002,
         uri: '4.ts'
       }]
-    }, 0, 5);
+    }, 5);
 
-    equal(duration,
-          ((50 * 1000 + 2) - 1) * 0.001,
-          'calculated with mixed intervals');
-  });
-
-  test('ignores segments before the start', function() {
-    var duration = Playlist.duration({
-      mediaSequence: 0,
-      segments: [{
-        duration: 10,
-        uri: '0.ts'
-      }, {
-        duration: 10,
-        uri: '1.ts'
-      }, {
-        duration: 10,
-        uri: '2.ts'
-      }]
-    }, 1, 3);
-
-    equal(duration, 10 + 10, 'ignored the first segment');
-  });
-
-  test('ignores discontinuity sequences earlier than the start', function() {
-    var duration = Playlist.duration({
-      mediaSequence: 0,
-      discontinuityStarts: [1, 3],
-      segments: [{
-        minVideoPts: 0,
-        minAudioPts: 0,
-        maxVideoPts: 10 * 1000,
-        maxAudioPts: 10 * 1000,
-        uri: '0.ts'
-      }, {
-        discontinuity: true,
-        duration: 9,
-        uri: '1.ts'
-      }, {
-        duration: 10,
-        uri: '2.ts'
-      }, {
-        discontinuity: true,
-        duration: 10,
-        uri: '3.ts'
-      }]
-    }, 2, 4);
-
-    equal(duration, 10 + 10, 'excluded the earlier segments');
+    equal(duration, 50.0002, 'calculated with mixed intervals');
   });
 
   test('ignores discontinuity sequences later than the end', function() {
@@ -196,20 +115,19 @@
         duration: 10,
         uri: '3.ts'
       }]
-    }, 0, 2);
+    }, 2);
 
     equal(duration, 19, 'excluded the later segments');
   });
 
-  test('handles trailing segments without PTS information', function() {
-    var duration = Playlist.duration({
+  test('handles trailing segments without timeline information', function() {
+    var playlist, duration;
+    playlist = {
       mediaSequence: 0,
       endList: true,
       segments: [{
-        minVideoPts: 0,
-        minAudioPts: 0,
-        maxVideoPts: 10 * 1000,
-        maxAudioPts: 10 * 1000,
+        start: 0,
+        end: 10.5,
         uri: '0.ts'
       }, {
         duration: 9,
@@ -218,107 +136,43 @@
         duration: 10,
         uri: '2.ts'
       }, {
-        minVideoPts: 29.5 * 1000,
-        minAudioPts: 29.5 * 1000,
-        maxVideoPts: 39.5 * 1000,
-        maxAudioPts: 39.5 * 1000,
+        start: 29.45,
+        end: 39.5,
         uri: '3.ts'
       }]
-    }, 0, 3);
+    };
+
+    duration = Playlist.duration(playlist, 3);
+    equal(duration, 29.45, 'calculated duration');
 
-    equal(duration, 29.5, 'calculated duration');
+    duration = Playlist.duration(playlist, 2);
+    equal(duration, 19.5, 'calculated duration');
   });
 
-  test('uses PTS intervals when the start and end segment have them', function() {
+  test('uses timeline intervals when segments have them', function() {
     var playlist, duration;
     playlist = {
       mediaSequence: 0,
       segments: [{
-        minVideoPts: 0,
-        minAudioPts: 0,
-        maxVideoPts: 10 * 1000,
-        maxAudioPts: 10 * 1000,
+        start: 0,
+        end: 10,
         uri: '0.ts'
       }, {
         duration: 9,
         uri: '1.ts'
       },{
-        minVideoPts: 20 * 1000 + 100,
-        minAudioPts: 20 * 1000 + 100,
-        maxVideoPts: 30 * 1000 + 100,
-        maxAudioPts: 30 * 1000 + 100,
+        start: 20.1,
+        end: 30.1,
         duration: 10,
         uri: '2.ts'
       }]
     };
-    duration = Playlist.duration(playlist, 0, 2);
+    duration = Playlist.duration(playlist, 2);
 
-    equal(duration, 20.1, 'used the PTS-based interval');
+    equal(duration, 20.1, 'used the timeline-based interval');
 
-    duration = Playlist.duration(playlist, 0, 3);
-    equal(duration, 30.1, 'used the PTS-based interval');
-  });
-
-  test('works for media without audio', function() {
-    equal(Playlist.duration({
-      mediaSequence: 0,
-      endList: true,
-      segments: [{
-        minVideoPts: 0,
-        maxVideoPts: 9 * 1000,
-        uri: 'no-audio.ts'
-      }]
-    }), 9, 'used video PTS values');
-  });
-
-  test('works for media without video', function() {
-    equal(Playlist.duration({
-      mediaSequence: 0,
-      endList: true,
-      segments: [{
-        minAudioPts: 0,
-        maxAudioPts: 9 * 1000,
-        uri: 'no-video.ts'
-      }]
-    }), 9, 'used video PTS values');
-  });
-
-  test('uses the largest continuous available PTS ranges', function() {
-    var playlist = {
-      mediaSequence: 0,
-      segments: [{
-        minVideoPts: 0,
-        minAudioPts: 0,
-        maxVideoPts: 10 * 1000,
-        maxAudioPts: 10 * 1000,
-        uri: '0.ts'
-      }, {
-        duration: 10,
-        uri: '1.ts'
-      }, {
-        // starts 0.5s earlier than the previous segment indicates
-        minVideoPts: 19.5 * 1000,
-        minAudioPts: 19.5 * 1000,
-        maxVideoPts: 29.5 * 1000,
-        maxAudioPts: 29.5 * 1000,
-        uri: '2.ts'
-      }, {
-        duration: 10,
-        uri: '3.ts'
-      }, {
-        // ... but by the last segment, there is actual 0.5s more
-        // content than duration indicates
-        minVideoPts: 40.5 * 1000,
-        minAudioPts: 40.5 * 1000,
-        maxVideoPts: 50.5 * 1000,
-        maxAudioPts: 50.5 * 1000,
-        uri: '4.ts'
-      }]
-    };
-
-    equal(Playlist.duration(playlist, 0, 5),
-          50.5,
-          'calculated across the larger PTS interval');
+    duration = Playlist.duration(playlist, 3);
+    equal(duration, 30.1, 'used the timeline-based interval');
   });
 
   test('counts the time between segments as part of the earlier segment\'s duration', function() {
@@ -326,22 +180,18 @@
       mediaSequence: 0,
       endList: true,
       segments: [{
-        minVideoPts: 0,
-        minAudioPts: 0,
-        maxVideoPts: 1 * 10 * 1000,
-        maxAudioPts: 1 * 10 * 1000,
+        start: 0,
+        end: 10,
         uri: '0.ts'
       }, {
-        minVideoPts: 1 * 10 * 1000 + 100,
-        minAudioPts: 1 * 10 * 1000 + 100,
-        maxVideoPts: 2 * 10 * 1000 + 100,
-        maxAudioPts: 2 * 10 * 1000 + 100,
+        start: 10.1,
+        end: 20.1,
         duration: 10,
         uri: '1.ts'
       }]
-    }, 0, 1);
+    }, 1);
 
-    equal(duration, (1 * 10 * 1000 + 100) * 0.001, 'included the segment gap');
+    equal(duration, 10.1, 'included the segment gap');
   });
 
   test('accounts for discontinuities', function() {
@@ -364,7 +214,7 @@
         duration: 10,
         uri: '1.ts'
       }]
-    }, 0, 2);
+    }, 2);
 
     equal(duration, 10 + 10, 'handles discontinuities');
   });
@@ -389,7 +239,7 @@
         duration: 10,
         uri: '1.ts'
       }]
-    }, 0, 1);
+    }, 1);
 
     equal(duration, (1 * 10 * 1000) * 0.001, 'did not include the segment gap');
   });
@@ -412,7 +262,7 @@
         duration: 10,
         uri: '1.ts'
       }]
-    }, 0, 1, false);
+    }, 1, false);
 
     equal(duration, (1 * 10 * 1000) * 0.001, 'did not include the segment gap');
   });
@@ -431,10 +281,9 @@
       }]
     };
 
-    equal(Playlist.duration(playlist, 0, 0), 0, 'zero-length duration is zero');
-    equal(Playlist.duration(playlist, 0, 0, false), 0, 'zero-length duration is zero');
-    equal(Playlist.duration(playlist, 0, -1), 0, 'negative length duration is zero');
-    equal(Playlist.duration(playlist, 2, 1, false), 0, 'negative length duration is zero');
+    equal(Playlist.duration(playlist, 0), 0, 'zero-length duration is zero');
+    equal(Playlist.duration(playlist, 0, false), 0, 'zero-length duration is zero');
+    equal(Playlist.duration(playlist, -1), 0, 'negative length duration is zero');
   });
 
   module('Playlist Seekable');