@dmlap implement seekable for live streams ([view](#295))

CHANGELOG.md

@@ -2,7 +2,7 @@ CHANGELOG
 =========
 
 ## HEAD (Unreleased)
-_(none)_
+* @dmlap implement seekable for live streams. Fix in-band metadata timing for live streams. ([view](https://github.com/videojs/videojs-contrib-hls/pull/295))
 
 --------------------
 

Gruntfile.js

@@ -34,6 +34,7 @@ module.exports = function(grunt) {
               'src/segment-parser.js',
               'src/m3u8/m3u8-parser.js',
               'src/xhr.js',
+              'src/playlist.js',
               'src/playlist-loader.js',
               'node_modules/pkcs7/dist/pkcs7.unpad.js',
               'src/decrypter.js'

example.html

@@ -28,13 +28,14 @@
 
   <!-- m3u8 handling -->
   <script src="src/m3u8/m3u8-parser.js"></script>
+  <script src="src/playlist.js"></script>
   <script src="src/playlist-loader.js"></script>
 
   <script src="node_modules/pkcs7/dist/pkcs7.unpad.js"></script>
   <script src="src/decrypter.js"></script>
 
   <script src="src/bin-utils.js"></script>
-  
+
   <!-- example MPEG2-TS segments -->
   <!-- bipbop -->
   <!-- <script src="test/tsSegment.js"></script> -->

src/aac-stream.js

@@ -12,7 +12,6 @@ var
 window.videojs.Hls.AacStream = function() {
   var
     next_pts, // :uint
-    pts_offset, // :int
     state, // :uint
     pes_length, // :int
     lastMetaPts,
@@ -32,7 +31,6 @@ window.videojs.Hls.AacStream = function() {
 
   // (pts:uint):void
   this.setTimeStampOffset = function(pts) {
-    pts_offset = pts;
 
     // keep track of the last time a metadata tag was written out
     // set the initial value so metadata will be generated before any
@@ -42,7 +40,7 @@ window.videojs.Hls.AacStream = function() {
 
   // (pts:uint, pes_size:int, dataAligned:Boolean):void
   this.setNextTimeStamp = function(pts, pes_size, dataAligned) {
-    next_pts = pts - pts_offset;
+    next_pts = pts;
     pes_length = pes_size;
 
     // If data is aligned, flush all internal buffers

src/h264-stream.js

@@ -37,7 +37,6 @@
   window.videojs.Hls.H264Stream = H264Stream = function() {
     this._next_pts = 0; // :uint;
     this._next_dts = 0; // :uint;
-    this._pts_offset = 0; // :int
 
     this._h264Frame = null; // :FlvTag
 
@@ -52,15 +51,13 @@
   };
 
   //(pts:uint):void
-  H264Stream.prototype.setTimeStampOffset = function(pts) {
-    this._pts_offset = pts;
-  };
+  H264Stream.prototype.setTimeStampOffset = function() {};
 
   //(pts:uint, dts:uint, dataAligned:Boolean):void
   H264Stream.prototype.setNextTimeStamp = function(pts, dts, dataAligned) {
     // We could end up with a DTS less than 0 here. We need to deal with that!
-    this._next_pts = pts - this._pts_offset;
-    this._next_dts = dts - this._pts_offset;
+    this._next_pts = pts;
+    this._next_dts = dts;
 
     // If data is aligned, flush all internal buffers
     if (dataAligned) {

src/m3u8/m3u8-parser.js

@@ -210,6 +210,18 @@
       this.trigger('data', event);
       return;
     }
+    match = (/^#EXT-X-DISCONTINUITY-SEQUENCE:?(\-?[0-9.]*)?/).exec(line);
+    if (match) {
+      event = {
+        type: 'tag',
+        tagType: 'discontinuity-sequence'
+      };
+      if (match[1]) {
+        event.number = parseInt(match[1], 10);
+      }
+      this.trigger('data', event);
+      return;
+    }
     match = (/^#EXT-X-PLAYLIST-TYPE:?(.*)?$/).exec(line);
     if (match) {
       event = {
@@ -308,7 +320,7 @@
         event.attributes = parseAttributes(match[1]);
         // parse the IV string into a Uint32Array
         if (event.attributes.IV) {
-          if (event.attributes.IV.substring(0,2) === '0x') {	
+          if (event.attributes.IV.substring(0,2) === '0x') {
             event.attributes.IV = event.attributes.IV.substring(2);
           }
 
@@ -409,6 +421,12 @@
                   message: 'defaulting media sequence to zero'
                 });
               }
+              if (!('discontinuitySequence' in this.manifest)) {
+                this.manifest.discontinuitySequence = 0;
+                this.trigger('info', {
+                  message: 'defaulting discontinuity sequence to zero'
+                });
+              }
               if (entry.duration >= 0) {
                 currentUri.duration = entry.duration;
               }
@@ -459,6 +477,15 @@
               }
               this.manifest.mediaSequence = entry.number;
             },
+            'discontinuity-sequence': function() {
+              if (!isFinite(entry.number)) {
+                this.trigger('warn', {
+                  message: 'ignoring invalid discontinuity sequence: ' + entry.number
+                });
+                return;
+              }
+              this.manifest.discontinuitySequence = entry.number;
+            },
             'playlist-type': function() {
               if (!(/VOD|EVENT/).test(entry.playlistType)) {
                 this.trigger('warn', {

src/metadata-stream.js

@@ -37,7 +37,8 @@
           if (tag.data[i] === 0) {
             // parse the text fields
             tag.description = parseUtf8(tag.data, 1, i);
-            tag.value = parseUtf8(tag.data, i + 1, tag.data.length);
+            // do not include the null terminator in the tag value
+            tag.value = parseUtf8(tag.data, i + 1, tag.data.length - 1);
             break;
           }
         }
@@ -173,13 +174,6 @@
                    (tag.data[19]);
       }
 
-      // adjust the PTS values to align with the video and audio
-      // streams
-      if (this.timestampOffset) {
-        tag.pts -= this.timestampOffset;
-        tag.dts -= this.timestampOffset;
-      }
-
       // parse one or more ID3 frames
       // http://id3.org/id3v2.3.0#ID3v2_frame_overview
       do {

src/playlist-loader.js

@@ -1,12 +1,23 @@
 /**
  * A state machine that manages the loading, caching, and updating of
- * M3U8 playlists.
+ * 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 and discontinuities looks like this:
+ *
+ * |-- expiredPreDiscontinuity --|-- expiredPostDiscontinuity --|-- segments --|
+ *
+ * You can use these values to calculate how much time has elapsed
+ * since the stream began loading or how long it has been since the
+ * most recent discontinuity was encountered, for instance.
  */
 (function(window, videojs) {
   'use strict';
   var
     resolveUrl = videojs.Hls.resolveUrl,
     xhr = videojs.Hls.xhr,
+    Playlist = videojs.Hls.Playlist,
 
     /**
      * Returns a new master playlist that is the result of merging an
@@ -51,66 +62,84 @@
       var
         loader = this,
         dispose,
-        media,
         mediaUpdateTimeout,
         request,
+        haveMetadata;
 
-        haveMetadata = function(error, xhr, url) {
-          var parser, refreshDelay, update;
+      PlaylistLoader.prototype.init.call(this);
 
-          loader.setBandwidth(request || xhr);
+      if (!srcUrl) {
+        throw new Error('A non-empty playlist URL is required');
+      }
 
-          // any in-flight request is now finished
-          request = null;
+      // update the playlist loader's state in response to a new or
+      // updated playlist.
+      haveMetadata = function(error, xhr, url) {
+        var parser, refreshDelay, update;
 
-          if (error) {
-            loader.error = {
-              status: xhr.status,
-              message: 'HLS playlist request error at URL: ' + url,
-              responseText: xhr.responseText,
-              code: (xhr.status >= 500) ? 4 : 2
-            };
-            return loader.trigger('error');
-          }
+        loader.setBandwidth(request || xhr);
 
-          loader.state = 'HAVE_METADATA';
+        // any in-flight request is now finished
+        request = null;
 
-          parser = new videojs.m3u8.Parser();
-          parser.push(xhr.responseText);
-          parser.end();
-          parser.manifest.uri = url;
-
-          // merge this playlist into the master
-          update = updateMaster(loader.master, parser.manifest);
-          refreshDelay = (parser.manifest.targetDuration || 10) * 1000;
-          if (update) {
-            loader.master = update;
-            media = loader.master.playlists[url];
-          } else {
-            // if the playlist is unchanged since the last reload,
-            // try again after half the target duration
-            refreshDelay /= 2;
-          }
+        if (error) {
+          loader.error = {
+            status: xhr.status,
+            message: 'HLS playlist request error at URL: ' + url,
+            responseText: xhr.responseText,
+            code: (xhr.status >= 500) ? 4 : 2
+          };
+          return loader.trigger('error');
+        }
 
-          // refresh live playlists after a target duration passes
-          if (!loader.media().endList) {
-            window.clearTimeout(mediaUpdateTimeout);
-            mediaUpdateTimeout = window.setTimeout(function() {
-              loader.trigger('mediaupdatetimeout');
-            }, refreshDelay);
-          }
+        loader.state = 'HAVE_METADATA';
 
-          loader.trigger('loadedplaylist');
-        };
+        parser = new videojs.m3u8.Parser();
+        parser.push(xhr.responseText);
+        parser.end();
+        parser.manifest.uri = url;
+
+        // merge this playlist into the master
+        update = updateMaster(loader.master, parser.manifest);
+        refreshDelay = (parser.manifest.targetDuration || 10) * 1000;
+        if (update) {
+          loader.master = update;
+          loader.updateMediaPlaylist_(parser.manifest);
+        } else {
+          // if the playlist is unchanged since the last reload,
+          // try again after half the target duration
+          refreshDelay /= 2;
+        }
 
-      PlaylistLoader.prototype.init.call(this);
+        // refresh live playlists after a target duration passes
+        if (!loader.media().endList) {
+          window.clearTimeout(mediaUpdateTimeout);
+          mediaUpdateTimeout = window.setTimeout(function() {
+            loader.trigger('mediaupdatetimeout');
+          }, refreshDelay);
+        }
 
-      if (!srcUrl) {
-        throw new Error('A non-empty playlist URL is required');
-      }
+        loader.trigger('loadedplaylist');
+      };
 
+      // initialize the loader state
       loader.state = 'HAVE_NOTHING';
 
+      // the total duration of all segments that expired and have been
+      // removed from the current playlist after the last
+      // #EXT-X-DISCONTINUITY. In a live playlist without
+      // discontinuities, this is the total amount of time that has
+      // been removed from the stream since the playlist loader began
+      // tracking it.
+      loader.expiredPostDiscontinuity_ = 0;
+
+      // the total duration of all segments that expired and have been
+      // removed from the current playlist before the last
+      // #EXT-X-DISCONTINUITY. The total amount of time that has
+      // expired is always the sum of expiredPreDiscontinuity_ and
+      // expiredPostDiscontinuity_.
+      loader.expiredPreDiscontinuity_ = 0;
+
       // capture the prototype dispose function
       dispose = this.dispose;
 
@@ -141,7 +170,7 @@
         var mediaChange = false;
         // getter
         if (!playlist) {
-          return media;
+          return loader.media_;
         }
 
         // setter
@@ -158,7 +187,7 @@
           playlist = loader.master.playlists[playlist];
         }
 
-        mediaChange = playlist.uri !== media.uri;
+        mediaChange = playlist.uri !== loader.media_.uri;
 
         // switch to fully loaded playlists immediately
         if (loader.master.playlists[playlist.uri].endList) {
@@ -169,7 +198,7 @@
             request = null;
           }
           loader.state = 'HAVE_METADATA';
-          media = playlist;
+          loader.media_ = playlist;
 
           // trigger media change if the active media has been updated
           if (mediaChange) {
@@ -292,5 +321,46 @@
     };
   PlaylistLoader.prototype = new videojs.Hls.Stream();
 
+  /**
+   * Update the PlaylistLoader state to reflect the changes in an
+   * update to the current media playlist.
+   * @param update {object} the updated media playlist object
+   */
+  PlaylistLoader.prototype.updateMediaPlaylist_ = function(update) {
+    var lastDiscontinuity, expiredCount, i;
+
+    if (this.media_) {
+      expiredCount = update.mediaSequence - this.media_.mediaSequence;
+
+      // setup the index for duration calculations so that the newly
+      // expired time will be accumulated after the last
+      // discontinuity, unless we discover otherwise
+      lastDiscontinuity = this.media_.mediaSequence;
+
+      if (this.media_.discontinuitySequence !== update.discontinuitySequence) {
+        i = expiredCount;
+        while (i--) {
+          if (this.media_.segments[i].discontinuity) {
+            // a segment that begins a new discontinuity sequence has expired
+            lastDiscontinuity = i + this.media_.mediaSequence;
+            this.expiredPreDiscontinuity_ += this.expiredPostDiscontinuity_;
+            this.expiredPostDiscontinuity_ = 0;
+            break;
+          }
+        }
+      }
+
+      // update the expirated durations
+      this.expiredPreDiscontinuity_ += Playlist.duration(this.media_,
+                                                         this.media_.mediaSequence,
+                                                         lastDiscontinuity);
+      this.expiredPostDiscontinuity_ += Playlist.duration(this.media_,
+                                                         lastDiscontinuity,
+                                                         this.media_.mediaSequence + expiredCount);
+    }
+
+    this.media_ = this.master.playlists[update.uri];
+  };
+
   videojs.Hls.PlaylistLoader = PlaylistLoader;
 })(window, window.videojs);