Decouple appending bytes from downloading and parsing segments

We have to wait until the SourceBuffer is empty before resetting the decoder when crossing over a timestamp discontinuity. Make appending bytes happen asynchronously so that we can delay appends util the buffer is empty when we see a discontinuity in the playlist. Fix tests.

@@ -161,7 +161,7 @@ var
         i;
         i;
 
 
     startIndex = startIndex || 0;
     startIndex = startIndex || 0;
-    endIndex = endIndex || (playlist.segments || []).length;
+    endIndex = endIndex !== undefined ? endIndex : (playlist.segments || []).length;
     i = endIndex - 1;
     i = endIndex - 1;
 
 
     for (; i >= startIndex; i--) {
     for (; i >= startIndex; i--) {
@@ -201,10 +201,12 @@ var
     var
     var
       segmentParser = new videojs.Hls.SegmentParser(),
       segmentParser = new videojs.Hls.SegmentParser(),
       settings = videojs.util.mergeOptions({}, player.options().hls),
       settings = videojs.util.mergeOptions({}, player.options().hls),
+      segmentBuffer = [],
 
 
       lastSeekedTime,
       lastSeekedTime,
       segmentXhr,
       segmentXhr,
       fillBuffer,
       fillBuffer,
+      drainBuffer,
       updateDuration;
       updateDuration;
 
 
 
 
@@ -385,6 +387,8 @@ var
         responseType: 'arraybuffer',
         responseType: 'arraybuffer',
         withCredentials: settings.withCredentials
         withCredentials: settings.withCredentials
       }, function(error, url) {
       }, function(error, url) {
+        var tags;
+
         // the segment request is no longer outstanding
         // the segment request is no longer outstanding
         segmentXhr = null;
         segmentXhr = null;
 
 
@@ -405,10 +409,6 @@ var
           return;
           return;
         }
         }
 
 
-        if (segment.discontinuity) {
-          player.hls.sourceBuffer.abort();
-        }
-
         // calculate the download bandwidth
         // calculate the download bandwidth
         player.hls.segmentXhrTime = (+new Date()) - startTime;
         player.hls.segmentXhrTime = (+new Date()) - startTime;
         player.hls.bandwidth = (this.response.byteLength / player.hls.segmentXhrTime) * 8 * 1000;
         player.hls.bandwidth = (this.response.byteLength / player.hls.segmentXhrTime) * 8 * 1000;
