NAL units may have unlimited trailing zeroes

When a NAL unit had trailing zeroes that were split across pushes to the H264Stream, the parser would go into an infinite loop. Instead, make sure we never advance the parser beyond the current push and advance the sync point to a valid position before starting processing. Add HTML-HLS dependencies to the example page.

@@ -34,6 +34,9 @@
   <script src="node_modules/pkcs7/dist/pkcs7.unpad.js"></script>
   <script src="node_modules/pkcs7/dist/pkcs7.unpad.js"></script>
   <script src="src/decrypter.js"></script>
   <script src="src/decrypter.js"></script>
 
 
+  <script src="../src/mp4-generator.js"></script>
+  <script src="../src/transmuxer.js"></script>
+
   <script src="src/bin-utils.js"></script>
   <script src="src/bin-utils.js"></script>
 
 
   <!-- example MPEG2-TS segments -->
   <!-- example MPEG2-TS segments -->

@@ -522,8 +522,8 @@ AudioSegmentStream.prototype = new videojs.Hls.Stream();
  */
  */
 NalByteStream = function() {
 NalByteStream = function() {
   var
   var
-    i = 6,
     syncPoint = 1,
     syncPoint = 1,
+    i,
     buffer;
     buffer;
   NalByteStream.prototype.init.call(this);
   NalByteStream.prototype.init.call(this);
 
 
@@ -548,6 +548,16 @@ NalByteStream = function() {
     // or this:
     // or this:
     // 0 0 1 .. NAL .. 0 0 0
     // 0 0 1 .. NAL .. 0 0 0
     // ^ sync point        ^ i
     // ^ sync point        ^ i
+
+    // advance the sync point to a NAL start, if necessary
+    for (; syncPoint < buffer.byteLength - 3; syncPoint++) {
+      if (buffer[syncPoint + 2] === 1) {
+        // the sync point is properly aligned
+        i = syncPoint + 5;
+        break;
+      }
+    }
+
     while (i < buffer.byteLength) {
     while (i < buffer.byteLength) {
       // look at the current byte to determine if we've hit the end of
       // look at the current byte to determine if we've hit the end of
       // a NAL unit boundary
       // a NAL unit boundary
@@ -568,7 +578,7 @@ NalByteStream = function() {
         // drop trailing zeroes
         // drop trailing zeroes
         do {
         do {
           i++;
           i++;
-        } while (buffer[i] !== 1);
+        } while (buffer[i] !== 1 && i < buffer.length);
         syncPoint = i - 2;
         syncPoint = i - 2;
         i += 3;
         i += 3;
         break;
         break;

@@ -741,23 +741,60 @@ test('unpacks nal units from byte streams split across pushes', function() {
     type: 'video',
     type: 'video',
     data: new Uint8Array([
     data: new Uint8Array([
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
-      0x09])
+      0x09, 0x07, 0x06, 0x05,
+      0x04
+    ])
   });
   });
   ok(!data, 'buffers NAL units across events');
   ok(!data, 'buffers NAL units across events');
 
 
   h264Stream.push({
   h264Stream.push({
     type: 'video',
     type: 'video',
     data: new Uint8Array([
     data: new Uint8Array([
-      0x07,
+      0x03, 0x02, 0x01,
       0x00, 0x00, 0x01
       0x00, 0x00, 0x01
     ])
     ])
   });
   });
   ok(data, 'generated a data event');
   ok(data, 'generated a data event');
   equal(data.nalUnitType, 'access_unit_delimiter_rbsp', 'identified an access unit delimiter');
   equal(data.nalUnitType, 'access_unit_delimiter_rbsp', 'identified an access unit delimiter');
-  equal(data.data.length, 2, 'calculated nal unit length');
+  equal(data.data.length, 8, 'calculated nal unit length');
   equal(data.data[1], 7, 'read a payload byte');
   equal(data.data[1], 7, 'read a payload byte');
 });
 });
 
 
+test('buffers nal unit trailing zeros across pushes', function() {
+  var data = [];
+  h264Stream.on('data', function(event) {
+    data.push(event);
+  });
+
+  // lots of zeros after the nal, stretching into the next push
+  h264Stream.push({
+    type: 'video',
+    data: new Uint8Array([
+      0x00, 0x00, 0x00, 0x01,
+      0x09, 0x07, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x00
+    ])
+  });
+  equal(data.length, 1, 'delivered the first nal');
+
+  h264Stream.push({
+    type: 'video',
+    data: new Uint8Array([
+      0x00, 0x00,
+      0x00, 0x00, 0x01,
+      0x09, 0x06,
+      0x00, 0x00, 0x01
+    ])
+  });
+  equal(data.length, 2, 'generated data events');
+  equal(data[0].data.length, 2, 'ignored trailing zeros');
+  equal(data[0].data[0], 0x09, 'found the first nal start');
+  equal(data[1].data.length, 2, 'found the following nal start');
+  equal(data[1].data[0], 0x09, 'found the second nal start');
+});
+
 test('unpacks nal units from byte streams with split sync points', function() {
 test('unpacks nal units from byte streams with split sync points', function() {
   var data;
   var data;
   h264Stream.on('data', function(event) {
   h264Stream.on('data', function(event) {