@@ -417,52 +417,97 @@ var
         segmentParser.parseSegmentBinaryData(new Uint8Array(this.response));
         segmentParser.parseSegmentBinaryData(new Uint8Array(this.response));
         segmentParser.flushTags();
         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()) {
+          tags.push(segmentParser.getNextTag());
+        }
+        segmentBuffer.push({
+          mediaIndex: player.hls.mediaIndex,
+          playlist: player.hls.playlists.media(),
+          offset: offset,
+          tags: tags
+        });
+        drainBuffer();
+
+        player.hls.mediaIndex++;
+
+        // figure out what stream the next segment should be downloaded from
+        // with the updated bandwidth information
+        player.hls.playlists.media(player.hls.selectPlaylist());
+      });
+    };
+
+    drainBuffer = function(event) {
+      var
+        i = 0,
+        mediaIndex,
+        playlist,
+        offset,
+        tags,
+        segment,
+
+        ptsTime,
+        segmentOffset;
+
+      if (!segmentBuffer.length) {
+        return;
+      }
+
+      mediaIndex = segmentBuffer[0].mediaIndex;
+      playlist = segmentBuffer[0].playlist;
+      offset = segmentBuffer[0].offset;
+      tags = segmentBuffer[0].tags;
+      segment = playlist.segments[mediaIndex];
+
+      event = event || {};
+
+      // abort() clears any data queued in the source buffer so wait
+      // until it empties before calling it when a discontinuity is
+      // next in the buffer
+      if (segment.discontinuity) {
+        if (event.type !== 'waiting') {
+          return;
+        }
+        player.hls.sourceBuffer.abort();
+      }
+
       // if we're refilling the buffer after a seek, scan through the muxed
       // if we're refilling the buffer after a seek, scan through the muxed
       // FLV tags until we find the one that is closest to the desired
       // FLV tags until we find the one that is closest to the desired
       // playback time
       // playback time
       if (typeof offset === 'number') {
       if (typeof offset === 'number') {
-            (function() {
-              var tag = segmentParser.getTags()[0],
-                  ptsnaught = tag.pts,
-                  playlist = player.hls.playlists.media(),
-                  segmentOffset,
-                  ptsTime;
-
-              segmentOffset = duration(playlist, 0, player.hls.mediaIndex) * 1000;
+        segmentOffset = duration(playlist, 0, mediaIndex) * 1000;
+        ptsTime = offset - segmentOffset + tags[0].pts;
 
 
-              ptsTime = offset - segmentOffset + ptsnaught;
-
-              for (; tag && tag.pts < ptsTime; tag = segmentParser.getTags()[0]) {
-                segmentParser.getNextTag();
+        while (tags[i].pts < ptsTime) {
+          i++;
         }
         }
 
 
         // tell the SWF where we will be seeking to
         // tell the SWF where we will be seeking to
-              player.hls.el().vjs_setProperty('currentTime', (tag.pts - ptsnaught + segmentOffset) * 0.001);
+        player.hls.el().vjs_setProperty('currentTime', (tags[i].pts - tags[0].pts + segmentOffset) * 0.001);
+
+        tags = tags.slice(i);
 
 
         lastSeekedTime = null;
         lastSeekedTime = null;
-            })();
       }
       }
 
 
-        while (segmentParser.tagsAvailable()) {
+      for (i = 0; i < tags.length; i++) {
         // queue up the bytes to be appended to the SourceBuffer
         // queue up the bytes to be appended to the SourceBuffer
         // the queue gives control back to the browser between tags
         // the queue gives control back to the browser between tags
         // so that large segments don't cause a "hiccup" in playback
         // so that large segments don't cause a "hiccup" in playback
 
 
-          player.hls.sourceBuffer.appendBuffer(segmentParser.getNextTag().bytes,
-                                               player);
-
+        player.hls.sourceBuffer.appendBuffer(tags[i].bytes, player);
       }
       }
 
 
-        player.hls.mediaIndex++;
+      // we're done processing this segment
+      segmentBuffer.shift();
 
 
-        if (player.hls.mediaIndex === player.hls.playlists.media().segments.length) {
+      if (mediaIndex === playlist.segments.length) {
         mediaSource.endOfStream();
         mediaSource.endOfStream();
       }
       }
-
-        // figure out what stream the next segment should be downloaded from
-        // with the updated bandwidth information
-        player.hls.playlists.media(player.hls.selectPlaylist());
-      });
     };
     };
 
 
     // load the MediaSource into the player
     // load the MediaSource into the player
@@ -481,9 +526,12 @@ var
       player.hls.playlists.on('loadedmetadata', function() {
       player.hls.playlists.on('loadedmetadata', function() {
         oldMediaPlaylist = player.hls.playlists.media();
         oldMediaPlaylist = player.hls.playlists.media();
 
 
-        // periodicaly check if the buffer needs to be refilled
+        // periodically check if new data needs to be downloaded or
+        // buffered data should be appended to the source buffer
         fillBuffer();
         fillBuffer();
         player.on('timeupdate', fillBuffer);
         player.on('timeupdate', fillBuffer);
+        player.on('timeupdate', drainBuffer);
+        player.on('waiting', drainBuffer);
 
 
         player.trigger('loadedmetadata');
         player.trigger('loadedmetadata');
       });
       });

@@ -840,8 +840,11 @@ test('calls abort() on the SourceBuffer before seeking', function() {
   standardXHRResponse(requests[0]);
   standardXHRResponse(requests[0]);
   standardXHRResponse(requests[1]);
   standardXHRResponse(requests[1]);
 
 
-  // seek to 7s
+  // drainBuffer() uses the first PTS value to account for any timestamp discontinuities in the stream
+  // adding a tag with a PTS of zero looks like a stream with no discontinuities
+  tags.push({ pts: 0, bytes: 0 });
   tags.push({ pts: 7000, bytes: 7 });
   tags.push({ pts: 7000, bytes: 7 });
+  // seek to 7s
   player.currentTime(7);
   player.currentTime(7);
   standardXHRResponse(requests[2]);
   standardXHRResponse(requests[2]);