From 10ef2acf730ec853624ecd1c3bb76c0d969768d4 Mon Sep 17 00:00:00 2001
From: ying_123 <zhangying@aten-optics.com>
Date: Thu, 8 Jun 2023 13:06:15 +0800
Subject: [PATCH] new version

---
 README.md                     |   11 +-
 dist/hls2mp4.cjs              | 6702 +++++++++++++++++++++++++++++++-
 dist/hls2mp4.js               | 6704 +++++++++++++++++++++++++++++++-
 dist/hls2mp4.umd.js           | 6708 ++++++++++++++++++++++++++++++++-
 dist/index.d.ts               |   11 +-
 dist/index.js                 | 6702 +++++++++++++++++++++++++++++++-
 dist/util/http.d.ts           |    1 +
 package.json                  |    9 +-
 rollup.config.mjs             |   14 +-
 src/index.ts                  |  150 +-
 src/muxer/mp4-transmuxer.d.ts |   25 +
 src/muxer/mp4-transmuxer.js   | 6446 +++++++++++++++++++++++++++++++
 src/util/http.ts              |    6 +
 yarn.lock                     |  132 +-
 14 files changed, 33024 insertions(+), 597 deletions(-)
 create mode 100644 dist/util/http.d.ts
 create mode 100644 src/muxer/mp4-transmuxer.d.ts
 create mode 100644 src/muxer/mp4-transmuxer.js
 create mode 100644 src/util/http.ts

diff --git a/README.md b/README.md
index 89ba2d1..8255ec0 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,6 @@
 ### A tool for download hls/m3u8 to mp4
 
-#### This package depends on @ffmpeg/ffmpeg, you need install it first
-
-```shell
-# install ffmpeg
-npm install @ffmpeg/ffmpeg @ffmpeg/core
-
-```
-
-##### for more information, see [https://github.com/ffmpegwasm/ffmpeg.wasm](https://github.com/ffmpegwasm/ffmpeg.wasm)
+#### no longer depend on @ffmpeg/ffmpeg since version 2.0
 
 ### online demo
 
@@ -44,7 +36,6 @@ hls2mp4.saveToFile(buffer, 'test.mp4')
 
 #### as script
 ```html
-<script src="static/js/ffmpeg.min.js"></script>
 <script src="dist/hls2mp4.js"></script>
 <script>
   const hls2mp4 = new Hls2Mp4({...})
diff --git a/dist/hls2mp4.cjs b/dist/hls2mp4.cjs
index 9c82b56..897dc1f 100644
--- a/dist/hls2mp4.cjs
+++ b/dist/hls2mp4.cjs
@@ -1,7 +1,5 @@
 'use strict';
 
-var FFmpeg = require('@ffmpeg/ffmpeg');
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -19,18 +17,6 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise */
 
 
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -81,10 +67,6464 @@ function __values(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
+var mp4Transmuxer = {exports: {}};
+
+/*! @name mux.js @version 6.3.0 @license Apache-2.0 */
+
+(function (module, exports) {
+	(function (global, factory) {
+	  module.exports = factory() ;
+	})(commonjsGlobal, (function () {
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   *
+	   * A lightweight readable stream implemention that handles event dispatching.
+	   * Objects that inherit from streams should call init in their constructors.
+	   */
+
+	  var Stream = function Stream() {
+	    this.init = function () {
+	      var listeners = {};
+	      /**
+	       * Add a listener for a specified event type.
+	       * @param type {string} the event name
+	       * @param listener {function} the callback to be invoked when an event of
+	       * the specified type occurs
+	       */
+	      this.on = function (type, listener) {
+	        if (!listeners[type]) {
+	          listeners[type] = [];
+	        }
+	        listeners[type] = listeners[type].concat(listener);
+	      };
+	      /**
+	       * Remove a listener for a specified event type.
+	       * @param type {string} the event name
+	       * @param listener {function} a function previously registered for this
+	       * type of event through `on`
+	       */
+	      this.off = function (type, listener) {
+	        var index;
+	        if (!listeners[type]) {
+	          return false;
+	        }
+	        index = listeners[type].indexOf(listener);
+	        listeners[type] = listeners[type].slice();
+	        listeners[type].splice(index, 1);
+	        return index > -1;
+	      };
+	      /**
+	       * Trigger an event of the specified type on this stream. Any additional
+	       * arguments to this function are passed as parameters to event listeners.
+	       * @param type {string} the event name
+	       */
+	      this.trigger = function (type) {
+	        var callbacks, i, length, args;
+	        callbacks = listeners[type];
+	        if (!callbacks) {
+	          return;
+	        }
+	        // Slicing the arguments on every invocation of this method
+	        // can add a significant amount of overhead. Avoid the
+	        // intermediate object creation for the common case of a
+	        // single callback argument
+	        if (arguments.length === 2) {
+	          length = callbacks.length;
+	          for (i = 0; i < length; ++i) {
+	            callbacks[i].call(this, arguments[1]);
+	          }
+	        } else {
+	          args = [];
+	          i = arguments.length;
+	          for (i = 1; i < arguments.length; ++i) {
+	            args.push(arguments[i]);
+	          }
+	          length = callbacks.length;
+	          for (i = 0; i < length; ++i) {
+	            callbacks[i].apply(this, args);
+	          }
+	        }
+	      };
+	      /**
+	       * Destroys the stream and cleans up.
+	       */
+	      this.dispose = function () {
+	        listeners = {};
+	      };
+	    };
+	  };
+
+	  /**
+	   * Forwards all `data` events on this stream to the destination stream. The
+	   * destination stream should provide a method `push` to receive the data
+	   * events as they arrive.
+	   * @param destination {stream} the stream that will receive all `data` events
+	   * @param autoFlush {boolean} if false, we will not call `flush` on the destination
+	   *                            when the current stream emits a 'done' event
+	   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
+	   */
+	  Stream.prototype.pipe = function (destination) {
+	    this.on('data', function (data) {
+	      destination.push(data);
+	    });
+	    this.on('done', function (flushSource) {
+	      destination.flush(flushSource);
+	    });
+	    this.on('partialdone', function (flushSource) {
+	      destination.partialFlush(flushSource);
+	    });
+	    this.on('endedtimeline', function (flushSource) {
+	      destination.endTimeline(flushSource);
+	    });
+	    this.on('reset', function (flushSource) {
+	      destination.reset(flushSource);
+	    });
+	    return destination;
+	  };
+
+	  // Default stream functions that are expected to be overridden to perform
+	  // actual work. These are provided by the prototype as a sort of no-op
+	  // implementation so that we don't have to check for their existence in the
+	  // `pipe` function above.
+	  Stream.prototype.push = function (data) {
+	    this.trigger('data', data);
+	  };
+	  Stream.prototype.flush = function (flushSource) {
+	    this.trigger('done', flushSource);
+	  };
+	  Stream.prototype.partialFlush = function (flushSource) {
+	    this.trigger('partialdone', flushSource);
+	  };
+	  Stream.prototype.endTimeline = function (flushSource) {
+	    this.trigger('endedtimeline', flushSource);
+	  };
+	  Stream.prototype.reset = function (flushSource) {
+	    this.trigger('reset', flushSource);
+	  };
+	  var stream = Stream;
+
+	  var MAX_UINT32$1 = Math.pow(2, 32);
+	  var getUint64 = function getUint64(uint8) {
+	    var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+	    var value;
+	    if (dv.getBigUint64) {
+	      value = dv.getBigUint64(0);
+	      if (value < Number.MAX_SAFE_INTEGER) {
+	        return Number(value);
+	      }
+	      return value;
+	    }
+	    return dv.getUint32(0) * MAX_UINT32$1 + dv.getUint32(4);
+	  };
+	  var numbers = {
+	    getUint64: getUint64,
+	    MAX_UINT32: MAX_UINT32$1
+	  };
+
+	  var MAX_UINT32 = numbers.MAX_UINT32;
+	  var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS;
+
+	  // pre-calculate constants
+	  (function () {
+	    var i;
+	    types = {
+	      avc1: [],
+	      // codingname
+	      avcC: [],
+	      btrt: [],
+	      dinf: [],
+	      dref: [],
+	      esds: [],
+	      ftyp: [],
+	      hdlr: [],
+	      mdat: [],
+	      mdhd: [],
+	      mdia: [],
+	      mfhd: [],
+	      minf: [],
+	      moof: [],
+	      moov: [],
+	      mp4a: [],
+	      // codingname
+	      mvex: [],
+	      mvhd: [],
+	      pasp: [],
+	      sdtp: [],
+	      smhd: [],
+	      stbl: [],
+	      stco: [],
+	      stsc: [],
+	      stsd: [],
+	      stsz: [],
+	      stts: [],
+	      styp: [],
+	      tfdt: [],
+	      tfhd: [],
+	      traf: [],
+	      trak: [],
+	      trun: [],
+	      trex: [],
+	      tkhd: [],
+	      vmhd: []
+	    };
+
+	    // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we
+	    // don't throw an error
+	    if (typeof Uint8Array === 'undefined') {
+	      return;
+	    }
+	    for (i in types) {
+	      if (types.hasOwnProperty(i)) {
+	        types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
+	      }
+	    }
+	    MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);
+	    AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);
+	    MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);
+	    VIDEO_HDLR = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // pre_defined
+	    0x76, 0x69, 0x64, 0x65,
+	    // handler_type: 'vide'
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
+	    ]);
+
+	    AUDIO_HDLR = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // pre_defined
+	    0x73, 0x6f, 0x75, 0x6e,
+	    // handler_type: 'soun'
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
+	    ]);
+
+	    HDLR_TYPES = {
+	      video: VIDEO_HDLR,
+	      audio: AUDIO_HDLR
+	    };
+	    DREF = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x01,
+	    // entry_count
+	    0x00, 0x00, 0x00, 0x0c,
+	    // entry_size
+	    0x75, 0x72, 0x6c, 0x20,
+	    // 'url' type
+	    0x00,
+	    // version 0
+	    0x00, 0x00, 0x01 // entry_flags
+	    ]);
+
+	    SMHD = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00,
+	    // balance, 0 means centered
+	    0x00, 0x00 // reserved
+	    ]);
+
+	    STCO = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00 // entry_count
+	    ]);
+
+	    STSC = STCO;
+	    STSZ = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // sample_size
+	    0x00, 0x00, 0x00, 0x00 // sample_count
+	    ]);
+
+	    STTS = STCO;
+	    VMHD = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x01,
+	    // flags
+	    0x00, 0x00,
+	    // graphicsmode
+	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
+	    ]);
+	  })();
+
+	  box = function box(type) {
+	    var payload = [],
+	      size = 0,
+	      i,
+	      result,
+	      view;
+	    for (i = 1; i < arguments.length; i++) {
+	      payload.push(arguments[i]);
+	    }
+	    i = payload.length;
+
+	    // calculate the total size we need to allocate
+	    while (i--) {
+	      size += payload[i].byteLength;
+	    }
+	    result = new Uint8Array(size + 8);
+	    view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+	    view.setUint32(0, result.byteLength);
+	    result.set(type, 4);
+
+	    // copy the payload into the result
+	    for (i = 0, size = 8; i < payload.length; i++) {
+	      result.set(payload[i], size);
+	      size += payload[i].byteLength;
+	    }
+	    return result;
+	  };
+	  dinf = function dinf() {
+	    return box(types.dinf, box(types.dref, DREF));
+	  };
+	  esds = function esds(track) {
+	    return box(types.esds, new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+
+	    // ES_Descriptor
+	    0x03,
+	    // tag, ES_DescrTag
+	    0x19,
+	    // length
+	    0x00, 0x00,
+	    // ES_ID
+	    0x00,
+	    // streamDependenceFlag, URL_flag, reserved, streamPriority
+
+	    // DecoderConfigDescriptor
+	    0x04,
+	    // tag, DecoderConfigDescrTag
+	    0x11,
+	    // length
+	    0x40,
+	    // object type
+	    0x15,
+	    // streamType
+	    0x00, 0x06, 0x00,
+	    // bufferSizeDB
+	    0x00, 0x00, 0xda, 0xc0,
+	    // maxBitrate
+	    0x00, 0x00, 0xda, 0xc0,
+	    // avgBitrate
+
+	    // DecoderSpecificInfo
+	    0x05,
+	    // tag, DecoderSpecificInfoTag
+	    0x02,
+	    // length
+	    // ISO/IEC 14496-3, AudioSpecificConfig
+	    // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
+	    track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig
+	    ]));
+	  };
+
+	  ftyp = function ftyp() {
+	    return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);
+	  };
+	  hdlr = function hdlr(type) {
+	    return box(types.hdlr, HDLR_TYPES[type]);
+	  };
+	  mdat = function mdat(data) {
+	    return box(types.mdat, data);
+	  };
+	  mdhd = function mdhd(track) {
+	    var result = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x02,
+	    // creation_time
+	    0x00, 0x00, 0x00, 0x03,
+	    // modification_time
+	    0x00, 0x01, 0x5f, 0x90,
+	    // timescale, 90,000 "ticks" per second
+
+	    track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF,
+	    // duration
+	    0x55, 0xc4,
+	    // 'und' language (undetermined)
+	    0x00, 0x00]);
+
+	    // Use the sample rate from the track metadata, when it is
+	    // defined. The sample rate can be parsed out of an ADTS header, for
+	    // instance.
+	    if (track.samplerate) {
+	      result[12] = track.samplerate >>> 24 & 0xFF;
+	      result[13] = track.samplerate >>> 16 & 0xFF;
+	      result[14] = track.samplerate >>> 8 & 0xFF;
+	      result[15] = track.samplerate & 0xFF;
+	    }
+	    return box(types.mdhd, result);
+	  };
+	  mdia = function mdia(track) {
+	    return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));
+	  };
+	  mfhd = function mfhd(sequenceNumber) {
+	    return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
+	    // flags
+	    (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number
+	    ]));
+	  };
+
+	  minf = function minf(track) {
+	    return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));
+	  };
+	  moof = function moof(sequenceNumber, tracks) {
+	    var trackFragments = [],
+	      i = tracks.length;
+	    // build traf boxes for each track fragment
+	    while (i--) {
+	      trackFragments[i] = traf(tracks[i]);
+	    }
+	    return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));
+	  };
+	  /**
+	   * Returns a movie box.
+	   * @param tracks {array} the tracks associated with this movie
+	   * @see ISO/IEC 14496-12:2012(E), section 8.2.1
+	   */
+	  moov = function moov(tracks, duration) {
+	    var i = tracks.length,
+	      boxes = [];
+	    while (i--) {
+	      boxes[i] = trak(tracks[i]);
+	    }
+	    return box.apply(null, [types.moov, mvhd(duration || 0xffffffff)].concat(boxes).concat(mvex(tracks)));
+	  };
+	  mvex = function mvex(tracks) {
+	    var i = tracks.length,
+	      boxes = [];
+	    while (i--) {
+	      boxes[i] = trex(tracks[i]);
+	    }
+	    return box.apply(null, [types.mvex].concat(boxes));
+	  };
+	  mvhd = function mvhd(duration) {
+	    var bytes = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x01,
+	    // creation_time
+	    0x00, 0x00, 0x00, 0x02,
+	    // modification_time
+	    0x00, 0x01, 0x5f, 0x90,
+	    // timescale, 90,000 "ticks" per second
+	    (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF,
+	    // duration
+	    0x00, 0x01, 0x00, 0x00,
+	    // 1.0 rate
+	    0x01, 0x00,
+	    // 1.0 volume
+	    0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+	    // transformation: unity matrix
+	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	    // pre_defined
+	    0xff, 0xff, 0xff, 0xff // next_track_ID
+	    ]);
+
+	    return box(types.mvhd, bytes);
+	  };
+	  sdtp = function sdtp(track) {
+	    var samples = track.samples || [],
+	      bytes = new Uint8Array(4 + samples.length),
+	      flags,
+	      i;
+
+	    // leave the full box header (4 bytes) all zero
+
+	    // write the sample table
+	    for (i = 0; i < samples.length; i++) {
+	      flags = samples[i].flags;
+	      bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
+	    }
+	    return box(types.sdtp, bytes);
+	  };
+	  stbl = function stbl(track) {
+	    return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));
+	  };
+	  (function () {
+	    var videoSample, audioSample;
+	    stsd = function stsd(track) {
+	      return box(types.stsd, new Uint8Array([0x00,
+	      // version 0
+	      0x00, 0x00, 0x00,
+	      // flags
+	      0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));
+	    };
+	    videoSample = function videoSample(track) {
+	      var sps = track.sps || [],
+	        pps = track.pps || [],
+	        sequenceParameterSets = [],
+	        pictureParameterSets = [],
+	        i,
+	        avc1Box;
+
+	      // assemble the SPSs
+	      for (i = 0; i < sps.length; i++) {
+	        sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);
+	        sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength
+	        sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS
+	      }
+
+	      // assemble the PPSs
+	      for (i = 0; i < pps.length; i++) {
+	        pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);
+	        pictureParameterSets.push(pps[i].byteLength & 0xFF);
+	        pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));
+	      }
+	      avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x01,
+	      // data_reference_index
+	      0x00, 0x00,
+	      // pre_defined
+	      0x00, 0x00,
+	      // reserved
+	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // pre_defined
+	      (track.width & 0xff00) >> 8, track.width & 0xff,
+	      // width
+	      (track.height & 0xff00) >> 8, track.height & 0xff,
+	      // height
+	      0x00, 0x48, 0x00, 0x00,
+	      // horizresolution
+	      0x00, 0x48, 0x00, 0x00,
+	      // vertresolution
+	      0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x01,
+	      // frame_count
+	      0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // compressorname
+	      0x00, 0x18,
+	      // depth = 24
+	      0x11, 0x11 // pre_defined = -1
+	      ]), box(types.avcC, new Uint8Array([0x01,
+	      // configurationVersion
+	      track.profileIdc,
+	      // AVCProfileIndication
+	      track.profileCompatibility,
+	      // profile_compatibility
+	      track.levelIdc,
+	      // AVCLevelIndication
+	      0xff // lengthSizeMinusOne, hard-coded to 4 bytes
+	      ].concat([sps.length],
+	      // numOfSequenceParameterSets
+	      sequenceParameterSets,
+	      // "SPS"
+	      [pps.length],
+	      // numOfPictureParameterSets
+	      pictureParameterSets // "PPS"
+	      ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
+	      // bufferSizeDB
+	      0x00, 0x2d, 0xc6, 0xc0,
+	      // maxBitrate
+	      0x00, 0x2d, 0xc6, 0xc0 // avgBitrate
+	      ]))];
+
+	      if (track.sarRatio) {
+	        var hSpacing = track.sarRatio[0],
+	          vSpacing = track.sarRatio[1];
+	        avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));
+	      }
+	      return box.apply(null, avc1Box);
+	    };
+	    audioSample = function audioSample(track) {
+	      return box(types.mp4a, new Uint8Array([
+	      // SampleEntry, ISO/IEC 14496-12
+	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x01,
+	      // data_reference_index
+
+	      // AudioSampleEntry, ISO/IEC 14496-12
+	      0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff,
+	      // channelcount
+
+	      (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff,
+	      // samplesize
+	      0x00, 0x00,
+	      // pre_defined
+	      0x00, 0x00,
+	      // reserved
+
+	      (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16
+
+	      // MP4AudioSampleEntry, ISO/IEC 14496-14
+	      ]), esds(track));
+	    };
+	  })();
+	  tkhd = function tkhd(track) {
+	    var result = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x07,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // creation_time
+	    0x00, 0x00, 0x00, 0x00,
+	    // modification_time
+	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+	    // track_ID
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF,
+	    // duration
+	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00,
+	    // layer
+	    0x00, 0x00,
+	    // alternate_group
+	    0x01, 0x00,
+	    // non-audio track volume
+	    0x00, 0x00,
+	    // reserved
+	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+	    // transformation: unity matrix
+	    (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00,
+	    // width
+	    (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height
+	    ]);
+
+	    return box(types.tkhd, result);
+	  };
+
+	  /**
+	   * Generate a track fragment (traf) box. A traf box collects metadata
+	   * about tracks in a movie fragment (moof) box.
+	   */
+	  traf = function traf(track) {
+	    var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;
+	    trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x3a,
+	    // flags
+	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+	    // track_ID
+	    0x00, 0x00, 0x00, 0x01,
+	    // sample_description_index
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_duration
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_size
+	    0x00, 0x00, 0x00, 0x00 // default_sample_flags
+	    ]));
+
+	    upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / MAX_UINT32);
+	    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % MAX_UINT32);
+	    trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01,
+	    // version 1
+	    0x00, 0x00, 0x00,
+	    // flags
+	    // baseMediaDecodeTime
+	    upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF]));
+
+	    // the data offset specifies the number of bytes from the start of
+	    // the containing moof to the first payload byte of the associated
+	    // mdat
+	    dataOffset = 32 +
+	    // tfhd
+	    20 +
+	    // tfdt
+	    8 +
+	    // traf header
+	    16 +
+	    // mfhd
+	    8 +
+	    // moof header
+	    8; // mdat header
+
+	    // audio tracks require less metadata
+	    if (track.type === 'audio') {
+	      trackFragmentRun = trun(track, dataOffset);
+	      return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);
+	    }
+
+	    // video tracks should contain an independent and disposable samples
+	    // box (sdtp)
+	    // generate one and adjust offsets to match
+	    sampleDependencyTable = sdtp(track);
+	    trackFragmentRun = trun(track, sampleDependencyTable.length + dataOffset);
+	    return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);
+	  };
+
+	  /**
+	   * Generate a track box.
+	   * @param track {object} a track definition
+	   * @return {Uint8Array} the track box
+	   */
+	  trak = function trak(track) {
+	    track.duration = track.duration || 0xffffffff;
+	    return box(types.trak, tkhd(track), mdia(track));
+	  };
+	  trex = function trex(track) {
+	    var result = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+	    // track_ID
+	    0x00, 0x00, 0x00, 0x01,
+	    // default_sample_description_index
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_duration
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_size
+	    0x00, 0x01, 0x00, 0x01 // default_sample_flags
+	    ]);
+	    // the last two bytes of default_sample_flags is the sample
+	    // degradation priority, a hint about the importance of this sample
+	    // relative to others. Lower the degradation priority for all sample
+	    // types other than video.
+	    if (track.type !== 'video') {
+	      result[result.length - 1] = 0x00;
+	    }
+	    return box(types.trex, result);
+	  };
+	  (function () {
+	    var audioTrun, videoTrun, trunHeader;
+
+	    // This method assumes all samples are uniform. That is, if a
+	    // duration is present for the first sample, it will be present for
+	    // all subsequent samples.
+	    // see ISO/IEC 14496-12:2012, Section 8.8.8.1
+	    trunHeader = function trunHeader(samples, offset) {
+	      var durationPresent = 0,
+	        sizePresent = 0,
+	        flagsPresent = 0,
+	        compositionTimeOffset = 0;
+
+	      // trun flag constants
+	      if (samples.length) {
+	        if (samples[0].duration !== undefined) {
+	          durationPresent = 0x1;
+	        }
+	        if (samples[0].size !== undefined) {
+	          sizePresent = 0x2;
+	        }
+	        if (samples[0].flags !== undefined) {
+	          flagsPresent = 0x4;
+	        }
+	        if (samples[0].compositionTimeOffset !== undefined) {
+	          compositionTimeOffset = 0x8;
+	        }
+	      }
+	      return [0x00,
+	      // version 0
+	      0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01,
+	      // flags
+	      (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF,
+	      // sample_count
+	      (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset
+	      ];
+	    };
+
+	    videoTrun = function videoTrun(track, offset) {
+	      var bytesOffest, bytes, header, samples, sample, i;
+	      samples = track.samples || [];
+	      offset += 8 + 12 + 16 * samples.length;
+	      header = trunHeader(samples, offset);
+	      bytes = new Uint8Array(header.length + samples.length * 16);
+	      bytes.set(header);
+	      bytesOffest = header.length;
+	      for (i = 0; i < samples.length; i++) {
+	        sample = samples[i];
+	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+	        bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;
+	        bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;
+	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;
+	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags
+	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset
+	      }
+
+	      return box(types.trun, bytes);
+	    };
+	    audioTrun = function audioTrun(track, offset) {
+	      var bytes, bytesOffest, header, samples, sample, i;
+	      samples = track.samples || [];
+	      offset += 8 + 12 + 8 * samples.length;
+	      header = trunHeader(samples, offset);
+	      bytes = new Uint8Array(header.length + samples.length * 8);
+	      bytes.set(header);
+	      bytesOffest = header.length;
+	      for (i = 0; i < samples.length; i++) {
+	        sample = samples[i];
+	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+	      }
+
+	      return box(types.trun, bytes);
+	    };
+	    trun = function trun(track, offset) {
+	      if (track.type === 'audio') {
+	        return audioTrun(track, offset);
+	      }
+	      return videoTrun(track, offset);
+	    };
+	  })();
+	  var mp4Generator = {
+	    ftyp: ftyp,
+	    mdat: mdat,
+	    moof: moof,
+	    moov: moov,
+	    initSegment: function initSegment(tracks) {
+	      var duration = tracks.reduce(function (p, n) {
+	        return p + n.duration;
+	      }, 0);
+	      var fileType = ftyp(),
+	        movie = moov(tracks, duration),
+	        result;
+	      result = new Uint8Array(fileType.byteLength + movie.byteLength);
+	      result.set(fileType);
+	      result.set(movie, fileType.byteLength);
+	      return result;
+	    }
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  // Convert an array of nal units into an array of frames with each frame being
+	  // composed of the nal units that make up that frame
+	  // Also keep track of cummulative data about the frame from the nal units such
+	  // as the frame duration, starting pts, etc.
+	  var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {
+	    var i,
+	      currentNal,
+	      currentFrame = [],
+	      frames = [];
+
+	    // TODO added for LHLS, make sure this is OK
+	    frames.byteLength = 0;
+	    frames.nalCount = 0;
+	    frames.duration = 0;
+	    currentFrame.byteLength = 0;
+	    for (i = 0; i < nalUnits.length; i++) {
+	      currentNal = nalUnits[i];
+
+	      // Split on 'aud'-type nal units
+	      if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
+	        // Since the very first nal unit is expected to be an AUD
+	        // only push to the frames array when currentFrame is not empty
+	        if (currentFrame.length) {
+	          currentFrame.duration = currentNal.dts - currentFrame.dts;
+	          // TODO added for LHLS, make sure this is OK
+	          frames.byteLength += currentFrame.byteLength;
+	          frames.nalCount += currentFrame.length;
+	          frames.duration += currentFrame.duration;
+	          frames.push(currentFrame);
+	        }
+	        currentFrame = [currentNal];
+	        currentFrame.byteLength = currentNal.data.byteLength;
+	        currentFrame.pts = currentNal.pts;
+	        currentFrame.dts = currentNal.dts;
+	      } else {
+	        // Specifically flag key frames for ease of use later
+	        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
+	          currentFrame.keyFrame = true;
+	        }
+	        currentFrame.duration = currentNal.dts - currentFrame.dts;
+	        currentFrame.byteLength += currentNal.data.byteLength;
+	        currentFrame.push(currentNal);
+	      }
+	    }
+
+	    // For the last frame, use the duration of the previous frame if we
+	    // have nothing better to go on
+	    if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {
+	      currentFrame.duration = frames[frames.length - 1].duration;
+	    }
+
+	    // Push the final frame
+	    // TODO added for LHLS, make sure this is OK
+	    frames.byteLength += currentFrame.byteLength;
+	    frames.nalCount += currentFrame.length;
+	    frames.duration += currentFrame.duration;
+	    frames.push(currentFrame);
+	    return frames;
+	  };
+
+	  // Convert an array of frames into an array of Gop with each Gop being composed
+	  // of the frames that make up that Gop
+	  // Also keep track of cummulative data about the Gop from the frames such as the
+	  // Gop duration, starting pts, etc.
+	  var groupFramesIntoGops = function groupFramesIntoGops(frames) {
+	    var i,
+	      currentFrame,
+	      currentGop = [],
+	      gops = [];
+
+	    // We must pre-set some of the values on the Gop since we
+	    // keep running totals of these values
+	    currentGop.byteLength = 0;
+	    currentGop.nalCount = 0;
+	    currentGop.duration = 0;
+	    currentGop.pts = frames[0].pts;
+	    currentGop.dts = frames[0].dts;
+
+	    // store some metadata about all the Gops
+	    gops.byteLength = 0;
+	    gops.nalCount = 0;
+	    gops.duration = 0;
+	    gops.pts = frames[0].pts;
+	    gops.dts = frames[0].dts;
+	    for (i = 0; i < frames.length; i++) {
+	      currentFrame = frames[i];
+	      if (currentFrame.keyFrame) {
+	        // Since the very first frame is expected to be an keyframe
+	        // only push to the gops array when currentGop is not empty
+	        if (currentGop.length) {
+	          gops.push(currentGop);
+	          gops.byteLength += currentGop.byteLength;
+	          gops.nalCount += currentGop.nalCount;
+	          gops.duration += currentGop.duration;
+	        }
+	        currentGop = [currentFrame];
+	        currentGop.nalCount = currentFrame.length;
+	        currentGop.byteLength = currentFrame.byteLength;
+	        currentGop.pts = currentFrame.pts;
+	        currentGop.dts = currentFrame.dts;
+	        currentGop.duration = currentFrame.duration;
+	      } else {
+	        currentGop.duration += currentFrame.duration;
+	        currentGop.nalCount += currentFrame.length;
+	        currentGop.byteLength += currentFrame.byteLength;
+	        currentGop.push(currentFrame);
+	      }
+	    }
+	    if (gops.length && currentGop.duration <= 0) {
+	      currentGop.duration = gops[gops.length - 1].duration;
+	    }
+	    gops.byteLength += currentGop.byteLength;
+	    gops.nalCount += currentGop.nalCount;
+	    gops.duration += currentGop.duration;
+
+	    // push the final Gop
+	    gops.push(currentGop);
+	    return gops;
+	  };
+
+	  /*
+	   * Search for the first keyframe in the GOPs and throw away all frames
+	   * until that keyframe. Then extend the duration of the pulled keyframe
+	   * and pull the PTS and DTS of the keyframe so that it covers the time
+	   * range of the frames that were disposed.
+	   *
+	   * @param {Array} gops video GOPs
+	   * @returns {Array} modified video GOPs
+	   */
+	  var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {
+	    var currentGop;
+	    if (!gops[0][0].keyFrame && gops.length > 1) {
+	      // Remove the first GOP
+	      currentGop = gops.shift();
+	      gops.byteLength -= currentGop.byteLength;
+	      gops.nalCount -= currentGop.nalCount;
+
+	      // Extend the first frame of what is now the
+	      // first gop to cover the time period of the
+	      // frames we just removed
+	      gops[0][0].dts = currentGop.dts;
+	      gops[0][0].pts = currentGop.pts;
+	      gops[0][0].duration += currentGop.duration;
+	    }
+	    return gops;
+	  };
+
+	  /**
+	   * Default sample object
+	   * see ISO/IEC 14496-12:2012, section 8.6.4.3
+	   */
+	  var createDefaultSample = function createDefaultSample() {
+	    return {
+	      size: 0,
+	      flags: {
+	        isLeading: 0,
+	        dependsOn: 1,
+	        isDependedOn: 0,
+	        hasRedundancy: 0,
+	        degradationPriority: 0,
+	        isNonSyncSample: 1
+	      }
+	    };
+	  };
+
+	  /*
+	   * Collates information from a video frame into an object for eventual
+	   * entry into an MP4 sample table.
+	   *
+	   * @param {Object} frame the video frame
+	   * @param {Number} dataOffset the byte offset to position the sample
+	   * @return {Object} object containing sample table info for a frame
+	   */
+	  var sampleForFrame = function sampleForFrame(frame, dataOffset) {
+	    var sample = createDefaultSample();
+	    sample.dataOffset = dataOffset;
+	    sample.compositionTimeOffset = frame.pts - frame.dts;
+	    sample.duration = frame.duration;
+	    sample.size = 4 * frame.length; // Space for nal unit size
+	    sample.size += frame.byteLength;
+	    if (frame.keyFrame) {
+	      sample.flags.dependsOn = 2;
+	      sample.flags.isNonSyncSample = 0;
+	    }
+	    return sample;
+	  };
+
+	  // generate the track's sample table from an array of gops
+	  var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {
+	    var h,
+	      i,
+	      sample,
+	      currentGop,
+	      currentFrame,
+	      dataOffset = baseDataOffset || 0,
+	      samples = [];
+	    for (h = 0; h < gops.length; h++) {
+	      currentGop = gops[h];
+	      for (i = 0; i < currentGop.length; i++) {
+	        currentFrame = currentGop[i];
+	        sample = sampleForFrame(currentFrame, dataOffset);
+	        dataOffset += sample.size;
+	        samples.push(sample);
+	      }
+	    }
+	    return samples;
+	  };
+
+	  // generate the track's raw mdat data from an array of gops
+	  var concatenateNalData = function concatenateNalData(gops) {
+	    var h,
+	      i,
+	      j,
+	      currentGop,
+	      currentFrame,
+	      currentNal,
+	      dataOffset = 0,
+	      nalsByteLength = gops.byteLength,
+	      numberOfNals = gops.nalCount,
+	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+	      data = new Uint8Array(totalByteLength),
+	      view = new DataView(data.buffer);
+
+	    // For each Gop..
+	    for (h = 0; h < gops.length; h++) {
+	      currentGop = gops[h];
+
+	      // For each Frame..
+	      for (i = 0; i < currentGop.length; i++) {
+	        currentFrame = currentGop[i];
+
+	        // For each NAL..
+	        for (j = 0; j < currentFrame.length; j++) {
+	          currentNal = currentFrame[j];
+	          view.setUint32(dataOffset, currentNal.data.byteLength);
+	          dataOffset += 4;
+	          data.set(currentNal.data, dataOffset);
+	          dataOffset += currentNal.data.byteLength;
+	        }
+	      }
+	    }
+	    return data;
+	  };
+
+	  // generate the track's sample table from a frame
+	  var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {
+	    var sample,
+	      dataOffset = baseDataOffset || 0,
+	      samples = [];
+	    sample = sampleForFrame(frame, dataOffset);
+	    samples.push(sample);
+	    return samples;
+	  };
+
+	  // generate the track's raw mdat data from a frame
+	  var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {
+	    var i,
+	      currentNal,
+	      dataOffset = 0,
+	      nalsByteLength = frame.byteLength,
+	      numberOfNals = frame.length,
+	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+	      data = new Uint8Array(totalByteLength),
+	      view = new DataView(data.buffer);
+
+	    // For each NAL..
+	    for (i = 0; i < frame.length; i++) {
+	      currentNal = frame[i];
+	      view.setUint32(dataOffset, currentNal.data.byteLength);
+	      dataOffset += 4;
+	      data.set(currentNal.data, dataOffset);
+	      dataOffset += currentNal.data.byteLength;
+	    }
+	    return data;
+	  };
+	  var frameUtils = {
+	    groupNalsIntoFrames: groupNalsIntoFrames,
+	    groupFramesIntoGops: groupFramesIntoGops,
+	    extendFirstKeyFrame: extendFirstKeyFrame,
+	    generateSampleTable: generateSampleTable$1,
+	    concatenateNalData: concatenateNalData,
+	    generateSampleTableForFrame: generateSampleTableForFrame,
+	    concatenateNalDataForFrame: concatenateNalDataForFrame
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  var highPrefix = [33, 16, 5, 32, 164, 27];
+	  var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];
+	  var zeroFill = function zeroFill(count) {
+	    var a = [];
+	    while (count--) {
+	      a.push(0);
+	    }
+	    return a;
+	  };
+	  var makeTable = function makeTable(metaTable) {
+	    return Object.keys(metaTable).reduce(function (obj, key) {
+	      obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {
+	        return arr.concat(part);
+	      }, []));
+	      return obj;
+	    }, {});
+	  };
+	  var silence;
+	  var silence_1 = function silence_1() {
+	    if (!silence) {
+	      // Frames-of-silence to use for filling in missing AAC frames
+	      var coneOfSilence = {
+	        96000: [highPrefix, [227, 64], zeroFill(154), [56]],
+	        88200: [highPrefix, [231], zeroFill(170), [56]],
+	        64000: [highPrefix, [248, 192], zeroFill(240), [56]],
+	        48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],
+	        44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],
+	        32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],
+	        24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],
+	        16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],
+	        12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],
+	        11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],
+	        8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]
+	      };
+	      silence = makeTable(coneOfSilence);
+	    }
+	    return silence;
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  var ONE_SECOND_IN_TS$3 = 90000,
+	    // 90kHz clock
+	    secondsToVideoTs,
+	    secondsToAudioTs,
+	    videoTsToSeconds,
+	    audioTsToSeconds,
+	    audioTsToVideoTs,
+	    videoTsToAudioTs,
+	    metadataTsToSeconds;
+	  secondsToVideoTs = function secondsToVideoTs(seconds) {
+	    return seconds * ONE_SECOND_IN_TS$3;
+	  };
+	  secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {
+	    return seconds * sampleRate;
+	  };
+	  videoTsToSeconds = function videoTsToSeconds(timestamp) {
+	    return timestamp / ONE_SECOND_IN_TS$3;
+	  };
+	  audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {
+	    return timestamp / sampleRate;
+	  };
+	  audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {
+	    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
+	  };
+	  videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {
+	    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
+	  };
+
+	  /**
+	   * Adjust ID3 tag or caption timing information by the timeline pts values
+	   * (if keepOriginalTimestamps is false) and convert to seconds
+	   */
+	  metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {
+	    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
+	  };
+	  var clock = {
+	    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$3,
+	    secondsToVideoTs: secondsToVideoTs,
+	    secondsToAudioTs: secondsToAudioTs,
+	    videoTsToSeconds: videoTsToSeconds,
+	    audioTsToSeconds: audioTsToSeconds,
+	    audioTsToVideoTs: audioTsToVideoTs,
+	    videoTsToAudioTs: videoTsToAudioTs,
+	    metadataTsToSeconds: metadataTsToSeconds
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+
+	  /**
+	   * Sum the `byteLength` properties of the data in each AAC frame
+	   */
+	  var sumFrameByteLengths = function sumFrameByteLengths(array) {
+	    var i,
+	      currentObj,
+	      sum = 0;
+
+	    // sum the byteLength's all each nal unit in the frame
+	    for (i = 0; i < array.length; i++) {
+	      currentObj = array[i];
+	      sum += currentObj.data.byteLength;
+	    }
+	    return sum;
+	  };
+
+	  // Possibly pad (prefix) the audio track with silence if appending this track
+	  // would lead to the introduction of a gap in the audio buffer
+	  var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {
+	    var baseMediaDecodeTimeTs,
+	      frameDuration = 0,
+	      audioGapDuration = 0,
+	      audioFillFrameCount = 0,
+	      audioFillDuration = 0,
+	      silentFrame,
+	      i,
+	      firstFrame;
+	    if (!frames.length) {
+	      return;
+	    }
+	    baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate);
+	    // determine frame clock duration based on sample rate, round up to avoid overfills
+	    frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));
+	    if (audioAppendStartTs && videoBaseMediaDecodeTime) {
+	      // insert the shortest possible amount (audio gap or audio to video gap)
+	      audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime);
+	      // number of full frames in the audio gap
+	      audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);
+	      audioFillDuration = audioFillFrameCount * frameDuration;
+	    }
+
+	    // don't attempt to fill gaps smaller than a single frame or larger
+	    // than a half second
+	    if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {
+	      return;
+	    }
+	    silentFrame = silence_1()[track.samplerate];
+	    if (!silentFrame) {
+	      // we don't have a silent frame pregenerated for the sample rate, so use a frame
+	      // from the content instead
+	      silentFrame = frames[0].data;
+	    }
+	    for (i = 0; i < audioFillFrameCount; i++) {
+	      firstFrame = frames[0];
+	      frames.splice(0, 0, {
+	        data: silentFrame,
+	        dts: firstFrame.dts - frameDuration,
+	        pts: firstFrame.pts - frameDuration
+	      });
+	    }
+	    track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));
+	    return audioFillDuration;
+	  };
+
+	  // If the audio segment extends before the earliest allowed dts
+	  // value, remove AAC frames until starts at or after the earliest
+	  // allowed DTS so that we don't end up with a negative baseMedia-
+	  // DecodeTime for the audio track
+	  var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {
+	    if (track.minSegmentDts >= earliestAllowedDts) {
+	      return adtsFrames;
+	    }
+
+	    // We will need to recalculate the earliest segment Dts
+	    track.minSegmentDts = Infinity;
+	    return adtsFrames.filter(function (currentFrame) {
+	      // If this is an allowed frame, keep it and record it's Dts
+	      if (currentFrame.dts >= earliestAllowedDts) {
+	        track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);
+	        track.minSegmentPts = track.minSegmentDts;
+	        return true;
+	      }
+	      // Otherwise, discard it
+	      return false;
+	    });
+	  };
+
+	  // generate the track's raw mdat data from an array of frames
+	  var generateSampleTable = function generateSampleTable(frames) {
+	    var i,
+	      currentFrame,
+	      samples = [];
+	    for (i = 0; i < frames.length; i++) {
+	      currentFrame = frames[i];
+	      samples.push({
+	        size: currentFrame.data.byteLength,
+	        duration: 1024 // For AAC audio, all samples contain 1024 samples
+	      });
+	    }
+
+	    return samples;
+	  };
+
+	  // generate the track's sample table from an array of frames
+	  var concatenateFrameData = function concatenateFrameData(frames) {
+	    var i,
+	      currentFrame,
+	      dataOffset = 0,
+	      data = new Uint8Array(sumFrameByteLengths(frames));
+	    for (i = 0; i < frames.length; i++) {
+	      currentFrame = frames[i];
+	      data.set(currentFrame.data, dataOffset);
+	      dataOffset += currentFrame.data.byteLength;
+	    }
+	    return data;
+	  };
+	  var audioFrameUtils = {
+	    prefixWithSilence: prefixWithSilence,
+	    trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,
+	    generateSampleTable: generateSampleTable,
+	    concatenateFrameData: concatenateFrameData
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS;
+
+	  /**
+	   * Store information about the start and end of the track and the
+	   * duration for each frame/sample we process in order to calculate
+	   * the baseMediaDecodeTime
+	   */
+	  var collectDtsInfo = function collectDtsInfo(track, data) {
+	    if (typeof data.pts === 'number') {
+	      if (track.timelineStartInfo.pts === undefined) {
+	        track.timelineStartInfo.pts = data.pts;
+	      }
+	      if (track.minSegmentPts === undefined) {
+	        track.minSegmentPts = data.pts;
+	      } else {
+	        track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);
+	      }
+	      if (track.maxSegmentPts === undefined) {
+	        track.maxSegmentPts = data.pts;
+	      } else {
+	        track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);
+	      }
+	    }
+	    if (typeof data.dts === 'number') {
+	      if (track.timelineStartInfo.dts === undefined) {
+	        track.timelineStartInfo.dts = data.dts;
+	      }
+	      if (track.minSegmentDts === undefined) {
+	        track.minSegmentDts = data.dts;
+	      } else {
+	        track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);
+	      }
+	      if (track.maxSegmentDts === undefined) {
+	        track.maxSegmentDts = data.dts;
+	      } else {
+	        track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);
+	      }
+	    }
+	  };
+
+	  /**
+	   * Clear values used to calculate the baseMediaDecodeTime between
+	   * tracks
+	   */
+	  var clearDtsInfo = function clearDtsInfo(track) {
+	    delete track.minSegmentDts;
+	    delete track.maxSegmentDts;
+	    delete track.minSegmentPts;
+	    delete track.maxSegmentPts;
+	  };
+
+	  /**
+	   * Calculate the track's baseMediaDecodeTime based on the earliest
+	   * DTS the transmuxer has ever seen and the minimum DTS for the
+	   * current track
+	   * @param track {object} track metadata configuration
+	   * @param keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at 0.
+	   */
+	  var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {
+	    var baseMediaDecodeTime,
+	      scale,
+	      minSegmentDts = track.minSegmentDts;
+
+	    // Optionally adjust the time so the first segment starts at zero.
+	    if (!keepOriginalTimestamps) {
+	      minSegmentDts -= track.timelineStartInfo.dts;
+	    }
+
+	    // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where
+	    // we want the start of the first segment to be placed
+	    baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime;
+
+	    // Add to that the distance this segment is from the very first
+	    baseMediaDecodeTime += minSegmentDts;
+
+	    // baseMediaDecodeTime must not become negative
+	    baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);
+	    if (track.type === 'audio') {
+	      // Audio has a different clock equal to the sampling_rate so we need to
+	      // scale the PTS values into the clock rate of the track
+	      scale = track.samplerate / ONE_SECOND_IN_TS$2;
+	      baseMediaDecodeTime *= scale;
+	      baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);
+	    }
+	    return baseMediaDecodeTime;
+	  };
+	  var trackDecodeInfo = {
+	    clearDtsInfo: clearDtsInfo,
+	    calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,
+	    collectDtsInfo: collectDtsInfo
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   *
+	   * Reads in-band caption information from a video elementary
+	   * stream. Captions must follow the CEA-708 standard for injection
+	   * into an MPEG-2 transport streams.
+	   * @see https://en.wikipedia.org/wiki/CEA-708
+	   * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf
+	   */
+
+	  // Supplemental enhancement information (SEI) NAL units have a
+	  // payload type field to indicate how they are to be
+	  // interpreted. CEAS-708 caption content is always transmitted with
+	  // payload type 0x04.
+	  var USER_DATA_REGISTERED_ITU_T_T35 = 4,
+	    RBSP_TRAILING_BITS = 128;
+
+	  /**
+	    * Parse a supplemental enhancement information (SEI) NAL unit.
+	    * Stops parsing once a message of type ITU T T35 has been found.
+	    *
+	    * @param bytes {Uint8Array} the bytes of a SEI NAL unit
+	    * @return {object} the parsed SEI payload
+	    * @see Rec. ITU-T H.264, 7.3.2.3.1
+	    */
+	  var parseSei = function parseSei(bytes) {
+	    var i = 0,
+	      result = {
+	        payloadType: -1,
+	        payloadSize: 0
+	      },
+	      payloadType = 0,
+	      payloadSize = 0;
+
+	    // go through the sei_rbsp parsing each each individual sei_message
+	    while (i < bytes.byteLength) {
+	      // stop once we have hit the end of the sei_rbsp
+	      if (bytes[i] === RBSP_TRAILING_BITS) {
+	        break;
+	      }
+
+	      // Parse payload type
+	      while (bytes[i] === 0xFF) {
+	        payloadType += 255;
+	        i++;
+	      }
+	      payloadType += bytes[i++];
+
+	      // Parse payload size
+	      while (bytes[i] === 0xFF) {
+	        payloadSize += 255;
+	        i++;
+	      }
+	      payloadSize += bytes[i++];
+
+	      // this sei_message is a 608/708 caption so save it and break
+	      // there can only ever be one caption message in a frame's sei
+	      if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {
+	        var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);
+	        if (userIdentifier === 'GA94') {
+	          result.payloadType = payloadType;
+	          result.payloadSize = payloadSize;
+	          result.payload = bytes.subarray(i, i + payloadSize);
+	          break;
+	        } else {
+	          result.payload = void 0;
+	        }
+	      }
+
+	      // skip the payload and parse the next message
+	      i += payloadSize;
+	      payloadType = 0;
+	      payloadSize = 0;
+	    }
+	    return result;
+	  };
+
+	  // see ANSI/SCTE 128-1 (2013), section 8.1
+	  var parseUserData = function parseUserData(sei) {
+	    // itu_t_t35_contry_code must be 181 (United States) for
+	    // captions
+	    if (sei.payload[0] !== 181) {
+	      return null;
+	    }
+
+	    // itu_t_t35_provider_code should be 49 (ATSC) for captions
+	    if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {
+	      return null;
+	    }
+
+	    // the user_identifier should be "GA94" to indicate ATSC1 data
+	    if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {
+	      return null;
+	    }
+
+	    // finally, user_data_type_code should be 0x03 for caption data
+	    if (sei.payload[7] !== 0x03) {
+	      return null;
+	    }
+
+	    // return the user_data_type_structure and strip the trailing
+	    // marker bits
+	    return sei.payload.subarray(8, sei.payload.length - 1);
+	  };
+
+	  // see CEA-708-D, section 4.4
+	  var parseCaptionPackets = function parseCaptionPackets(pts, userData) {
+	    var results = [],
+	      i,
+	      count,
+	      offset,
+	      data;
+
+	    // if this is just filler, return immediately
+	    if (!(userData[0] & 0x40)) {
+	      return results;
+	    }
+
+	    // parse out the cc_data_1 and cc_data_2 fields
+	    count = userData[0] & 0x1f;
+	    for (i = 0; i < count; i++) {
+	      offset = i * 3;
+	      data = {
+	        type: userData[offset + 2] & 0x03,
+	        pts: pts
+	      };
+
+	      // capture cc data when cc_valid is 1
+	      if (userData[offset + 2] & 0x04) {
+	        data.ccData = userData[offset + 3] << 8 | userData[offset + 4];
+	        results.push(data);
+	      }
+	    }
+	    return results;
+	  };
+	  var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+	    var length = data.byteLength,
+	      emulationPreventionBytesPositions = [],
+	      i = 1,
+	      newLength,
+	      newData;
+
+	    // Find all `Emulation Prevention Bytes`
+	    while (i < length - 2) {
+	      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+	        emulationPreventionBytesPositions.push(i + 2);
+	        i += 2;
+	      } else {
+	        i++;
+	      }
+	    }
+
+	    // If no Emulation Prevention Bytes were found just return the original
+	    // array
+	    if (emulationPreventionBytesPositions.length === 0) {
+	      return data;
+	    }
+
+	    // Create a new array to hold the NAL unit data
+	    newLength = length - emulationPreventionBytesPositions.length;
+	    newData = new Uint8Array(newLength);
+	    var sourceIndex = 0;
+	    for (i = 0; i < newLength; sourceIndex++, i++) {
+	      if (sourceIndex === emulationPreventionBytesPositions[0]) {
+	        // Skip this byte
+	        sourceIndex++;
+	        // Remove this position index
+	        emulationPreventionBytesPositions.shift();
+	      }
+	      newData[i] = data[sourceIndex];
+	    }
+	    return newData;
+	  };
+
+	  // exports
+	  var captionPacketParser = {
+	    parseSei: parseSei,
+	    parseUserData: parseUserData,
+	    parseCaptionPackets: parseCaptionPackets,
+	    discardEmulationPreventionBytes: discardEmulationPreventionBytes,
+	    USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35
+	  };
+
+	  // -----------------
+	  // Link To Transport
+	  // -----------------
+
+	  var CaptionStream = function CaptionStream(options) {
+	    options = options || {};
+	    CaptionStream.prototype.init.call(this);
+
+	    // parse708captions flag, default to true
+	    this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;
+	    this.captionPackets_ = [];
+	    this.ccStreams_ = [new Cea608Stream(0, 0),
+	    // eslint-disable-line no-use-before-define
+	    new Cea608Stream(0, 1),
+	    // eslint-disable-line no-use-before-define
+	    new Cea608Stream(1, 0),
+	    // eslint-disable-line no-use-before-define
+	    new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define
+	    ];
+
+	    if (this.parse708captions_) {
+	      this.cc708Stream_ = new Cea708Stream({
+	        captionServices: options.captionServices
+	      }); // eslint-disable-line no-use-before-define
+	    }
+
+	    this.reset();
+
+	    // forward data and done events from CCs to this CaptionStream
+	    this.ccStreams_.forEach(function (cc) {
+	      cc.on('data', this.trigger.bind(this, 'data'));
+	      cc.on('partialdone', this.trigger.bind(this, 'partialdone'));
+	      cc.on('done', this.trigger.bind(this, 'done'));
+	    }, this);
+	    if (this.parse708captions_) {
+	      this.cc708Stream_.on('data', this.trigger.bind(this, 'data'));
+	      this.cc708Stream_.on('partialdone', this.trigger.bind(this, 'partialdone'));
+	      this.cc708Stream_.on('done', this.trigger.bind(this, 'done'));
+	    }
+	  };
+	  CaptionStream.prototype = new stream();
+	  CaptionStream.prototype.push = function (event) {
+	    var sei, userData, newCaptionPackets;
+
+	    // only examine SEI NALs
+	    if (event.nalUnitType !== 'sei_rbsp') {
+	      return;
+	    }
+
+	    // parse the sei
+	    sei = captionPacketParser.parseSei(event.escapedRBSP);
+
+	    // no payload data, skip
+	    if (!sei.payload) {
+	      return;
+	    }
+
+	    // ignore everything but user_data_registered_itu_t_t35
+	    if (sei.payloadType !== captionPacketParser.USER_DATA_REGISTERED_ITU_T_T35) {
+	      return;
+	    }
+
+	    // parse out the user data payload
+	    userData = captionPacketParser.parseUserData(sei);
+
+	    // ignore unrecognized userData
+	    if (!userData) {
+	      return;
+	    }
+
+	    // Sometimes, the same segment # will be downloaded twice. To stop the
+	    // caption data from being processed twice, we track the latest dts we've
+	    // received and ignore everything with a dts before that. However, since
+	    // data for a specific dts can be split across packets on either side of
+	    // a segment boundary, we need to make sure we *don't* ignore the packets
+	    // from the *next* segment that have dts === this.latestDts_. By constantly
+	    // tracking the number of packets received with dts === this.latestDts_, we
+	    // know how many should be ignored once we start receiving duplicates.
+	    if (event.dts < this.latestDts_) {
+	      // We've started getting older data, so set the flag.
+	      this.ignoreNextEqualDts_ = true;
+	      return;
+	    } else if (event.dts === this.latestDts_ && this.ignoreNextEqualDts_) {
+	      this.numSameDts_--;
+	      if (!this.numSameDts_) {
+	        // We've received the last duplicate packet, time to start processing again
+	        this.ignoreNextEqualDts_ = false;
+	      }
+	      return;
+	    }
+
+	    // parse out CC data packets and save them for later
+	    newCaptionPackets = captionPacketParser.parseCaptionPackets(event.pts, userData);
+	    this.captionPackets_ = this.captionPackets_.concat(newCaptionPackets);
+	    if (this.latestDts_ !== event.dts) {
+	      this.numSameDts_ = 0;
+	    }
+	    this.numSameDts_++;
+	    this.latestDts_ = event.dts;
+	  };
+	  CaptionStream.prototype.flushCCStreams = function (flushType) {
+	    this.ccStreams_.forEach(function (cc) {
+	      return flushType === 'flush' ? cc.flush() : cc.partialFlush();
+	    }, this);
+	  };
+	  CaptionStream.prototype.flushStream = function (flushType) {
+	    // make sure we actually parsed captions before proceeding
+	    if (!this.captionPackets_.length) {
+	      this.flushCCStreams(flushType);
+	      return;
+	    }
+
+	    // In Chrome, the Array#sort function is not stable so add a
+	    // presortIndex that we can use to ensure we get a stable-sort
+	    this.captionPackets_.forEach(function (elem, idx) {
+	      elem.presortIndex = idx;
+	    });
+
+	    // sort caption byte-pairs based on their PTS values
+	    this.captionPackets_.sort(function (a, b) {
+	      if (a.pts === b.pts) {
+	        return a.presortIndex - b.presortIndex;
+	      }
+	      return a.pts - b.pts;
+	    });
+	    this.captionPackets_.forEach(function (packet) {
+	      if (packet.type < 2) {
+	        // Dispatch packet to the right Cea608Stream
+	        this.dispatchCea608Packet(packet);
+	      } else {
+	        // Dispatch packet to the Cea708Stream
+	        this.dispatchCea708Packet(packet);
+	      }
+	    }, this);
+	    this.captionPackets_.length = 0;
+	    this.flushCCStreams(flushType);
+	  };
+	  CaptionStream.prototype.flush = function () {
+	    return this.flushStream('flush');
+	  };
+
+	  // Only called if handling partial data
+	  CaptionStream.prototype.partialFlush = function () {
+	    return this.flushStream('partialFlush');
+	  };
+	  CaptionStream.prototype.reset = function () {
+	    this.latestDts_ = null;
+	    this.ignoreNextEqualDts_ = false;
+	    this.numSameDts_ = 0;
+	    this.activeCea608Channel_ = [null, null];
+	    this.ccStreams_.forEach(function (ccStream) {
+	      ccStream.reset();
+	    });
+	  };
+
+	  // From the CEA-608 spec:
+	  /*
+	   * When XDS sub-packets are interleaved with other services, the end of each sub-packet shall be followed
+	   * by a control pair to change to a different service. When any of the control codes from 0x10 to 0x1F is
+	   * used to begin a control code pair, it indicates the return to captioning or Text data. The control code pair
+	   * and subsequent data should then be processed according to the FCC rules. It may be necessary for the
+	   * line 21 data encoder to automatically insert a control code pair (i.e. RCL, RU2, RU3, RU4, RDC, or RTD)
+	   * to switch to captioning or Text.
+	  */
+	  // With that in mind, we ignore any data between an XDS control code and a
+	  // subsequent closed-captioning control code.
+	  CaptionStream.prototype.dispatchCea608Packet = function (packet) {
+	    // NOTE: packet.type is the CEA608 field
+	    if (this.setsTextOrXDSActive(packet)) {
+	      this.activeCea608Channel_[packet.type] = null;
+	    } else if (this.setsChannel1Active(packet)) {
+	      this.activeCea608Channel_[packet.type] = 0;
+	    } else if (this.setsChannel2Active(packet)) {
+	      this.activeCea608Channel_[packet.type] = 1;
+	    }
+	    if (this.activeCea608Channel_[packet.type] === null) {
+	      // If we haven't received anything to set the active channel, or the
+	      // packets are Text/XDS data, discard the data; we don't want jumbled
+	      // captions
+	      return;
+	    }
+	    this.ccStreams_[(packet.type << 1) + this.activeCea608Channel_[packet.type]].push(packet);
+	  };
+	  CaptionStream.prototype.setsChannel1Active = function (packet) {
+	    return (packet.ccData & 0x7800) === 0x1000;
+	  };
+	  CaptionStream.prototype.setsChannel2Active = function (packet) {
+	    return (packet.ccData & 0x7800) === 0x1800;
+	  };
+	  CaptionStream.prototype.setsTextOrXDSActive = function (packet) {
+	    return (packet.ccData & 0x7100) === 0x0100 || (packet.ccData & 0x78fe) === 0x102a || (packet.ccData & 0x78fe) === 0x182a;
+	  };
+	  CaptionStream.prototype.dispatchCea708Packet = function (packet) {
+	    if (this.parse708captions_) {
+	      this.cc708Stream_.push(packet);
+	    }
+	  };
+
+	  // ----------------------
+	  // Session to Application
+	  // ----------------------
+
+	  // This hash maps special and extended character codes to their
+	  // proper Unicode equivalent. The first one-byte key is just a
+	  // non-standard character code. The two-byte keys that follow are
+	  // the extended CEA708 character codes, along with the preceding
+	  // 0x10 extended character byte to distinguish these codes from
+	  // non-extended character codes. Every CEA708 character code that
+	  // is not in this object maps directly to a standard unicode
+	  // character code.
+	  // The transparent space and non-breaking transparent space are
+	  // technically not fully supported since there is no code to
+	  // make them transparent, so they have normal non-transparent
+	  // stand-ins.
+	  // The special closed caption (CC) character isn't a standard
+	  // unicode character, so a fairly similar unicode character was
+	  // chosen in it's place.
+	  var CHARACTER_TRANSLATION_708 = {
+	    0x7f: 0x266a,
+	    // ♪
+	    0x1020: 0x20,
+	    // Transparent Space
+	    0x1021: 0xa0,
+	    // Nob-breaking Transparent Space
+	    0x1025: 0x2026,
+	    // …
+	    0x102a: 0x0160,
+	    // Š
+	    0x102c: 0x0152,
+	    // Œ
+	    0x1030: 0x2588,
+	    // █
+	    0x1031: 0x2018,
+	    // ‘
+	    0x1032: 0x2019,
+	    // ’
+	    0x1033: 0x201c,
+	    // “
+	    0x1034: 0x201d,
+	    // ”
+	    0x1035: 0x2022,
+	    // •
+	    0x1039: 0x2122,
+	    // ™
+	    0x103a: 0x0161,
+	    // š
+	    0x103c: 0x0153,
+	    // œ
+	    0x103d: 0x2120,
+	    // ℠
+	    0x103f: 0x0178,
+	    // Ÿ
+	    0x1076: 0x215b,
+	    // ⅛
+	    0x1077: 0x215c,
+	    // ⅜
+	    0x1078: 0x215d,
+	    // ⅝
+	    0x1079: 0x215e,
+	    // ⅞
+	    0x107a: 0x23d0,
+	    // ⏐
+	    0x107b: 0x23a4,
+	    // ⎤
+	    0x107c: 0x23a3,
+	    // ⎣
+	    0x107d: 0x23af,
+	    // ⎯
+	    0x107e: 0x23a6,
+	    // ⎦
+	    0x107f: 0x23a1,
+	    // ⎡
+	    0x10a0: 0x3138 // ㄸ (CC char)
+	  };
+
+	  var get708CharFromCode = function get708CharFromCode(code) {
+	    var newCode = CHARACTER_TRANSLATION_708[code] || code;
+	    if (code & 0x1000 && code === newCode) {
+	      // Invalid extended code
+	      return '';
+	    }
+	    return String.fromCharCode(newCode);
+	  };
+	  var within708TextBlock = function within708TextBlock(b) {
+	    return 0x20 <= b && b <= 0x7f || 0xa0 <= b && b <= 0xff;
+	  };
+	  var Cea708Window = function Cea708Window(windowNum) {
+	    this.windowNum = windowNum;
+	    this.reset();
+	  };
+	  Cea708Window.prototype.reset = function () {
+	    this.clearText();
+	    this.pendingNewLine = false;
+	    this.winAttr = {};
+	    this.penAttr = {};
+	    this.penLoc = {};
+	    this.penColor = {};
+
+	    // These default values are arbitrary,
+	    // defineWindow will usually override them
+	    this.visible = 0;
+	    this.rowLock = 0;
+	    this.columnLock = 0;
+	    this.priority = 0;
+	    this.relativePositioning = 0;
+	    this.anchorVertical = 0;
+	    this.anchorHorizontal = 0;
+	    this.anchorPoint = 0;
+	    this.rowCount = 1;
+	    this.virtualRowCount = this.rowCount + 1;
+	    this.columnCount = 41;
+	    this.windowStyle = 0;
+	    this.penStyle = 0;
+	  };
+	  Cea708Window.prototype.getText = function () {
+	    return this.rows.join('\n');
+	  };
+	  Cea708Window.prototype.clearText = function () {
+	    this.rows = [''];
+	    this.rowIdx = 0;
+	  };
+	  Cea708Window.prototype.newLine = function (pts) {
+	    if (this.rows.length >= this.virtualRowCount && typeof this.beforeRowOverflow === 'function') {
+	      this.beforeRowOverflow(pts);
+	    }
+	    if (this.rows.length > 0) {
+	      this.rows.push('');
+	      this.rowIdx++;
+	    }
+
+	    // Show all virtual rows since there's no visible scrolling
+	    while (this.rows.length > this.virtualRowCount) {
+	      this.rows.shift();
+	      this.rowIdx--;
+	    }
+	  };
+	  Cea708Window.prototype.isEmpty = function () {
+	    if (this.rows.length === 0) {
+	      return true;
+	    } else if (this.rows.length === 1) {
+	      return this.rows[0] === '';
+	    }
+	    return false;
+	  };
+	  Cea708Window.prototype.addText = function (text) {
+	    this.rows[this.rowIdx] += text;
+	  };
+	  Cea708Window.prototype.backspace = function () {
+	    if (!this.isEmpty()) {
+	      var row = this.rows[this.rowIdx];
+	      this.rows[this.rowIdx] = row.substr(0, row.length - 1);
+	    }
+	  };
+	  var Cea708Service = function Cea708Service(serviceNum, encoding, stream) {
+	    this.serviceNum = serviceNum;
+	    this.text = '';
+	    this.currentWindow = new Cea708Window(-1);
+	    this.windows = [];
+	    this.stream = stream;
+
+	    // Try to setup a TextDecoder if an `encoding` value was provided
+	    if (typeof encoding === 'string') {
+	      this.createTextDecoder(encoding);
+	    }
+	  };
+
+	  /**
+	   * Initialize service windows
+	   * Must be run before service use
+	   *
+	   * @param  {Integer}  pts               PTS value
+	   * @param  {Function} beforeRowOverflow Function to execute before row overflow of a window
+	   */
+	  Cea708Service.prototype.init = function (pts, beforeRowOverflow) {
+	    this.startPts = pts;
+	    for (var win = 0; win < 8; win++) {
+	      this.windows[win] = new Cea708Window(win);
+	      if (typeof beforeRowOverflow === 'function') {
+	        this.windows[win].beforeRowOverflow = beforeRowOverflow;
+	      }
+	    }
+	  };
+
+	  /**
+	   * Set current window of service to be affected by commands
+	   *
+	   * @param  {Integer} windowNum Window number
+	   */
+	  Cea708Service.prototype.setCurrentWindow = function (windowNum) {
+	    this.currentWindow = this.windows[windowNum];
+	  };
+
+	  /**
+	   * Try to create a TextDecoder if it is natively supported
+	   */
+	  Cea708Service.prototype.createTextDecoder = function (encoding) {
+	    if (typeof TextDecoder === 'undefined') {
+	      this.stream.trigger('log', {
+	        level: 'warn',
+	        message: 'The `encoding` option is unsupported without TextDecoder support'
+	      });
+	    } else {
+	      try {
+	        this.textDecoder_ = new TextDecoder(encoding);
+	      } catch (error) {
+	        this.stream.trigger('log', {
+	          level: 'warn',
+	          message: 'TextDecoder could not be created with ' + encoding + ' encoding. ' + error
+	        });
+	      }
+	    }
+	  };
+	  var Cea708Stream = function Cea708Stream(options) {
+	    options = options || {};
+	    Cea708Stream.prototype.init.call(this);
+	    var self = this;
+	    var captionServices = options.captionServices || {};
+	    var captionServiceEncodings = {};
+	    var serviceProps;
+
+	    // Get service encodings from captionServices option block
+	    Object.keys(captionServices).forEach(function (serviceName) {
+	      serviceProps = captionServices[serviceName];
+	      if (/^SERVICE/.test(serviceName)) {
+	        captionServiceEncodings[serviceName] = serviceProps.encoding;
+	      }
+	    });
+	    this.serviceEncodings = captionServiceEncodings;
+	    this.current708Packet = null;
+	    this.services = {};
+	    this.push = function (packet) {
+	      if (packet.type === 3) {
+	        // 708 packet start
+	        self.new708Packet();
+	        self.add708Bytes(packet);
+	      } else {
+	        if (self.current708Packet === null) {
+	          // This should only happen at the start of a file if there's no packet start.
+	          self.new708Packet();
+	        }
+	        self.add708Bytes(packet);
+	      }
+	    };
+	  };
+	  Cea708Stream.prototype = new stream();
+
+	  /**
+	   * Push current 708 packet, create new 708 packet.
+	   */
+	  Cea708Stream.prototype.new708Packet = function () {
+	    if (this.current708Packet !== null) {
+	      this.push708Packet();
+	    }
+	    this.current708Packet = {
+	      data: [],
+	      ptsVals: []
+	    };
+	  };
+
+	  /**
+	   * Add pts and both bytes from packet into current 708 packet.
+	   */
+	  Cea708Stream.prototype.add708Bytes = function (packet) {
+	    var data = packet.ccData;
+	    var byte0 = data >>> 8;
+	    var byte1 = data & 0xff;
+
+	    // I would just keep a list of packets instead of bytes, but it isn't clear in the spec
+	    // that service blocks will always line up with byte pairs.
+	    this.current708Packet.ptsVals.push(packet.pts);
+	    this.current708Packet.data.push(byte0);
+	    this.current708Packet.data.push(byte1);
+	  };
+
+	  /**
+	   * Parse completed 708 packet into service blocks and push each service block.
+	   */
+	  Cea708Stream.prototype.push708Packet = function () {
+	    var packet708 = this.current708Packet;
+	    var packetData = packet708.data;
+	    var serviceNum = null;
+	    var blockSize = null;
+	    var i = 0;
+	    var b = packetData[i++];
+	    packet708.seq = b >> 6;
+	    packet708.sizeCode = b & 0x3f; // 0b00111111;
+
+	    for (; i < packetData.length; i++) {
+	      b = packetData[i++];
+	      serviceNum = b >> 5;
+	      blockSize = b & 0x1f; // 0b00011111
+
+	      if (serviceNum === 7 && blockSize > 0) {
+	        // Extended service num
+	        b = packetData[i++];
+	        serviceNum = b;
+	      }
+	      this.pushServiceBlock(serviceNum, i, blockSize);
+	      if (blockSize > 0) {
+	        i += blockSize - 1;
+	      }
+	    }
+	  };
+
+	  /**
+	   * Parse service block, execute commands, read text.
+	   *
+	   * Note: While many of these commands serve important purposes,
+	   * many others just parse out the parameters or attributes, but
+	   * nothing is done with them because this is not a full and complete
+	   * implementation of the entire 708 spec.
+	   *
+	   * @param  {Integer} serviceNum Service number
+	   * @param  {Integer} start      Start index of the 708 packet data
+	   * @param  {Integer} size       Block size
+	   */
+	  Cea708Stream.prototype.pushServiceBlock = function (serviceNum, start, size) {
+	    var b;
+	    var i = start;
+	    var packetData = this.current708Packet.data;
+	    var service = this.services[serviceNum];
+	    if (!service) {
+	      service = this.initService(serviceNum, i);
+	    }
+	    for (; i < start + size && i < packetData.length; i++) {
+	      b = packetData[i];
+	      if (within708TextBlock(b)) {
+	        i = this.handleText(i, service);
+	      } else if (b === 0x18) {
+	        i = this.multiByteCharacter(i, service);
+	      } else if (b === 0x10) {
+	        i = this.extendedCommands(i, service);
+	      } else if (0x80 <= b && b <= 0x87) {
+	        i = this.setCurrentWindow(i, service);
+	      } else if (0x98 <= b && b <= 0x9f) {
+	        i = this.defineWindow(i, service);
+	      } else if (b === 0x88) {
+	        i = this.clearWindows(i, service);
+	      } else if (b === 0x8c) {
+	        i = this.deleteWindows(i, service);
+	      } else if (b === 0x89) {
+	        i = this.displayWindows(i, service);
+	      } else if (b === 0x8a) {
+	        i = this.hideWindows(i, service);
+	      } else if (b === 0x8b) {
+	        i = this.toggleWindows(i, service);
+	      } else if (b === 0x97) {
+	        i = this.setWindowAttributes(i, service);
+	      } else if (b === 0x90) {
+	        i = this.setPenAttributes(i, service);
+	      } else if (b === 0x91) {
+	        i = this.setPenColor(i, service);
+	      } else if (b === 0x92) {
+	        i = this.setPenLocation(i, service);
+	      } else if (b === 0x8f) {
+	        service = this.reset(i, service);
+	      } else if (b === 0x08) {
+	        // BS: Backspace
+	        service.currentWindow.backspace();
+	      } else if (b === 0x0c) {
+	        // FF: Form feed
+	        service.currentWindow.clearText();
+	      } else if (b === 0x0d) {
+	        // CR: Carriage return
+	        service.currentWindow.pendingNewLine = true;
+	      } else if (b === 0x0e) {
+	        // HCR: Horizontal carriage return
+	        service.currentWindow.clearText();
+	      } else if (b === 0x8d) {
+	        // DLY: Delay, nothing to do
+	        i++;
+	      } else ;
+	    }
+	  };
+
+	  /**
+	   * Execute an extended command
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.extendedCommands = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    if (within708TextBlock(b)) {
+	      i = this.handleText(i, service, {
+	        isExtended: true
+	      });
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Get PTS value of a given byte index
+	   *
+	   * @param  {Integer} byteIndex  Index of the byte
+	   * @return {Integer}            PTS
+	   */
+	  Cea708Stream.prototype.getPts = function (byteIndex) {
+	    // There's 1 pts value per 2 bytes
+	    return this.current708Packet.ptsVals[Math.floor(byteIndex / 2)];
+	  };
+
+	  /**
+	   * Initializes a service
+	   *
+	   * @param  {Integer} serviceNum Service number
+	   * @return {Service}            Initialized service object
+	   */
+	  Cea708Stream.prototype.initService = function (serviceNum, i) {
+	    var serviceName = 'SERVICE' + serviceNum;
+	    var self = this;
+	    var serviceName;
+	    var encoding;
+	    if (serviceName in this.serviceEncodings) {
+	      encoding = this.serviceEncodings[serviceName];
+	    }
+	    this.services[serviceNum] = new Cea708Service(serviceNum, encoding, self);
+	    this.services[serviceNum].init(this.getPts(i), function (pts) {
+	      self.flushDisplayed(pts, self.services[serviceNum]);
+	    });
+	    return this.services[serviceNum];
+	  };
+
+	  /**
+	   * Execute text writing to current window
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.handleText = function (i, service, options) {
+	    var isExtended = options && options.isExtended;
+	    var isMultiByte = options && options.isMultiByte;
+	    var packetData = this.current708Packet.data;
+	    var extended = isExtended ? 0x1000 : 0x0000;
+	    var currentByte = packetData[i];
+	    var nextByte = packetData[i + 1];
+	    var win = service.currentWindow;
+	    var char;
+	    var charCodeArray;
+
+	    // Use the TextDecoder if one was created for this service
+	    if (service.textDecoder_ && !isExtended) {
+	      if (isMultiByte) {
+	        charCodeArray = [currentByte, nextByte];
+	        i++;
+	      } else {
+	        charCodeArray = [currentByte];
+	      }
+	      char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
+	    } else {
+	      char = get708CharFromCode(extended | currentByte);
+	    }
+	    if (win.pendingNewLine && !win.isEmpty()) {
+	      win.newLine(this.getPts(i));
+	    }
+	    win.pendingNewLine = false;
+	    win.addText(char);
+	    return i;
+	  };
+
+	  /**
+	   * Handle decoding of multibyte character
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.multiByteCharacter = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var firstByte = packetData[i + 1];
+	    var secondByte = packetData[i + 2];
+	    if (within708TextBlock(firstByte) && within708TextBlock(secondByte)) {
+	      i = this.handleText(++i, service, {
+	        isMultiByte: true
+	      });
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the CW# command.
+	   *
+	   * Set the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setCurrentWindow = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var windowNum = b & 0x07;
+	    service.setCurrentWindow(windowNum);
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the DF# command.
+	   *
+	   * Define a window and set it as the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.defineWindow = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var windowNum = b & 0x07;
+	    service.setCurrentWindow(windowNum);
+	    var win = service.currentWindow;
+	    b = packetData[++i];
+	    win.visible = (b & 0x20) >> 5; // v
+	    win.rowLock = (b & 0x10) >> 4; // rl
+	    win.columnLock = (b & 0x08) >> 3; // cl
+	    win.priority = b & 0x07; // p
+
+	    b = packetData[++i];
+	    win.relativePositioning = (b & 0x80) >> 7; // rp
+	    win.anchorVertical = b & 0x7f; // av
+
+	    b = packetData[++i];
+	    win.anchorHorizontal = b; // ah
+
+	    b = packetData[++i];
+	    win.anchorPoint = (b & 0xf0) >> 4; // ap
+	    win.rowCount = b & 0x0f; // rc
+
+	    b = packetData[++i];
+	    win.columnCount = b & 0x3f; // cc
+
+	    b = packetData[++i];
+	    win.windowStyle = (b & 0x38) >> 3; // ws
+	    win.penStyle = b & 0x07; // ps
+
+	    // The spec says there are (rowCount+1) "virtual rows"
+	    win.virtualRowCount = win.rowCount + 1;
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SWA command.
+	   *
+	   * Set attributes of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setWindowAttributes = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var winAttr = service.currentWindow.winAttr;
+	    b = packetData[++i];
+	    winAttr.fillOpacity = (b & 0xc0) >> 6; // fo
+	    winAttr.fillRed = (b & 0x30) >> 4; // fr
+	    winAttr.fillGreen = (b & 0x0c) >> 2; // fg
+	    winAttr.fillBlue = b & 0x03; // fb
+
+	    b = packetData[++i];
+	    winAttr.borderType = (b & 0xc0) >> 6; // bt
+	    winAttr.borderRed = (b & 0x30) >> 4; // br
+	    winAttr.borderGreen = (b & 0x0c) >> 2; // bg
+	    winAttr.borderBlue = b & 0x03; // bb
+
+	    b = packetData[++i];
+	    winAttr.borderType += (b & 0x80) >> 5; // bt
+	    winAttr.wordWrap = (b & 0x40) >> 6; // ww
+	    winAttr.printDirection = (b & 0x30) >> 4; // pd
+	    winAttr.scrollDirection = (b & 0x0c) >> 2; // sd
+	    winAttr.justify = b & 0x03; // j
+
+	    b = packetData[++i];
+	    winAttr.effectSpeed = (b & 0xf0) >> 4; // es
+	    winAttr.effectDirection = (b & 0x0c) >> 2; // ed
+	    winAttr.displayEffect = b & 0x03; // de
+
+	    return i;
+	  };
+
+	  /**
+	   * Gather text from all displayed windows and push a caption to output.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   */
+	  Cea708Stream.prototype.flushDisplayed = function (pts, service) {
+	    var displayedText = [];
+
+	    // TODO: Positioning not supported, displaying multiple windows will not necessarily
+	    // display text in the correct order, but sample files so far have not shown any issue.
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (service.windows[winId].visible && !service.windows[winId].isEmpty()) {
+	        displayedText.push(service.windows[winId].getText());
+	      }
+	    }
+	    service.endPts = pts;
+	    service.text = displayedText.join('\n\n');
+	    this.pushCaption(service);
+	    service.startPts = pts;
+	  };
+
+	  /**
+	   * Push a caption to output if the caption contains text.
+	   *
+	   * @param  {Service} service  The service object to be affected
+	   */
+	  Cea708Stream.prototype.pushCaption = function (service) {
+	    if (service.text !== '') {
+	      this.trigger('data', {
+	        startPts: service.startPts,
+	        endPts: service.endPts,
+	        text: service.text,
+	        stream: 'cc708_' + service.serviceNum
+	      });
+	      service.text = '';
+	      service.startPts = service.endPts;
+	    }
+	  };
+
+	  /**
+	   * Parse and execute the DSW command.
+	   *
+	   * Set visible property of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.displayWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].visible = 1;
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the HDW command.
+	   *
+	   * Set visible property of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.hideWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].visible = 0;
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the TGW command.
+	   *
+	   * Set visible property of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.toggleWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].visible ^= 1;
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the CLW command.
+	   *
+	   * Clear text of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.clearWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].clearText();
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the DLW command.
+	   *
+	   * Re-initialize windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.deleteWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].reset();
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SPA command.
+	   *
+	   * Set pen attributes of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setPenAttributes = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var penAttr = service.currentWindow.penAttr;
+	    b = packetData[++i];
+	    penAttr.textTag = (b & 0xf0) >> 4; // tt
+	    penAttr.offset = (b & 0x0c) >> 2; // o
+	    penAttr.penSize = b & 0x03; // s
+
+	    b = packetData[++i];
+	    penAttr.italics = (b & 0x80) >> 7; // i
+	    penAttr.underline = (b & 0x40) >> 6; // u
+	    penAttr.edgeType = (b & 0x38) >> 3; // et
+	    penAttr.fontStyle = b & 0x07; // fs
+
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SPC command.
+	   *
+	   * Set pen color of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setPenColor = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var penColor = service.currentWindow.penColor;
+	    b = packetData[++i];
+	    penColor.fgOpacity = (b & 0xc0) >> 6; // fo
+	    penColor.fgRed = (b & 0x30) >> 4; // fr
+	    penColor.fgGreen = (b & 0x0c) >> 2; // fg
+	    penColor.fgBlue = b & 0x03; // fb
+
+	    b = packetData[++i];
+	    penColor.bgOpacity = (b & 0xc0) >> 6; // bo
+	    penColor.bgRed = (b & 0x30) >> 4; // br
+	    penColor.bgGreen = (b & 0x0c) >> 2; // bg
+	    penColor.bgBlue = b & 0x03; // bb
+
+	    b = packetData[++i];
+	    penColor.edgeRed = (b & 0x30) >> 4; // er
+	    penColor.edgeGreen = (b & 0x0c) >> 2; // eg
+	    penColor.edgeBlue = b & 0x03; // eb
+
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SPL command.
+	   *
+	   * Set pen location of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setPenLocation = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var penLoc = service.currentWindow.penLoc;
+
+	    // Positioning isn't really supported at the moment, so this essentially just inserts a linebreak
+	    service.currentWindow.pendingNewLine = true;
+	    b = packetData[++i];
+	    penLoc.row = b & 0x0f; // r
+
+	    b = packetData[++i];
+	    penLoc.column = b & 0x3f; // c
+
+	    return i;
+	  };
+
+	  /**
+	   * Execute the RST command.
+	   *
+	   * Reset service to a clean slate. Re-initialize.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Service}          Re-initialized service
+	   */
+	  Cea708Stream.prototype.reset = function (i, service) {
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    return this.initService(service.serviceNum, i);
+	  };
+
+	  // This hash maps non-ASCII, special, and extended character codes to their
+	  // proper Unicode equivalent. The first keys that are only a single byte
+	  // are the non-standard ASCII characters, which simply map the CEA608 byte
+	  // to the standard ASCII/Unicode. The two-byte keys that follow are the CEA608
+	  // character codes, but have their MSB bitmasked with 0x03 so that a lookup
+	  // can be performed regardless of the field and data channel on which the
+	  // character code was received.
+	  var CHARACTER_TRANSLATION = {
+	    0x2a: 0xe1,
+	    // á
+	    0x5c: 0xe9,
+	    // é
+	    0x5e: 0xed,
+	    // í
+	    0x5f: 0xf3,
+	    // ó
+	    0x60: 0xfa,
+	    // ú
+	    0x7b: 0xe7,
+	    // ç
+	    0x7c: 0xf7,
+	    // ÷
+	    0x7d: 0xd1,
+	    // Ñ
+	    0x7e: 0xf1,
+	    // ñ
+	    0x7f: 0x2588,
+	    // █
+	    0x0130: 0xae,
+	    // ®
+	    0x0131: 0xb0,
+	    // °
+	    0x0132: 0xbd,
+	    // ½
+	    0x0133: 0xbf,
+	    // ¿
+	    0x0134: 0x2122,
+	    // ™
+	    0x0135: 0xa2,
+	    // ¢
+	    0x0136: 0xa3,
+	    // £
+	    0x0137: 0x266a,
+	    // ♪
+	    0x0138: 0xe0,
+	    // à
+	    0x0139: 0xa0,
+	    //
+	    0x013a: 0xe8,
+	    // è
+	    0x013b: 0xe2,
+	    // â
+	    0x013c: 0xea,
+	    // ê
+	    0x013d: 0xee,
+	    // î
+	    0x013e: 0xf4,
+	    // ô
+	    0x013f: 0xfb,
+	    // û
+	    0x0220: 0xc1,
+	    // Á
+	    0x0221: 0xc9,
+	    // É
+	    0x0222: 0xd3,
+	    // Ó
+	    0x0223: 0xda,
+	    // Ú
+	    0x0224: 0xdc,
+	    // Ü
+	    0x0225: 0xfc,
+	    // ü
+	    0x0226: 0x2018,
+	    // ‘
+	    0x0227: 0xa1,
+	    // ¡
+	    0x0228: 0x2a,
+	    // *
+	    0x0229: 0x27,
+	    // '
+	    0x022a: 0x2014,
+	    // —
+	    0x022b: 0xa9,
+	    // ©
+	    0x022c: 0x2120,
+	    // ℠
+	    0x022d: 0x2022,
+	    // •
+	    0x022e: 0x201c,
+	    // “
+	    0x022f: 0x201d,
+	    // ”
+	    0x0230: 0xc0,
+	    // À
+	    0x0231: 0xc2,
+	    // Â
+	    0x0232: 0xc7,
+	    // Ç
+	    0x0233: 0xc8,
+	    // È
+	    0x0234: 0xca,
+	    // Ê
+	    0x0235: 0xcb,
+	    // Ë
+	    0x0236: 0xeb,
+	    // ë
+	    0x0237: 0xce,
+	    // Î
+	    0x0238: 0xcf,
+	    // Ï
+	    0x0239: 0xef,
+	    // ï
+	    0x023a: 0xd4,
+	    // Ô
+	    0x023b: 0xd9,
+	    // Ù
+	    0x023c: 0xf9,
+	    // ù
+	    0x023d: 0xdb,
+	    // Û
+	    0x023e: 0xab,
+	    // «
+	    0x023f: 0xbb,
+	    // »
+	    0x0320: 0xc3,
+	    // Ã
+	    0x0321: 0xe3,
+	    // ã
+	    0x0322: 0xcd,
+	    // Í
+	    0x0323: 0xcc,
+	    // Ì
+	    0x0324: 0xec,
+	    // ì
+	    0x0325: 0xd2,
+	    // Ò
+	    0x0326: 0xf2,
+	    // ò
+	    0x0327: 0xd5,
+	    // Õ
+	    0x0328: 0xf5,
+	    // õ
+	    0x0329: 0x7b,
+	    // {
+	    0x032a: 0x7d,
+	    // }
+	    0x032b: 0x5c,
+	    // \
+	    0x032c: 0x5e,
+	    // ^
+	    0x032d: 0x5f,
+	    // _
+	    0x032e: 0x7c,
+	    // |
+	    0x032f: 0x7e,
+	    // ~
+	    0x0330: 0xc4,
+	    // Ä
+	    0x0331: 0xe4,
+	    // ä
+	    0x0332: 0xd6,
+	    // Ö
+	    0x0333: 0xf6,
+	    // ö
+	    0x0334: 0xdf,
+	    // ß
+	    0x0335: 0xa5,
+	    // ¥
+	    0x0336: 0xa4,
+	    // ¤
+	    0x0337: 0x2502,
+	    // │
+	    0x0338: 0xc5,
+	    // Å
+	    0x0339: 0xe5,
+	    // å
+	    0x033a: 0xd8,
+	    // Ø
+	    0x033b: 0xf8,
+	    // ø
+	    0x033c: 0x250c,
+	    // ┌
+	    0x033d: 0x2510,
+	    // ┐
+	    0x033e: 0x2514,
+	    // └
+	    0x033f: 0x2518 // ┘
+	  };
+
+	  var getCharFromCode = function getCharFromCode(code) {
+	    if (code === null) {
+	      return '';
+	    }
+	    code = CHARACTER_TRANSLATION[code] || code;
+	    return String.fromCharCode(code);
+	  };
+
+	  // the index of the last row in a CEA-608 display buffer
+	  var BOTTOM_ROW = 14;
+
+	  // This array is used for mapping PACs -> row #, since there's no way of
+	  // getting it through bit logic.
+	  var ROWS = [0x1100, 0x1120, 0x1200, 0x1220, 0x1500, 0x1520, 0x1600, 0x1620, 0x1700, 0x1720, 0x1000, 0x1300, 0x1320, 0x1400, 0x1420];
+
+	  // CEA-608 captions are rendered onto a 34x15 matrix of character
+	  // cells. The "bottom" row is the last element in the outer array.
+	  var createDisplayBuffer = function createDisplayBuffer() {
+	    var result = [],
+	      i = BOTTOM_ROW + 1;
+	    while (i--) {
+	      result.push('');
+	    }
+	    return result;
+	  };
+	  var Cea608Stream = function Cea608Stream(field, dataChannel) {
+	    Cea608Stream.prototype.init.call(this);
+	    this.field_ = field || 0;
+	    this.dataChannel_ = dataChannel || 0;
+	    this.name_ = 'CC' + ((this.field_ << 1 | this.dataChannel_) + 1);
+	    this.setConstants();
+	    this.reset();
+	    this.push = function (packet) {
+	      var data, swap, char0, char1, text;
+	      // remove the parity bits
+	      data = packet.ccData & 0x7f7f;
+
+	      // ignore duplicate control codes; the spec demands they're sent twice
+	      if (data === this.lastControlCode_) {
+	        this.lastControlCode_ = null;
+	        return;
+	      }
+
+	      // Store control codes
+	      if ((data & 0xf000) === 0x1000) {
+	        this.lastControlCode_ = data;
+	      } else if (data !== this.PADDING_) {
+	        this.lastControlCode_ = null;
+	      }
+	      char0 = data >>> 8;
+	      char1 = data & 0xff;
+	      if (data === this.PADDING_) {
+	        return;
+	      } else if (data === this.RESUME_CAPTION_LOADING_) {
+	        this.mode_ = 'popOn';
+	      } else if (data === this.END_OF_CAPTION_) {
+	        // If an EOC is received while in paint-on mode, the displayed caption
+	        // text should be swapped to non-displayed memory as if it was a pop-on
+	        // caption. Because of that, we should explicitly switch back to pop-on
+	        // mode
+	        this.mode_ = 'popOn';
+	        this.clearFormatting(packet.pts);
+	        // if a caption was being displayed, it's gone now
+	        this.flushDisplayed(packet.pts);
+
+	        // flip memory
+	        swap = this.displayed_;
+	        this.displayed_ = this.nonDisplayed_;
+	        this.nonDisplayed_ = swap;
+
+	        // start measuring the time to display the caption
+	        this.startPts_ = packet.pts;
+	      } else if (data === this.ROLL_UP_2_ROWS_) {
+	        this.rollUpRows_ = 2;
+	        this.setRollUp(packet.pts);
+	      } else if (data === this.ROLL_UP_3_ROWS_) {
+	        this.rollUpRows_ = 3;
+	        this.setRollUp(packet.pts);
+	      } else if (data === this.ROLL_UP_4_ROWS_) {
+	        this.rollUpRows_ = 4;
+	        this.setRollUp(packet.pts);
+	      } else if (data === this.CARRIAGE_RETURN_) {
+	        this.clearFormatting(packet.pts);
+	        this.flushDisplayed(packet.pts);
+	        this.shiftRowsUp_();
+	        this.startPts_ = packet.pts;
+	      } else if (data === this.BACKSPACE_) {
+	        if (this.mode_ === 'popOn') {
+	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+	        } else {
+	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+	        }
+	      } else if (data === this.ERASE_DISPLAYED_MEMORY_) {
+	        this.flushDisplayed(packet.pts);
+	        this.displayed_ = createDisplayBuffer();
+	      } else if (data === this.ERASE_NON_DISPLAYED_MEMORY_) {
+	        this.nonDisplayed_ = createDisplayBuffer();
+	      } else if (data === this.RESUME_DIRECT_CAPTIONING_) {
+	        if (this.mode_ !== 'paintOn') {
+	          // NOTE: This should be removed when proper caption positioning is
+	          // implemented
+	          this.flushDisplayed(packet.pts);
+	          this.displayed_ = createDisplayBuffer();
+	        }
+	        this.mode_ = 'paintOn';
+	        this.startPts_ = packet.pts;
+
+	        // Append special characters to caption text
+	      } else if (this.isSpecialCharacter(char0, char1)) {
+	        // Bitmask char0 so that we can apply character transformations
+	        // regardless of field and data channel.
+	        // Then byte-shift to the left and OR with char1 so we can pass the
+	        // entire character code to `getCharFromCode`.
+	        char0 = (char0 & 0x03) << 8;
+	        text = getCharFromCode(char0 | char1);
+	        this[this.mode_](packet.pts, text);
+	        this.column_++;
+
+	        // Append extended characters to caption text
+	      } else if (this.isExtCharacter(char0, char1)) {
+	        // Extended characters always follow their "non-extended" equivalents.
+	        // IE if a "è" is desired, you'll always receive "eè"; non-compliant
+	        // decoders are supposed to drop the "è", while compliant decoders
+	        // backspace the "e" and insert "è".
+
+	        // Delete the previous character
+	        if (this.mode_ === 'popOn') {
+	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+	        } else {
+	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+	        }
+
+	        // Bitmask char0 so that we can apply character transformations
+	        // regardless of field and data channel.
+	        // Then byte-shift to the left and OR with char1 so we can pass the
+	        // entire character code to `getCharFromCode`.
+	        char0 = (char0 & 0x03) << 8;
+	        text = getCharFromCode(char0 | char1);
+	        this[this.mode_](packet.pts, text);
+	        this.column_++;
+
+	        // Process mid-row codes
+	      } else if (this.isMidRowCode(char0, char1)) {
+	        // Attributes are not additive, so clear all formatting
+	        this.clearFormatting(packet.pts);
+
+	        // According to the standard, mid-row codes
+	        // should be replaced with spaces, so add one now
+	        this[this.mode_](packet.pts, ' ');
+	        this.column_++;
+	        if ((char1 & 0xe) === 0xe) {
+	          this.addFormatting(packet.pts, ['i']);
+	        }
+	        if ((char1 & 0x1) === 0x1) {
+	          this.addFormatting(packet.pts, ['u']);
+	        }
+
+	        // Detect offset control codes and adjust cursor
+	      } else if (this.isOffsetControlCode(char0, char1)) {
+	        // Cursor position is set by indent PAC (see below) in 4-column
+	        // increments, with an additional offset code of 1-3 to reach any
+	        // of the 32 columns specified by CEA-608. So all we need to do
+	        // here is increment the column cursor by the given offset.
+	        this.column_ += char1 & 0x03;
+
+	        // Detect PACs (Preamble Address Codes)
+	      } else if (this.isPAC(char0, char1)) {
+	        // There's no logic for PAC -> row mapping, so we have to just
+	        // find the row code in an array and use its index :(
+	        var row = ROWS.indexOf(data & 0x1f20);
+
+	        // Configure the caption window if we're in roll-up mode
+	        if (this.mode_ === 'rollUp') {
+	          // This implies that the base row is incorrectly set.
+	          // As per the recommendation in CEA-608(Base Row Implementation), defer to the number
+	          // of roll-up rows set.
+	          if (row - this.rollUpRows_ + 1 < 0) {
+	            row = this.rollUpRows_ - 1;
+	          }
+	          this.setRollUp(packet.pts, row);
+	        }
+	        if (row !== this.row_) {
+	          // formatting is only persistent for current row
+	          this.clearFormatting(packet.pts);
+	          this.row_ = row;
+	        }
+	        // All PACs can apply underline, so detect and apply
+	        // (All odd-numbered second bytes set underline)
+	        if (char1 & 0x1 && this.formatting_.indexOf('u') === -1) {
+	          this.addFormatting(packet.pts, ['u']);
+	        }
+	        if ((data & 0x10) === 0x10) {
+	          // We've got an indent level code. Each successive even number
+	          // increments the column cursor by 4, so we can get the desired
+	          // column position by bit-shifting to the right (to get n/2)
+	          // and multiplying by 4.
+	          this.column_ = ((data & 0xe) >> 1) * 4;
+	        }
+	        if (this.isColorPAC(char1)) {
+	          // it's a color code, though we only support white, which
+	          // can be either normal or italicized. white italics can be
+	          // either 0x4e or 0x6e depending on the row, so we just
+	          // bitwise-and with 0xe to see if italics should be turned on
+	          if ((char1 & 0xe) === 0xe) {
+	            this.addFormatting(packet.pts, ['i']);
+	          }
+	        }
+
+	        // We have a normal character in char0, and possibly one in char1
+	      } else if (this.isNormalChar(char0)) {
+	        if (char1 === 0x00) {
+	          char1 = null;
+	        }
+	        text = getCharFromCode(char0);
+	        text += getCharFromCode(char1);
+	        this[this.mode_](packet.pts, text);
+	        this.column_ += text.length;
+	      } // finish data processing
+	    };
+	  };
+
+	  Cea608Stream.prototype = new stream();
+	  // Trigger a cue point that captures the current state of the
+	  // display buffer
+	  Cea608Stream.prototype.flushDisplayed = function (pts) {
+	    var content = this.displayed_
+	    // remove spaces from the start and end of the string
+	    .map(function (row, index) {
+	      try {
+	        return row.trim();
+	      } catch (e) {
+	        // Ordinarily, this shouldn't happen. However, caption
+	        // parsing errors should not throw exceptions and
+	        // break playback.
+	        this.trigger('log', {
+	          level: 'warn',
+	          message: 'Skipping a malformed 608 caption at index ' + index + '.'
+	        });
+	        return '';
+	      }
+	    }, this)
+	    // combine all text rows to display in one cue
+	    .join('\n')
+	    // and remove blank rows from the start and end, but not the middle
+	    .replace(/^\n+|\n+$/g, '');
+	    if (content.length) {
+	      this.trigger('data', {
+	        startPts: this.startPts_,
+	        endPts: pts,
+	        text: content,
+	        stream: this.name_
+	      });
+	    }
+	  };
+
+	  /**
+	   * Zero out the data, used for startup and on seek
+	   */
+	  Cea608Stream.prototype.reset = function () {
+	    this.mode_ = 'popOn';
+	    // When in roll-up mode, the index of the last row that will
+	    // actually display captions. If a caption is shifted to a row
+	    // with a lower index than this, it is cleared from the display
+	    // buffer
+	    this.topRow_ = 0;
+	    this.startPts_ = 0;
+	    this.displayed_ = createDisplayBuffer();
+	    this.nonDisplayed_ = createDisplayBuffer();
+	    this.lastControlCode_ = null;
+
+	    // Track row and column for proper line-breaking and spacing
+	    this.column_ = 0;
+	    this.row_ = BOTTOM_ROW;
+	    this.rollUpRows_ = 2;
+
+	    // This variable holds currently-applied formatting
+	    this.formatting_ = [];
+	  };
+
+	  /**
+	   * Sets up control code and related constants for this instance
+	   */
+	  Cea608Stream.prototype.setConstants = function () {
+	    // The following attributes have these uses:
+	    // ext_ :    char0 for mid-row codes, and the base for extended
+	    //           chars (ext_+0, ext_+1, and ext_+2 are char0s for
+	    //           extended codes)
+	    // control_: char0 for control codes, except byte-shifted to the
+	    //           left so that we can do this.control_ | CONTROL_CODE
+	    // offset_:  char0 for tab offset codes
+	    //
+	    // It's also worth noting that control codes, and _only_ control codes,
+	    // differ between field 1 and field2. Field 2 control codes are always
+	    // their field 1 value plus 1. That's why there's the "| field" on the
+	    // control value.
+	    if (this.dataChannel_ === 0) {
+	      this.BASE_ = 0x10;
+	      this.EXT_ = 0x11;
+	      this.CONTROL_ = (0x14 | this.field_) << 8;
+	      this.OFFSET_ = 0x17;
+	    } else if (this.dataChannel_ === 1) {
+	      this.BASE_ = 0x18;
+	      this.EXT_ = 0x19;
+	      this.CONTROL_ = (0x1c | this.field_) << 8;
+	      this.OFFSET_ = 0x1f;
+	    }
+
+	    // Constants for the LSByte command codes recognized by Cea608Stream. This
+	    // list is not exhaustive. For a more comprehensive listing and semantics see
+	    // http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf
+	    // Padding
+	    this.PADDING_ = 0x0000;
+	    // Pop-on Mode
+	    this.RESUME_CAPTION_LOADING_ = this.CONTROL_ | 0x20;
+	    this.END_OF_CAPTION_ = this.CONTROL_ | 0x2f;
+	    // Roll-up Mode
+	    this.ROLL_UP_2_ROWS_ = this.CONTROL_ | 0x25;
+	    this.ROLL_UP_3_ROWS_ = this.CONTROL_ | 0x26;
+	    this.ROLL_UP_4_ROWS_ = this.CONTROL_ | 0x27;
+	    this.CARRIAGE_RETURN_ = this.CONTROL_ | 0x2d;
+	    // paint-on mode
+	    this.RESUME_DIRECT_CAPTIONING_ = this.CONTROL_ | 0x29;
+	    // Erasure
+	    this.BACKSPACE_ = this.CONTROL_ | 0x21;
+	    this.ERASE_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2c;
+	    this.ERASE_NON_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2e;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet data is a special character
+	   *
+	   * Special characters have a second byte in the range 0x30 to 0x3f,
+	   * with the first byte being 0x11 (for data channel 1) or 0x19 (for
+	   * data channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are an special character
+	   */
+	  Cea608Stream.prototype.isSpecialCharacter = function (char0, char1) {
+	    return char0 === this.EXT_ && char1 >= 0x30 && char1 <= 0x3f;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet data is an extended character
+	   *
+	   * Extended characters have a second byte in the range 0x20 to 0x3f,
+	   * with the first byte being 0x12 or 0x13 (for data channel 1) or
+	   * 0x1a or 0x1b (for data channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are an extended character
+	   */
+	  Cea608Stream.prototype.isExtCharacter = function (char0, char1) {
+	    return (char0 === this.EXT_ + 1 || char0 === this.EXT_ + 2) && char1 >= 0x20 && char1 <= 0x3f;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet is a mid-row code
+	   *
+	   * Mid-row codes have a second byte in the range 0x20 to 0x2f, with
+	   * the first byte being 0x11 (for data channel 1) or 0x19 (for data
+	   * channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are a mid-row code
+	   */
+	  Cea608Stream.prototype.isMidRowCode = function (char0, char1) {
+	    return char0 === this.EXT_ && char1 >= 0x20 && char1 <= 0x2f;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet is an offset control code
+	   *
+	   * Offset control codes have a second byte in the range 0x21 to 0x23,
+	   * with the first byte being 0x17 (for data channel 1) or 0x1f (for
+	   * data channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are an offset control code
+	   */
+	  Cea608Stream.prototype.isOffsetControlCode = function (char0, char1) {
+	    return char0 === this.OFFSET_ && char1 >= 0x21 && char1 <= 0x23;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet is a Preamble Address Code
+	   *
+	   * PACs have a first byte in the range 0x10 to 0x17 (for data channel 1)
+	   * or 0x18 to 0x1f (for data channel 2), with the second byte in the
+	   * range 0x40 to 0x7f.
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are a PAC
+	   */
+	  Cea608Stream.prototype.isPAC = function (char0, char1) {
+	    return char0 >= this.BASE_ && char0 < this.BASE_ + 8 && char1 >= 0x40 && char1 <= 0x7f;
+	  };
+
+	  /**
+	   * Detects if a packet's second byte is in the range of a PAC color code
+	   *
+	   * PAC color codes have the second byte be in the range 0x40 to 0x4f, or
+	   * 0x60 to 0x6f.
+	   *
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the byte is a color PAC
+	   */
+	  Cea608Stream.prototype.isColorPAC = function (char1) {
+	    return char1 >= 0x40 && char1 <= 0x4f || char1 >= 0x60 && char1 <= 0x7f;
+	  };
+
+	  /**
+	   * Detects if a single byte is in the range of a normal character
+	   *
+	   * Normal text bytes are in the range 0x20 to 0x7f.
+	   *
+	   * @param  {Integer} char  The byte
+	   * @return {Boolean}       Whether the byte is a normal character
+	   */
+	  Cea608Stream.prototype.isNormalChar = function (char) {
+	    return char >= 0x20 && char <= 0x7f;
+	  };
+
+	  /**
+	   * Configures roll-up
+	   *
+	   * @param  {Integer} pts         Current PTS
+	   * @param  {Integer} newBaseRow  Used by PACs to slide the current window to
+	   *                               a new position
+	   */
+	  Cea608Stream.prototype.setRollUp = function (pts, newBaseRow) {
+	    // Reset the base row to the bottom row when switching modes
+	    if (this.mode_ !== 'rollUp') {
+	      this.row_ = BOTTOM_ROW;
+	      this.mode_ = 'rollUp';
+	      // Spec says to wipe memories when switching to roll-up
+	      this.flushDisplayed(pts);
+	      this.nonDisplayed_ = createDisplayBuffer();
+	      this.displayed_ = createDisplayBuffer();
+	    }
+	    if (newBaseRow !== undefined && newBaseRow !== this.row_) {
+	      // move currently displayed captions (up or down) to the new base row
+	      for (var i = 0; i < this.rollUpRows_; i++) {
+	        this.displayed_[newBaseRow - i] = this.displayed_[this.row_ - i];
+	        this.displayed_[this.row_ - i] = '';
+	      }
+	    }
+	    if (newBaseRow === undefined) {
+	      newBaseRow = this.row_;
+	    }
+	    this.topRow_ = newBaseRow - this.rollUpRows_ + 1;
+	  };
+
+	  // Adds the opening HTML tag for the passed character to the caption text,
+	  // and keeps track of it for later closing
+	  Cea608Stream.prototype.addFormatting = function (pts, format) {
+	    this.formatting_ = this.formatting_.concat(format);
+	    var text = format.reduce(function (text, format) {
+	      return text + '<' + format + '>';
+	    }, '');
+	    this[this.mode_](pts, text);
+	  };
+
+	  // Adds HTML closing tags for current formatting to caption text and
+	  // clears remembered formatting
+	  Cea608Stream.prototype.clearFormatting = function (pts) {
+	    if (!this.formatting_.length) {
+	      return;
+	    }
+	    var text = this.formatting_.reverse().reduce(function (text, format) {
+	      return text + '</' + format + '>';
+	    }, '');
+	    this.formatting_ = [];
+	    this[this.mode_](pts, text);
+	  };
+
+	  // Mode Implementations
+	  Cea608Stream.prototype.popOn = function (pts, text) {
+	    var baseRow = this.nonDisplayed_[this.row_];
+
+	    // buffer characters
+	    baseRow += text;
+	    this.nonDisplayed_[this.row_] = baseRow;
+	  };
+	  Cea608Stream.prototype.rollUp = function (pts, text) {
+	    var baseRow = this.displayed_[this.row_];
+	    baseRow += text;
+	    this.displayed_[this.row_] = baseRow;
+	  };
+	  Cea608Stream.prototype.shiftRowsUp_ = function () {
+	    var i;
+	    // clear out inactive rows
+	    for (i = 0; i < this.topRow_; i++) {
+	      this.displayed_[i] = '';
+	    }
+	    for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {
+	      this.displayed_[i] = '';
+	    }
+	    // shift displayed rows up
+	    for (i = this.topRow_; i < this.row_; i++) {
+	      this.displayed_[i] = this.displayed_[i + 1];
+	    }
+	    // clear out the bottom row
+	    this.displayed_[this.row_] = '';
+	  };
+	  Cea608Stream.prototype.paintOn = function (pts, text) {
+	    var baseRow = this.displayed_[this.row_];
+	    baseRow += text;
+	    this.displayed_[this.row_] = baseRow;
+	  };
+
+	  // exports
+	  var captionStream = {
+	    CaptionStream: CaptionStream,
+	    Cea608Stream: Cea608Stream,
+	    Cea708Stream: Cea708Stream
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+
+	  var streamTypes = {
+	    H264_STREAM_TYPE: 0x1B,
+	    ADTS_STREAM_TYPE: 0x0F,
+	    METADATA_STREAM_TYPE: 0x15
+	  };
+
+	  var MAX_TS = 8589934592;
+	  var RO_THRESH = 4294967296;
+	  var TYPE_SHARED = 'shared';
+	  var handleRollover = function handleRollover(value, reference) {
+	    var direction = 1;
+	    if (value > reference) {
+	      // If the current timestamp value is greater than our reference timestamp and we detect a
+	      // timestamp rollover, this means the roll over is happening in the opposite direction.
+	      // Example scenario: Enter a long stream/video just after a rollover occurred. The reference
+	      // point will be set to a small number, e.g. 1. The user then seeks backwards over the
+	      // rollover point. In loading this segment, the timestamp values will be very large,
+	      // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust
+	      // the time stamp to be `value - 2^33`.
+	      direction = -1;
+	    }
+
+	    // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will
+	    // cause an incorrect adjustment.
+	    while (Math.abs(reference - value) > RO_THRESH) {
+	      value += direction * MAX_TS;
+	    }
+	    return value;
+	  };
+	  var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {
+	    var lastDTS, referenceDTS;
+	    TimestampRolloverStream.prototype.init.call(this);
+
+	    // The "shared" type is used in cases where a stream will contain muxed
+	    // video and audio. We could use `undefined` here, but having a string
+	    // makes debugging a little clearer.
+	    this.type_ = type || TYPE_SHARED;
+	    this.push = function (data) {
+	      // Any "shared" rollover streams will accept _all_ data. Otherwise,
+	      // streams will only accept data that matches their type.
+	      if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {
+	        return;
+	      }
+	      if (referenceDTS === undefined) {
+	        referenceDTS = data.dts;
+	      }
+	      data.dts = handleRollover(data.dts, referenceDTS);
+	      data.pts = handleRollover(data.pts, referenceDTS);
+	      lastDTS = data.dts;
+	      this.trigger('data', data);
+	    };
+	    this.flush = function () {
+	      referenceDTS = lastDTS;
+	      this.trigger('done');
+	    };
+	    this.endTimeline = function () {
+	      this.flush();
+	      this.trigger('endedtimeline');
+	    };
+	    this.discontinuity = function () {
+	      referenceDTS = void 0;
+	      lastDTS = void 0;
+	    };
+	    this.reset = function () {
+	      this.discontinuity();
+	      this.trigger('reset');
+	    };
+	  };
+	  TimestampRolloverStream$1.prototype = new stream();
+	  var timestampRolloverStream = {
+	    TimestampRolloverStream: TimestampRolloverStream$1,
+	    handleRollover: handleRollover
+	  };
+
+	  // IE11 doesn't support indexOf for TypedArrays.
+	  // Once IE11 support is dropped, this function should be removed.
+	  var typedArrayIndexOf$1 = function typedArrayIndexOf(typedArray, element, fromIndex) {
+	    if (!typedArray) {
+	      return -1;
+	    }
+	    var currentIndex = fromIndex;
+	    for (; currentIndex < typedArray.length; currentIndex++) {
+	      if (typedArray[currentIndex] === element) {
+	        return currentIndex;
+	      }
+	    }
+	    return -1;
+	  };
+	  var typedArray = {
+	    typedArrayIndexOf: typedArrayIndexOf$1
+	  };
+
+	  var typedArrayIndexOf = typedArray.typedArrayIndexOf,
+	    // Frames that allow different types of text encoding contain a text
+	    // encoding description byte [ID3v2.4.0 section 4.]
+	    textEncodingDescriptionByte = {
+	      Iso88591: 0x00,
+	      // ISO-8859-1, terminated with \0.
+	      Utf16: 0x01,
+	      // UTF-16 encoded Unicode BOM, terminated with \0\0
+	      Utf16be: 0x02,
+	      // UTF-16BE encoded Unicode, without BOM, terminated with \0\0
+	      Utf8: 0x03 // UTF-8 encoded Unicode, terminated with \0
+	    },
+	    // return a percent-encoded representation of the specified byte range
+	    // @see http://en.wikipedia.org/wiki/Percent-encoding 
+	    percentEncode$1 = function percentEncode(bytes, start, end) {
+	      var i,
+	        result = '';
+	      for (i = start; i < end; i++) {
+	        result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+	      }
+	      return result;
+	    },
+	    // return the string representation of the specified byte range,
+	    // interpreted as UTf-8.
+	    parseUtf8 = function parseUtf8(bytes, start, end) {
+	      return decodeURIComponent(percentEncode$1(bytes, start, end));
+	    },
+	    // return the string representation of the specified byte range,
+	    // interpreted as ISO-8859-1.
+	    parseIso88591$1 = function parseIso88591(bytes, start, end) {
+	      return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line
+	    },
+	    parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {
+	      return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+	    },
+	    frameParsers = {
+	      'APIC': function APIC(frame) {
+	        var i = 1,
+	          mimeTypeEndIndex,
+	          descriptionEndIndex,
+	          LINK_MIME_TYPE = '-->';
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+
+	        // parsing fields [ID3v2.4.0 section 4.14.]
+	        mimeTypeEndIndex = typedArrayIndexOf(frame.data, 0, i);
+	        if (mimeTypeEndIndex < 0) {
+	          // malformed frame
+	          return;
+	        }
+
+	        // parsing Mime type field (terminated with \0)
+	        frame.mimeType = parseIso88591$1(frame.data, i, mimeTypeEndIndex);
+	        i = mimeTypeEndIndex + 1;
+
+	        // parsing 1-byte Picture Type field
+	        frame.pictureType = frame.data[i];
+	        i++;
+	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, i);
+	        if (descriptionEndIndex < 0) {
+	          // malformed frame
+	          return;
+	        }
+
+	        // parsing Description field (terminated with \0)
+	        frame.description = parseUtf8(frame.data, i, descriptionEndIndex);
+	        i = descriptionEndIndex + 1;
+	        if (frame.mimeType === LINK_MIME_TYPE) {
+	          // parsing Picture Data field as URL (always represented as ISO-8859-1 [ID3v2.4.0 section 4.])
+	          frame.url = parseIso88591$1(frame.data, i, frame.data.length);
+	        } else {
+	          // parsing Picture Data field as binary data
+	          frame.pictureData = frame.data.subarray(i, frame.data.length);
+	        }
+	      },
+	      'T*': function T(frame) {
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+
+	        // parse text field, do not include null terminator in the frame value
+	        // frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
+	        frame.value = parseUtf8(frame.data, 1, frame.data.length).replace(/\0*$/, '');
+	        // text information frames supports multiple strings, stored as a terminator separated list [ID3v2.4.0 section 4.2.]
+	        frame.values = frame.value.split('\0');
+	      },
+	      'TXXX': function TXXX(frame) {
+	        var descriptionEndIndex;
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+	        if (descriptionEndIndex === -1) {
+	          return;
+	        }
+
+	        // parse the text fields
+	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+	        // do not include the null terminator in the tag value
+	        // frames that allow different types of encoding contain terminated text
+	        // [ID3v2.4.0 section 4.]
+	        frame.value = parseUtf8(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0*$/, '');
+	        frame.data = frame.value;
+	      },
+	      'W*': function W(frame) {
+	        // parse URL field; URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+	        // if the value is followed by a string termination all the following information should be ignored [ID3v2.4.0 section 4.3]
+	        frame.url = parseIso88591$1(frame.data, 0, frame.data.length).replace(/\0.*$/, '');
+	      },
+	      'WXXX': function WXXX(frame) {
+	        var descriptionEndIndex;
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+	        if (descriptionEndIndex === -1) {
+	          return;
+	        }
+
+	        // parse the description and URL fields
+	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+	        // URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+	        // if the value is followed by a string termination all the following information
+	        // should be ignored [ID3v2.4.0 section 4.3]
+	        frame.url = parseIso88591$1(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0.*$/, '');
+	      },
+	      'PRIV': function PRIV(frame) {
+	        var i;
+	        for (i = 0; i < frame.data.length; i++) {
+	          if (frame.data[i] === 0) {
+	            // parse the description and URL fields
+	            frame.owner = parseIso88591$1(frame.data, 0, i);
+	            break;
+	          }
+	        }
+	        frame.privateData = frame.data.subarray(i + 1);
+	        frame.data = frame.privateData;
+	      }
+	    };
+	  var parseId3Frames = function parseId3Frames(data) {
+	    var frameSize,
+	      frameHeader,
+	      frameStart = 10,
+	      tagSize = 0,
+	      frames = [];
+
+	    // If we don't have enough data for a header, 10 bytes, 
+	    // or 'ID3' in the first 3 bytes this is not a valid ID3 tag.
+	    if (data.length < 10 || data[0] !== 'I'.charCodeAt(0) || data[1] !== 'D'.charCodeAt(0) || data[2] !== '3'.charCodeAt(0)) {
+	      return;
+	    }
+	    // the frame size is transmitted as a 28-bit integer in the
+	    // last four bytes of the ID3 header.
+	    // The most significant bit of each byte is dropped and the
+	    // results concatenated to recover the actual value.
+	    tagSize = parseSyncSafeInteger$1(data.subarray(6, 10));
+
+	    // ID3 reports the tag size excluding the header but it's more
+	    // convenient for our comparisons to include it
+	    tagSize += 10;
+	    // check bit 6 of byte 5 for the extended header flag.
+	    var hasExtendedHeader = data[5] & 0x40;
+	    if (hasExtendedHeader) {
+	      // advance the frame start past the extended header
+	      frameStart += 4; // header size field
+	      frameStart += parseSyncSafeInteger$1(data.subarray(10, 14));
+	      tagSize -= parseSyncSafeInteger$1(data.subarray(16, 20)); // clip any padding off the end
+	    }
+
+	    // parse one or more ID3 frames
+	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+	    do {
+	      // determine the number of bytes in this frame
+	      frameSize = parseSyncSafeInteger$1(data.subarray(frameStart + 4, frameStart + 8));
+	      if (frameSize < 1) {
+	        break;
+	      }
+	      frameHeader = String.fromCharCode(data[frameStart], data[frameStart + 1], data[frameStart + 2], data[frameStart + 3]);
+	      var frame = {
+	        id: frameHeader,
+	        data: data.subarray(frameStart + 10, frameStart + frameSize + 10)
+	      };
+	      frame.key = frame.id;
+
+	      // parse frame values
+	      if (frameParsers[frame.id]) {
+	        // use frame specific parser
+	        frameParsers[frame.id](frame);
+	      } else if (frame.id[0] === 'T') {
+	        // use text frame generic parser
+	        frameParsers['T*'](frame);
+	      } else if (frame.id[0] === 'W') {
+	        // use URL link frame generic parser
+	        frameParsers['W*'](frame);
+	      }
+	      frames.push(frame);
+	      frameStart += 10; // advance past the frame header
+	      frameStart += frameSize; // advance past the frame body
+	    } while (frameStart < tagSize);
+	    return frames;
+	  };
+	  var parseId3 = {
+	    parseId3Frames: parseId3Frames,
+	    parseSyncSafeInteger: parseSyncSafeInteger$1,
+	    frameParsers: frameParsers
+	  };
+
+	  var _MetadataStream;
+	  _MetadataStream = function MetadataStream(options) {
+	    var settings = {
+	        // the bytes of the program-level descriptor field in MP2T
+	        // see ISO/IEC 13818-1:2013 (E), section 2.6 "Program and
+	        // program element descriptors"
+	        descriptor: options && options.descriptor
+	      },
+	      // the total size in bytes of the ID3 tag being parsed
+	      tagSize = 0,
+	      // tag data that is not complete enough to be parsed
+	      buffer = [],
+	      // the total number of bytes currently in the buffer
+	      bufferSize = 0,
+	      i;
+	    _MetadataStream.prototype.init.call(this);
+
+	    // calculate the text track in-band metadata track dispatch type
+	    // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
+	    this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);
+	    if (settings.descriptor) {
+	      for (i = 0; i < settings.descriptor.length; i++) {
+	        this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);
+	      }
+	    }
+	    this.push = function (chunk) {
+	      var tag, frameStart, frameSize, frame, i, frameHeader;
+	      if (chunk.type !== 'timed-metadata') {
+	        return;
+	      }
+
+	      // if data_alignment_indicator is set in the PES header,
+	      // we must have the start of a new ID3 tag. Assume anything
+	      // remaining in the buffer was malformed and throw it out
+	      if (chunk.dataAlignmentIndicator) {
+	        bufferSize = 0;
+	        buffer.length = 0;
+	      }
+
+	      // ignore events that don't look like ID3 data
+	      if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {
+	        this.trigger('log', {
+	          level: 'warn',
+	          message: 'Skipping unrecognized metadata packet'
+	        });
+	        return;
+	      }
+
+	      // add this chunk to the data we've collected so far
+
+	      buffer.push(chunk);
+	      bufferSize += chunk.data.byteLength;
+
+	      // grab the size of the entire frame from the ID3 header
+	      if (buffer.length === 1) {
+	        // the frame size is transmitted as a 28-bit integer in the
+	        // last four bytes of the ID3 header.
+	        // The most significant bit of each byte is dropped and the
+	        // results concatenated to recover the actual value.
+	        tagSize = parseId3.parseSyncSafeInteger(chunk.data.subarray(6, 10));
+
+	        // ID3 reports the tag size excluding the header but it's more
+	        // convenient for our comparisons to include it
+	        tagSize += 10;
+	      }
+
+	      // if the entire frame has not arrived, wait for more data
+	      if (bufferSize < tagSize) {
+	        return;
+	      }
+
+	      // collect the entire frame so it can be parsed
+	      tag = {
+	        data: new Uint8Array(tagSize),
+	        frames: [],
+	        pts: buffer[0].pts,
+	        dts: buffer[0].dts
+	      };
+	      for (i = 0; i < tagSize;) {
+	        tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);
+	        i += buffer[0].data.byteLength;
+	        bufferSize -= buffer[0].data.byteLength;
+	        buffer.shift();
+	      }
+
+	      // find the start of the first frame and the end of the tag
+	      frameStart = 10;
+	      if (tag.data[5] & 0x40) {
+	        // advance the frame start past the extended header
+	        frameStart += 4; // header size field
+	        frameStart += parseId3.parseSyncSafeInteger(tag.data.subarray(10, 14));
+
+	        // clip any padding off the end
+	        tagSize -= parseId3.parseSyncSafeInteger(tag.data.subarray(16, 20));
+	      }
+
+	      // parse one or more ID3 frames
+	      // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+	      do {
+	        // determine the number of bytes in this frame
+	        frameSize = parseId3.parseSyncSafeInteger(tag.data.subarray(frameStart + 4, frameStart + 8));
+	        if (frameSize < 1) {
+	          this.trigger('log', {
+	            level: 'warn',
+	            message: 'Malformed ID3 frame encountered. Skipping remaining metadata parsing.'
+	          });
+	          // If the frame is malformed, don't parse any further frames but allow previous valid parsed frames
+	          // to be sent along.
+	          break;
+	        }
+	        frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);
+	        frame = {
+	          id: frameHeader,
+	          data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)
+	        };
+	        frame.key = frame.id;
+
+	        // parse frame values
+	        if (parseId3.frameParsers[frame.id]) {
+	          // use frame specific parser
+	          parseId3.frameParsers[frame.id](frame);
+	        } else if (frame.id[0] === 'T') {
+	          // use text frame generic parser
+	          parseId3.frameParsers['T*'](frame);
+	        } else if (frame.id[0] === 'W') {
+	          // use URL link frame generic parser
+	          parseId3.frameParsers['W*'](frame);
+	        }
+
+	        // handle the special PRIV frame used to indicate the start
+	        // time for raw AAC data
+	        if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {
+	          var d = frame.data,
+	            size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+	          size *= 4;
+	          size += d[7] & 0x03;
+	          frame.timeStamp = size;
+	          // in raw AAC, all subsequent data will be timestamped based
+	          // on the value of this frame
+	          // we couldn't have known the appropriate pts and dts before
+	          // parsing this ID3 tag so set those values now
+	          if (tag.pts === undefined && tag.dts === undefined) {
+	            tag.pts = frame.timeStamp;
+	            tag.dts = frame.timeStamp;
+	          }
+	          this.trigger('timestamp', frame);
+	        }
+	        tag.frames.push(frame);
+	        frameStart += 10; // advance past the frame header
+	        frameStart += frameSize; // advance past the frame body
+	      } while (frameStart < tagSize);
+	      this.trigger('data', tag);
+	    };
+	  };
+	  _MetadataStream.prototype = new stream();
+	  var metadataStream = _MetadataStream;
+
+	  var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream;
+
+	  // object types
+	  var _TransportPacketStream, _TransportParseStream, _ElementaryStream;
+
+	  // constants
+	  var MP2T_PACKET_LENGTH = 188,
+	    // bytes
+	    SYNC_BYTE = 0x47;
+
+	  /**
+	   * Splits an incoming stream of binary data into MPEG-2 Transport
+	   * Stream packets.
+	   */
+	  _TransportPacketStream = function TransportPacketStream() {
+	    var buffer = new Uint8Array(MP2T_PACKET_LENGTH),
+	      bytesInBuffer = 0;
+	    _TransportPacketStream.prototype.init.call(this);
+
+	    // Deliver new bytes to the stream.
+
+	    /**
+	     * Split a stream of data into M2TS packets
+	    **/
+	    this.push = function (bytes) {
+	      var startIndex = 0,
+	        endIndex = MP2T_PACKET_LENGTH,
+	        everything;
+
+	      // If there are bytes remaining from the last segment, prepend them to the
+	      // bytes that were pushed in
+	      if (bytesInBuffer) {
+	        everything = new Uint8Array(bytes.byteLength + bytesInBuffer);
+	        everything.set(buffer.subarray(0, bytesInBuffer));
+	        everything.set(bytes, bytesInBuffer);
+	        bytesInBuffer = 0;
+	      } else {
+	        everything = bytes;
+	      }
+
+	      // While we have enough data for a packet
+	      while (endIndex < everything.byteLength) {
+	        // Look for a pair of start and end sync bytes in the data..
+	        if (everything[startIndex] === SYNC_BYTE && everything[endIndex] === SYNC_BYTE) {
+	          // We found a packet so emit it and jump one whole packet forward in
+	          // the stream
+	          this.trigger('data', everything.subarray(startIndex, endIndex));
+	          startIndex += MP2T_PACKET_LENGTH;
+	          endIndex += MP2T_PACKET_LENGTH;
+	          continue;
+	        }
+	        // If we get here, we have somehow become de-synchronized and we need to step
+	        // forward one byte at a time until we find a pair of sync bytes that denote
+	        // a packet
+	        startIndex++;
+	        endIndex++;
+	      }
+
+	      // If there was some data left over at the end of the segment that couldn't
+	      // possibly be a whole packet, keep it because it might be the start of a packet
+	      // that continues in the next segment
+	      if (startIndex < everything.byteLength) {
+	        buffer.set(everything.subarray(startIndex), 0);
+	        bytesInBuffer = everything.byteLength - startIndex;
+	      }
+	    };
+
+	    /**
+	     * Passes identified M2TS packets to the TransportParseStream to be parsed
+	    **/
+	    this.flush = function () {
+	      // If the buffer contains a whole packet when we are being flushed, emit it
+	      // and empty the buffer. Otherwise hold onto the data because it may be
+	      // important for decoding the next segment
+	      if (bytesInBuffer === MP2T_PACKET_LENGTH && buffer[0] === SYNC_BYTE) {
+	        this.trigger('data', buffer);
+	        bytesInBuffer = 0;
+	      }
+	      this.trigger('done');
+	    };
+	    this.endTimeline = function () {
+	      this.flush();
+	      this.trigger('endedtimeline');
+	    };
+	    this.reset = function () {
+	      bytesInBuffer = 0;
+	      this.trigger('reset');
+	    };
+	  };
+	  _TransportPacketStream.prototype = new stream();
+
+	  /**
+	   * Accepts an MP2T TransportPacketStream and emits data events with parsed
+	   * forms of the individual transport stream packets.
+	   */
+	  _TransportParseStream = function TransportParseStream() {
+	    var parsePsi, parsePat, parsePmt, self;
+	    _TransportParseStream.prototype.init.call(this);
+	    self = this;
+	    this.packetsWaitingForPmt = [];
+	    this.programMapTable = undefined;
+	    parsePsi = function parsePsi(payload, psi) {
+	      var offset = 0;
+
+	      // PSI packets may be split into multiple sections and those
+	      // sections may be split into multiple packets. If a PSI
+	      // section starts in this packet, the payload_unit_start_indicator
+	      // will be true and the first byte of the payload will indicate
+	      // the offset from the current position to the start of the
+	      // section.
+	      if (psi.payloadUnitStartIndicator) {
+	        offset += payload[offset] + 1;
+	      }
+	      if (psi.type === 'pat') {
+	        parsePat(payload.subarray(offset), psi);
+	      } else {
+	        parsePmt(payload.subarray(offset), psi);
+	      }
+	    };
+	    parsePat = function parsePat(payload, pat) {
+	      pat.section_number = payload[7]; // eslint-disable-line camelcase
+	      pat.last_section_number = payload[8]; // eslint-disable-line camelcase
+
+	      // skip the PSI header and parse the first PMT entry
+	      self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];
+	      pat.pmtPid = self.pmtPid;
+	    };
+
+	    /**
+	     * Parse out the relevant fields of a Program Map Table (PMT).
+	     * @param payload {Uint8Array} the PMT-specific portion of an MP2T
+	     * packet. The first byte in this array should be the table_id
+	     * field.
+	     * @param pmt {object} the object that should be decorated with
+	     * fields parsed from the PMT.
+	     */
+	    parsePmt = function parsePmt(payload, pmt) {
+	      var sectionLength, tableEnd, programInfoLength, offset;
+
+	      // PMTs can be sent ahead of the time when they should actually
+	      // take effect. We don't believe this should ever be the case
+	      // for HLS but we'll ignore "forward" PMT declarations if we see
+	      // them. Future PMT declarations have the current_next_indicator
+	      // set to zero.
+	      if (!(payload[5] & 0x01)) {
+	        return;
+	      }
+
+	      // overwrite any existing program map table
+	      self.programMapTable = {
+	        video: null,
+	        audio: null,
+	        'timed-metadata': {}
+	      };
+
+	      // the mapping table ends at the end of the current section
+	      sectionLength = (payload[1] & 0x0f) << 8 | payload[2];
+	      tableEnd = 3 + sectionLength - 4;
+
+	      // to determine where the table is, we have to figure out how
+	      // long the program info descriptors are
+	      programInfoLength = (payload[10] & 0x0f) << 8 | payload[11];
+
+	      // advance the offset to the first entry in the mapping table
+	      offset = 12 + programInfoLength;
+	      while (offset < tableEnd) {
+	        var streamType = payload[offset];
+	        var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2];
+
+	        // only map a single elementary_pid for audio and video stream types
+	        // TODO: should this be done for metadata too? for now maintain behavior of
+	        //       multiple metadata streams
+	        if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {
+	          self.programMapTable.video = pid;
+	        } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {
+	          self.programMapTable.audio = pid;
+	        } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {
+	          // map pid to stream type for metadata streams
+	          self.programMapTable['timed-metadata'][pid] = streamType;
+	        }
+
+	        // move to the next table entry
+	        // skip past the elementary stream descriptors, if present
+	        offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;
+	      }
+
+	      // record the map on the packet as well
+	      pmt.programMapTable = self.programMapTable;
+	    };
+
+	    /**
+	     * Deliver a new MP2T packet to the next stream in the pipeline.
+	     */
+	    this.push = function (packet) {
+	      var result = {},
+	        offset = 4;
+	      result.payloadUnitStartIndicator = !!(packet[1] & 0x40);
+
+	      // pid is a 13-bit field starting at the last bit of packet[1]
+	      result.pid = packet[1] & 0x1f;
+	      result.pid <<= 8;
+	      result.pid |= packet[2];
+
+	      // if an adaption field is present, its length is specified by the
+	      // fifth byte of the TS packet header. The adaptation field is
+	      // used to add stuffing to PES packets that don't fill a complete
+	      // TS packet, and to specify some forms of timing and control data
+	      // that we do not currently use.
+	      if ((packet[3] & 0x30) >>> 4 > 0x01) {
+	        offset += packet[offset] + 1;
+	      }
+
+	      // parse the rest of the packet based on the type
+	      if (result.pid === 0) {
+	        result.type = 'pat';
+	        parsePsi(packet.subarray(offset), result);
+	        this.trigger('data', result);
+	      } else if (result.pid === this.pmtPid) {
+	        result.type = 'pmt';
+	        parsePsi(packet.subarray(offset), result);
+	        this.trigger('data', result);
+
+	        // if there are any packets waiting for a PMT to be found, process them now
+	        while (this.packetsWaitingForPmt.length) {
+	          this.processPes_.apply(this, this.packetsWaitingForPmt.shift());
+	        }
+	      } else if (this.programMapTable === undefined) {
+	        // When we have not seen a PMT yet, defer further processing of
+	        // PES packets until one has been parsed
+	        this.packetsWaitingForPmt.push([packet, offset, result]);
+	      } else {
+	        this.processPes_(packet, offset, result);
+	      }
+	    };
+	    this.processPes_ = function (packet, offset, result) {
+	      // set the appropriate stream type
+	      if (result.pid === this.programMapTable.video) {
+	        result.streamType = streamTypes.H264_STREAM_TYPE;
+	      } else if (result.pid === this.programMapTable.audio) {
+	        result.streamType = streamTypes.ADTS_STREAM_TYPE;
+	      } else {
+	        // if not video or audio, it is timed-metadata or unknown
+	        // if unknown, streamType will be undefined
+	        result.streamType = this.programMapTable['timed-metadata'][result.pid];
+	      }
+	      result.type = 'pes';
+	      result.data = packet.subarray(offset);
+	      this.trigger('data', result);
+	    };
+	  };
+	  _TransportParseStream.prototype = new stream();
+	  _TransportParseStream.STREAM_TYPES = {
+	    h264: 0x1b,
+	    adts: 0x0f
+	  };
+
+	  /**
+	   * Reconsistutes program elementary stream (PES) packets from parsed
+	   * transport stream packets. That is, if you pipe an
+	   * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output
+	   * events will be events which capture the bytes for individual PES
+	   * packets plus relevant metadata that has been extracted from the
+	   * container.
+	   */
+	  _ElementaryStream = function ElementaryStream() {
+	    var self = this,
+	      segmentHadPmt = false,
+	      // PES packet fragments
+	      video = {
+	        data: [],
+	        size: 0
+	      },
+	      audio = {
+	        data: [],
+	        size: 0
+	      },
+	      timedMetadata = {
+	        data: [],
+	        size: 0
+	      },
+	      programMapTable,
+	      parsePes = function parsePes(payload, pes) {
+	        var ptsDtsFlags;
+	        var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2];
+	        // default to an empty array
+	        pes.data = new Uint8Array();
+	        // In certain live streams, the start of a TS fragment has ts packets
+	        // that are frame data that is continuing from the previous fragment. This
+	        // is to check that the pes data is the start of a new pes payload
+	        if (startPrefix !== 1) {
+	          return;
+	        }
+	        // get the packet length, this will be 0 for video
+	        pes.packetLength = 6 + (payload[4] << 8 | payload[5]);
+
+	        // find out if this packets starts a new keyframe
+	        pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0;
+	        // PES packets may be annotated with a PTS value, or a PTS value
+	        // and a DTS value. Determine what combination of values is
+	        // available to work with.
+	        ptsDtsFlags = payload[7];
+
+	        // PTS and DTS are normally stored as a 33-bit number.  Javascript
+	        // performs all bitwise operations on 32-bit integers but javascript
+	        // supports a much greater range (52-bits) of integer using standard
+	        // mathematical operations.
+	        // We construct a 31-bit value using bitwise operators over the 31
+	        // most significant bits and then multiply by 4 (equal to a left-shift
+	        // of 2) before we add the final 2 least significant bits of the
+	        // timestamp (equal to an OR.)
+	        if (ptsDtsFlags & 0xC0) {
+	          // the PTS and DTS are not written out directly. For information
+	          // on how they are encoded, see
+	          // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
+	          pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;
+	          pes.pts *= 4; // Left shift by 2
+	          pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs
+	          pes.dts = pes.pts;
+	          if (ptsDtsFlags & 0x40) {
+	            pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;
+	            pes.dts *= 4; // Left shift by 2
+	            pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs
+	          }
+	        }
+	        // the data section starts immediately after the PES header.
+	        // pes_header_data_length specifies the number of header bytes
+	        // that follow the last byte of the field.
+	        pes.data = payload.subarray(9 + payload[8]);
+	      },
+	      /**
+	        * Pass completely parsed PES packets to the next stream in the pipeline
+	       **/
+	      flushStream = function flushStream(stream, type, forceFlush) {
+	        var packetData = new Uint8Array(stream.size),
+	          event = {
+	            type: type
+	          },
+	          i = 0,
+	          offset = 0,
+	          packetFlushable = false,
+	          fragment;
+
+	        // do nothing if there is not enough buffered data for a complete
+	        // PES header
+	        if (!stream.data.length || stream.size < 9) {
+	          return;
+	        }
+	        event.trackId = stream.data[0].pid;
+
+	        // reassemble the packet
+	        for (i = 0; i < stream.data.length; i++) {
+	          fragment = stream.data[i];
+	          packetData.set(fragment.data, offset);
+	          offset += fragment.data.byteLength;
+	        }
+
+	        // parse assembled packet's PES header
+	        parsePes(packetData, event);
+
+	        // non-video PES packets MUST have a non-zero PES_packet_length
+	        // check that there is enough stream data to fill the packet
+	        packetFlushable = type === 'video' || event.packetLength <= stream.size;
+
+	        // flush pending packets if the conditions are right
+	        if (forceFlush || packetFlushable) {
+	          stream.size = 0;
+	          stream.data.length = 0;
+	        }
+
+	        // only emit packets that are complete. this is to avoid assembling
+	        // incomplete PES packets due to poor segmentation
+	        if (packetFlushable) {
+	          self.trigger('data', event);
+	        }
+	      };
+	    _ElementaryStream.prototype.init.call(this);
+
+	    /**
+	     * Identifies M2TS packet types and parses PES packets using metadata
+	     * parsed from the PMT
+	     **/
+	    this.push = function (data) {
+	      ({
+	        pat: function pat() {
+	          // we have to wait for the PMT to arrive as well before we
+	          // have any meaningful metadata
+	        },
+	        pes: function pes() {
+	          var stream, streamType;
+	          switch (data.streamType) {
+	            case streamTypes.H264_STREAM_TYPE:
+	              stream = video;
+	              streamType = 'video';
+	              break;
+	            case streamTypes.ADTS_STREAM_TYPE:
+	              stream = audio;
+	              streamType = 'audio';
+	              break;
+	            case streamTypes.METADATA_STREAM_TYPE:
+	              stream = timedMetadata;
+	              streamType = 'timed-metadata';
+	              break;
+	            default:
+	              // ignore unknown stream types
+	              return;
+	          }
+
+	          // if a new packet is starting, we can flush the completed
+	          // packet
+	          if (data.payloadUnitStartIndicator) {
+	            flushStream(stream, streamType, true);
+	          }
+
+	          // buffer this fragment until we are sure we've received the
+	          // complete payload
+	          stream.data.push(data);
+	          stream.size += data.data.byteLength;
+	        },
+	        pmt: function pmt() {
+	          var event = {
+	            type: 'metadata',
+	            tracks: []
+	          };
+	          programMapTable = data.programMapTable;
+
+	          // translate audio and video streams to tracks
+	          if (programMapTable.video !== null) {
+	            event.tracks.push({
+	              timelineStartInfo: {
+	                baseMediaDecodeTime: 0
+	              },
+	              id: +programMapTable.video,
+	              codec: 'avc',
+	              type: 'video'
+	            });
+	          }
+	          if (programMapTable.audio !== null) {
+	            event.tracks.push({
+	              timelineStartInfo: {
+	                baseMediaDecodeTime: 0
+	              },
+	              id: +programMapTable.audio,
+	              codec: 'adts',
+	              type: 'audio'
+	            });
+	          }
+	          segmentHadPmt = true;
+	          self.trigger('data', event);
+	        }
+	      })[data.type]();
+	    };
+	    this.reset = function () {
+	      video.size = 0;
+	      video.data.length = 0;
+	      audio.size = 0;
+	      audio.data.length = 0;
+	      this.trigger('reset');
+	    };
+
+	    /**
+	     * Flush any remaining input. Video PES packets may be of variable
+	     * length. Normally, the start of a new video packet can trigger the
+	     * finalization of the previous packet. That is not possible if no
+	     * more video is forthcoming, however. In that case, some other
+	     * mechanism (like the end of the file) has to be employed. When it is
+	     * clear that no additional data is forthcoming, calling this method
+	     * will flush the buffered packets.
+	     */
+	    this.flushStreams_ = function () {
+	      // !!THIS ORDER IS IMPORTANT!!
+	      // video first then audio
+	      flushStream(video, 'video');
+	      flushStream(audio, 'audio');
+	      flushStream(timedMetadata, 'timed-metadata');
+	    };
+	    this.flush = function () {
+	      // if on flush we haven't had a pmt emitted
+	      // and we have a pmt to emit. emit the pmt
+	      // so that we trigger a trackinfo downstream.
+	      if (!segmentHadPmt && programMapTable) {
+	        var pmt = {
+	          type: 'metadata',
+	          tracks: []
+	        };
+	        // translate audio and video streams to tracks
+	        if (programMapTable.video !== null) {
+	          pmt.tracks.push({
+	            timelineStartInfo: {
+	              baseMediaDecodeTime: 0
+	            },
+	            id: +programMapTable.video,
+	            codec: 'avc',
+	            type: 'video'
+	          });
+	        }
+	        if (programMapTable.audio !== null) {
+	          pmt.tracks.push({
+	            timelineStartInfo: {
+	              baseMediaDecodeTime: 0
+	            },
+	            id: +programMapTable.audio,
+	            codec: 'adts',
+	            type: 'audio'
+	          });
+	        }
+	        self.trigger('data', pmt);
+	      }
+	      segmentHadPmt = false;
+	      this.flushStreams_();
+	      this.trigger('done');
+	    };
+	  };
+	  _ElementaryStream.prototype = new stream();
+	  var m2ts = {
+	    PAT_PID: 0x0000,
+	    MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH,
+	    TransportPacketStream: _TransportPacketStream,
+	    TransportParseStream: _TransportParseStream,
+	    ElementaryStream: _ElementaryStream,
+	    TimestampRolloverStream: TimestampRolloverStream,
+	    CaptionStream: captionStream.CaptionStream,
+	    Cea608Stream: captionStream.Cea608Stream,
+	    Cea708Stream: captionStream.Cea708Stream,
+	    MetadataStream: metadataStream
+	  };
+	  for (var type in streamTypes) {
+	    if (streamTypes.hasOwnProperty(type)) {
+	      m2ts[type] = streamTypes[type];
+	    }
+	  }
+	  var m2ts_1 = m2ts;
+
+	  var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;
+	  var _AdtsStream;
+	  var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+
+	  /*
+	   * Accepts a ElementaryStream and emits data events with parsed
+	   * AAC Audio Frames of the individual packets. Input audio in ADTS
+	   * format is unpacked and re-emitted as AAC frames.
+	   *
+	   * @see http://wiki.multimedia.cx/index.php?title=ADTS
+	   * @see http://wiki.multimedia.cx/?title=Understanding_AAC
+	   */
+	  _AdtsStream = function AdtsStream(handlePartialSegments) {
+	    var buffer,
+	      frameNum = 0;
+	    _AdtsStream.prototype.init.call(this);
+	    this.skipWarn_ = function (start, end) {
+	      this.trigger('log', {
+	        level: 'warn',
+	        message: "adts skiping bytes " + start + " to " + end + " in frame " + frameNum + " outside syncword"
+	      });
+	    };
+	    this.push = function (packet) {
+	      var i = 0,
+	        frameLength,
+	        protectionSkipBytes,
+	        oldBuffer,
+	        sampleCount,
+	        adtsFrameDuration;
+	      if (!handlePartialSegments) {
+	        frameNum = 0;
+	      }
+	      if (packet.type !== 'audio') {
+	        // ignore non-audio data
+	        return;
+	      }
+
+	      // Prepend any data in the buffer to the input data so that we can parse
+	      // aac frames the cross a PES packet boundary
+	      if (buffer && buffer.length) {
+	        oldBuffer = buffer;
+	        buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);
+	        buffer.set(oldBuffer);
+	        buffer.set(packet.data, oldBuffer.byteLength);
+	      } else {
+	        buffer = packet.data;
+	      }
+
+	      // unpack any ADTS frames which have been fully received
+	      // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS
+	      var skip;
+
+	      // We use i + 7 here because we want to be able to parse the entire header.
+	      // If we don't have enough bytes to do that, then we definitely won't have a full frame.
+	      while (i + 7 < buffer.length) {
+	        // Look for the start of an ADTS header..
+	        if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {
+	          if (typeof skip !== 'number') {
+	            skip = i;
+	          }
+	          // If a valid header was not found,  jump one forward and attempt to
+	          // find a valid ADTS header starting at the next byte
+	          i++;
+	          continue;
+	        }
+	        if (typeof skip === 'number') {
+	          this.skipWarn_(skip, i);
+	          skip = null;
+	        }
+
+	        // The protection skip bit tells us if we have 2 bytes of CRC data at the
+	        // end of the ADTS header
+	        protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2;
+
+	        // Frame length is a 13 bit integer starting 16 bits from the
+	        // end of the sync sequence
+	        // NOTE: frame length includes the size of the header
+	        frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;
+	        sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;
+	        adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$1 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2];
+
+	        // If we don't have enough data to actually finish this ADTS frame,
+	        // then we have to wait for more data
+	        if (buffer.byteLength - i < frameLength) {
+	          break;
+	        }
+
+	        // Otherwise, deliver the complete AAC frame
+	        this.trigger('data', {
+	          pts: packet.pts + frameNum * adtsFrameDuration,
+	          dts: packet.dts + frameNum * adtsFrameDuration,
+	          sampleCount: sampleCount,
+	          audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,
+	          channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,
+	          samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],
+	          samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,
+	          // assume ISO/IEC 14496-12 AudioSampleEntry default of 16
+	          samplesize: 16,
+	          // data is the frame without it's header
+	          data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)
+	        });
+	        frameNum++;
+	        i += frameLength;
+	      }
+	      if (typeof skip === 'number') {
+	        this.skipWarn_(skip, i);
+	        skip = null;
+	      }
+
+	      // remove processed bytes from the buffer.
+	      buffer = buffer.subarray(i);
+	    };
+	    this.flush = function () {
+	      frameNum = 0;
+	      this.trigger('done');
+	    };
+	    this.reset = function () {
+	      buffer = void 0;
+	      this.trigger('reset');
+	    };
+	    this.endTimeline = function () {
+	      buffer = void 0;
+	      this.trigger('endedtimeline');
+	    };
+	  };
+	  _AdtsStream.prototype = new stream();
+	  var adts = _AdtsStream;
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+
+	  var ExpGolomb;
+
+	  /**
+	   * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+	   * scheme used by h264.
+	   */
+	  ExpGolomb = function ExpGolomb(workingData) {
+	    var
+	      // the number of bytes left to examine in workingData
+	      workingBytesAvailable = workingData.byteLength,
+	      // the current word being examined
+	      workingWord = 0,
+	      // :uint
+
+	      // the number of bits left to examine in the current word
+	      workingBitsAvailable = 0; // :uint;
+
+	    // ():uint
+	    this.length = function () {
+	      return 8 * workingBytesAvailable;
+	    };
+
+	    // ():uint
+	    this.bitsAvailable = function () {
+	      return 8 * workingBytesAvailable + workingBitsAvailable;
+	    };
+
+	    // ():void
+	    this.loadWord = function () {
+	      var position = workingData.byteLength - workingBytesAvailable,
+	        workingBytes = new Uint8Array(4),
+	        availableBytes = Math.min(4, workingBytesAvailable);
+	      if (availableBytes === 0) {
+	        throw new Error('no bytes available');
+	      }
+	      workingBytes.set(workingData.subarray(position, position + availableBytes));
+	      workingWord = new DataView(workingBytes.buffer).getUint32(0);
+
+	      // track the amount of workingData that has been processed
+	      workingBitsAvailable = availableBytes * 8;
+	      workingBytesAvailable -= availableBytes;
+	    };
+
+	    // (count:int):void
+	    this.skipBits = function (count) {
+	      var skipBytes; // :int
+	      if (workingBitsAvailable > count) {
+	        workingWord <<= count;
+	        workingBitsAvailable -= count;
+	      } else {
+	        count -= workingBitsAvailable;
+	        skipBytes = Math.floor(count / 8);
+	        count -= skipBytes * 8;
+	        workingBytesAvailable -= skipBytes;
+	        this.loadWord();
+	        workingWord <<= count;
+	        workingBitsAvailable -= count;
+	      }
+	    };
+
+	    // (size:int):uint
+	    this.readBits = function (size) {
+	      var bits = Math.min(workingBitsAvailable, size),
+	        // :uint
+	        valu = workingWord >>> 32 - bits; // :uint
+	      // if size > 31, handle error
+	      workingBitsAvailable -= bits;
+	      if (workingBitsAvailable > 0) {
+	        workingWord <<= bits;
+	      } else if (workingBytesAvailable > 0) {
+	        this.loadWord();
+	      }
+	      bits = size - bits;
+	      if (bits > 0) {
+	        return valu << bits | this.readBits(bits);
+	      }
+	      return valu;
+	    };
+
+	    // ():uint
+	    this.skipLeadingZeros = function () {
+	      var leadingZeroCount; // :uint
+	      for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {
+	        if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {
+	          // the first bit of working word is 1
+	          workingWord <<= leadingZeroCount;
+	          workingBitsAvailable -= leadingZeroCount;
+	          return leadingZeroCount;
+	        }
+	      }
+
+	      // we exhausted workingWord and still have not found a 1
+	      this.loadWord();
+	      return leadingZeroCount + this.skipLeadingZeros();
+	    };
+
+	    // ():void
+	    this.skipUnsignedExpGolomb = function () {
+	      this.skipBits(1 + this.skipLeadingZeros());
+	    };
+
+	    // ():void
+	    this.skipExpGolomb = function () {
+	      this.skipBits(1 + this.skipLeadingZeros());
+	    };
+
+	    // ():uint
+	    this.readUnsignedExpGolomb = function () {
+	      var clz = this.skipLeadingZeros(); // :uint
+	      return this.readBits(clz + 1) - 1;
+	    };
+
+	    // ():int
+	    this.readExpGolomb = function () {
+	      var valu = this.readUnsignedExpGolomb(); // :int
+	      if (0x01 & valu) {
+	        // the number is odd if the low order bit is set
+	        return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
+	      }
+
+	      return -1 * (valu >>> 1); // divide by two then make it negative
+	    };
+
+	    // Some convenience functions
+	    // :Boolean
+	    this.readBoolean = function () {
+	      return this.readBits(1) === 1;
+	    };
+
+	    // ():int
+	    this.readUnsignedByte = function () {
+	      return this.readBits(8);
+	    };
+	    this.loadWord();
+	  };
+	  var expGolomb = ExpGolomb;
+
+	  var _H264Stream, _NalByteStream;
+	  var PROFILES_WITH_OPTIONAL_SPS_DATA;
+
+	  /**
+	   * Accepts a NAL unit byte stream and unpacks the embedded NAL units.
+	   */
+	  _NalByteStream = function NalByteStream() {
+	    var syncPoint = 0,
+	      i,
+	      buffer;
+	    _NalByteStream.prototype.init.call(this);
+
+	    /*
+	     * Scans a byte stream and triggers a data event with the NAL units found.
+	     * @param {Object} data Event received from H264Stream
+	     * @param {Uint8Array} data.data The h264 byte stream to be scanned
+	     *
+	     * @see H264Stream.push
+	     */
+	    this.push = function (data) {
+	      var swapBuffer;
+	      if (!buffer) {
+	        buffer = data.data;
+	      } else {
+	        swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);
+	        swapBuffer.set(buffer);
+	        swapBuffer.set(data.data, buffer.byteLength);
+	        buffer = swapBuffer;
+	      }
+	      var len = buffer.byteLength;
+
+	      // Rec. ITU-T H.264, Annex B
+	      // scan for NAL unit boundaries
+
+	      // a match looks like this:
+	      // 0 0 1 .. NAL .. 0 0 1
+	      // ^ sync point        ^ i
+	      // or this:
+	      // 0 0 1 .. NAL .. 0 0 0
+	      // ^ sync point        ^ i
+
+	      // advance the sync point to a NAL start, if necessary
+	      for (; syncPoint < len - 3; syncPoint++) {
+	        if (buffer[syncPoint + 2] === 1) {
+	          // the sync point is properly aligned
+	          i = syncPoint + 5;
+	          break;
+	        }
+	      }
+	      while (i < len) {
+	        // look at the current byte to determine if we've hit the end of
+	        // a NAL unit boundary
+	        switch (buffer[i]) {
+	          case 0:
+	            // skip past non-sync sequences
+	            if (buffer[i - 1] !== 0) {
+	              i += 2;
+	              break;
+	            } else if (buffer[i - 2] !== 0) {
+	              i++;
+	              break;
+	            }
+
+	            // deliver the NAL unit if it isn't empty
+	            if (syncPoint + 3 !== i - 2) {
+	              this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+	            }
+
+	            // drop trailing zeroes
+	            do {
+	              i++;
+	            } while (buffer[i] !== 1 && i < len);
+	            syncPoint = i - 2;
+	            i += 3;
+	            break;
+	          case 1:
+	            // skip past non-sync sequences
+	            if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {
+	              i += 3;
+	              break;
+	            }
+
+	            // deliver the NAL unit
+	            this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+	            syncPoint = i - 2;
+	            i += 3;
+	            break;
+	          default:
+	            // the current byte isn't a one or zero, so it cannot be part
+	            // of a sync sequence
+	            i += 3;
+	            break;
+	        }
+	      }
+	      // filter out the NAL units that were delivered
+	      buffer = buffer.subarray(syncPoint);
+	      i -= syncPoint;
+	      syncPoint = 0;
+	    };
+	    this.reset = function () {
+	      buffer = null;
+	      syncPoint = 0;
+	      this.trigger('reset');
+	    };
+	    this.flush = function () {
+	      // deliver the last buffered NAL unit
+	      if (buffer && buffer.byteLength > 3) {
+	        this.trigger('data', buffer.subarray(syncPoint + 3));
+	      }
+	      // reset the stream state
+	      buffer = null;
+	      syncPoint = 0;
+	      this.trigger('done');
+	    };
+	    this.endTimeline = function () {
+	      this.flush();
+	      this.trigger('endedtimeline');
+	    };
+	  };
+	  _NalByteStream.prototype = new stream();
+
+	  // values of profile_idc that indicate additional fields are included in the SPS
+	  // see Recommendation ITU-T H.264 (4/2013),
+	  // 7.3.2.1.1 Sequence parameter set data syntax
+	  PROFILES_WITH_OPTIONAL_SPS_DATA = {
+	    100: true,
+	    110: true,
+	    122: true,
+	    244: true,
+	    44: true,
+	    83: true,
+	    86: true,
+	    118: true,
+	    128: true,
+	    // TODO: the three profiles below don't
+	    // appear to have sps data in the specificiation anymore?
+	    138: true,
+	    139: true,
+	    134: true
+	  };
+
+	  /**
+	   * Accepts input from a ElementaryStream and produces H.264 NAL unit data
+	   * events.
+	   */
+	  _H264Stream = function H264Stream() {
+	    var nalByteStream = new _NalByteStream(),
+	      self,
+	      trackId,
+	      currentPts,
+	      currentDts,
+	      discardEmulationPreventionBytes,
+	      readSequenceParameterSet,
+	      skipScalingList;
+	    _H264Stream.prototype.init.call(this);
+	    self = this;
+
+	    /*
+	     * Pushes a packet from a stream onto the NalByteStream
+	     *
+	     * @param {Object} packet - A packet received from a stream
+	     * @param {Uint8Array} packet.data - The raw bytes of the packet
+	     * @param {Number} packet.dts - Decode timestamp of the packet
+	     * @param {Number} packet.pts - Presentation timestamp of the packet
+	     * @param {Number} packet.trackId - The id of the h264 track this packet came from
+	     * @param {('video'|'audio')} packet.type - The type of packet
+	     *
+	     */
+	    this.push = function (packet) {
+	      if (packet.type !== 'video') {
+	        return;
+	      }
+	      trackId = packet.trackId;
+	      currentPts = packet.pts;
+	      currentDts = packet.dts;
+	      nalByteStream.push(packet);
+	    };
+
+	    /*
+	     * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps
+	     * for the NALUs to the next stream component.
+	     * Also, preprocess caption and sequence parameter NALUs.
+	     *
+	     * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`
+	     * @see NalByteStream.push
+	     */
+	    nalByteStream.on('data', function (data) {
+	      var event = {
+	        trackId: trackId,
+	        pts: currentPts,
+	        dts: currentDts,
+	        data: data,
+	        nalUnitTypeCode: data[0] & 0x1f
+	      };
+	      switch (event.nalUnitTypeCode) {
+	        case 0x05:
+	          event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';
+	          break;
+	        case 0x06:
+	          event.nalUnitType = 'sei_rbsp';
+	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+	          break;
+	        case 0x07:
+	          event.nalUnitType = 'seq_parameter_set_rbsp';
+	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+	          event.config = readSequenceParameterSet(event.escapedRBSP);
+	          break;
+	        case 0x08:
+	          event.nalUnitType = 'pic_parameter_set_rbsp';
+	          break;
+	        case 0x09:
+	          event.nalUnitType = 'access_unit_delimiter_rbsp';
+	          break;
+	      }
+	      // This triggers data on the H264Stream
+	      self.trigger('data', event);
+	    });
+	    nalByteStream.on('done', function () {
+	      self.trigger('done');
+	    });
+	    nalByteStream.on('partialdone', function () {
+	      self.trigger('partialdone');
+	    });
+	    nalByteStream.on('reset', function () {
+	      self.trigger('reset');
+	    });
+	    nalByteStream.on('endedtimeline', function () {
+	      self.trigger('endedtimeline');
+	    });
+	    this.flush = function () {
+	      nalByteStream.flush();
+	    };
+	    this.partialFlush = function () {
+	      nalByteStream.partialFlush();
+	    };
+	    this.reset = function () {
+	      nalByteStream.reset();
+	    };
+	    this.endTimeline = function () {
+	      nalByteStream.endTimeline();
+	    };
+
+	    /**
+	     * Advance the ExpGolomb decoder past a scaling list. The scaling
+	     * list is optionally transmitted as part of a sequence parameter
+	     * set and is not relevant to transmuxing.
+	     * @param count {number} the number of entries in this scaling list
+	     * @param expGolombDecoder {object} an ExpGolomb pointed to the
+	     * start of a scaling list
+	     * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+	     */
+	    skipScalingList = function skipScalingList(count, expGolombDecoder) {
+	      var lastScale = 8,
+	        nextScale = 8,
+	        j,
+	        deltaScale;
+	      for (j = 0; j < count; j++) {
+	        if (nextScale !== 0) {
+	          deltaScale = expGolombDecoder.readExpGolomb();
+	          nextScale = (lastScale + deltaScale + 256) % 256;
+	        }
+	        lastScale = nextScale === 0 ? lastScale : nextScale;
+	      }
+	    };
+
+	    /**
+	     * Expunge any "Emulation Prevention" bytes from a "Raw Byte
+	     * Sequence Payload"
+	     * @param data {Uint8Array} the bytes of a RBSP from a NAL
+	     * unit
+	     * @return {Uint8Array} the RBSP without any Emulation
+	     * Prevention Bytes
+	     */
+	    discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+	      var length = data.byteLength,
+	        emulationPreventionBytesPositions = [],
+	        i = 1,
+	        newLength,
+	        newData;
+
+	      // Find all `Emulation Prevention Bytes`
+	      while (i < length - 2) {
+	        if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+	          emulationPreventionBytesPositions.push(i + 2);
+	          i += 2;
+	        } else {
+	          i++;
+	        }
+	      }
+
+	      // If no Emulation Prevention Bytes were found just return the original
+	      // array
+	      if (emulationPreventionBytesPositions.length === 0) {
+	        return data;
+	      }
+
+	      // Create a new array to hold the NAL unit data
+	      newLength = length - emulationPreventionBytesPositions.length;
+	      newData = new Uint8Array(newLength);
+	      var sourceIndex = 0;
+	      for (i = 0; i < newLength; sourceIndex++, i++) {
+	        if (sourceIndex === emulationPreventionBytesPositions[0]) {
+	          // Skip this byte
+	          sourceIndex++;
+	          // Remove this position index
+	          emulationPreventionBytesPositions.shift();
+	        }
+	        newData[i] = data[sourceIndex];
+	      }
+	      return newData;
+	    };
+
+	    /**
+	     * Read a sequence parameter set and return some interesting video
+	     * properties. A sequence parameter set is the H264 metadata that
+	     * describes the properties of upcoming video frames.
+	     * @param data {Uint8Array} the bytes of a sequence parameter set
+	     * @return {object} an object with configuration parsed from the
+	     * sequence parameter set, including the dimensions of the
+	     * associated video frames.
+	     */
+	    readSequenceParameterSet = function readSequenceParameterSet(data) {
+	      var frameCropLeftOffset = 0,
+	        frameCropRightOffset = 0,
+	        frameCropTopOffset = 0,
+	        frameCropBottomOffset = 0,
+	        expGolombDecoder,
+	        profileIdc,
+	        levelIdc,
+	        profileCompatibility,
+	        chromaFormatIdc,
+	        picOrderCntType,
+	        numRefFramesInPicOrderCntCycle,
+	        picWidthInMbsMinus1,
+	        picHeightInMapUnitsMinus1,
+	        frameMbsOnlyFlag,
+	        scalingListCount,
+	        sarRatio = [1, 1],
+	        aspectRatioIdc,
+	        i;
+	      expGolombDecoder = new expGolomb(data);
+	      profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc
+	      profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag
+	      levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)
+	      expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id
+
+	      // some profiles have more optional data we don't need
+	      if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {
+	        chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
+	        if (chromaFormatIdc === 3) {
+	          expGolombDecoder.skipBits(1); // separate_colour_plane_flag
+	        }
+
+	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8
+	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8
+	        expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
+	        if (expGolombDecoder.readBoolean()) {
+	          // seq_scaling_matrix_present_flag
+	          scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+	          for (i = 0; i < scalingListCount; i++) {
+	            if (expGolombDecoder.readBoolean()) {
+	              // seq_scaling_list_present_flag[ i ]
+	              if (i < 6) {
+	                skipScalingList(16, expGolombDecoder);
+	              } else {
+	                skipScalingList(64, expGolombDecoder);
+	              }
+	            }
+	          }
+	        }
+	      }
+	      expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4
+	      picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
+	      if (picOrderCntType === 0) {
+	        expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4
+	      } else if (picOrderCntType === 1) {
+	        expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag
+	        expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic
+	        expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field
+	        numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();
+	        for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+	          expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]
+	        }
+	      }
+
+	      expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames
+	      expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
+
+	      picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+	      picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+	      frameMbsOnlyFlag = expGolombDecoder.readBits(1);
+	      if (frameMbsOnlyFlag === 0) {
+	        expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag
+	      }
+
+	      expGolombDecoder.skipBits(1); // direct_8x8_inference_flag
+	      if (expGolombDecoder.readBoolean()) {
+	        // frame_cropping_flag
+	        frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
+	        frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
+	        frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
+	        frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
+	      }
+	      if (expGolombDecoder.readBoolean()) {
+	        // vui_parameters_present_flag
+	        if (expGolombDecoder.readBoolean()) {
+	          // aspect_ratio_info_present_flag
+	          aspectRatioIdc = expGolombDecoder.readUnsignedByte();
+	          switch (aspectRatioIdc) {
+	            case 1:
+	              sarRatio = [1, 1];
+	              break;
+	            case 2:
+	              sarRatio = [12, 11];
+	              break;
+	            case 3:
+	              sarRatio = [10, 11];
+	              break;
+	            case 4:
+	              sarRatio = [16, 11];
+	              break;
+	            case 5:
+	              sarRatio = [40, 33];
+	              break;
+	            case 6:
+	              sarRatio = [24, 11];
+	              break;
+	            case 7:
+	              sarRatio = [20, 11];
+	              break;
+	            case 8:
+	              sarRatio = [32, 11];
+	              break;
+	            case 9:
+	              sarRatio = [80, 33];
+	              break;
+	            case 10:
+	              sarRatio = [18, 11];
+	              break;
+	            case 11:
+	              sarRatio = [15, 11];
+	              break;
+	            case 12:
+	              sarRatio = [64, 33];
+	              break;
+	            case 13:
+	              sarRatio = [160, 99];
+	              break;
+	            case 14:
+	              sarRatio = [4, 3];
+	              break;
+	            case 15:
+	              sarRatio = [3, 2];
+	              break;
+	            case 16:
+	              sarRatio = [2, 1];
+	              break;
+	            case 255:
+	              {
+	                sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];
+	                break;
+	              }
+	          }
+	          if (sarRatio) {
+	            sarRatio[0] / sarRatio[1];
+	          }
+	        }
+	      }
+	      return {
+	        profileIdc: profileIdc,
+	        levelIdc: levelIdc,
+	        profileCompatibility: profileCompatibility,
+	        width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,
+	        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,
+	        // sar is sample aspect ratio
+	        sarRatio: sarRatio
+	      };
+	    };
+	  };
+	  _H264Stream.prototype = new stream();
+	  var h264 = {
+	    H264Stream: _H264Stream,
+	    NalByteStream: _NalByteStream
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   *
+	   * Utilities to detect basic properties and metadata about Aac data.
+	   */
+
+	  var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+	  var parseId3TagSize = function parseId3TagSize(header, byteIndex) {
+	    var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],
+	      flags = header[byteIndex + 5],
+	      footerPresent = (flags & 16) >> 4;
+
+	    // if we get a negative returnSize clamp it to 0
+	    returnSize = returnSize >= 0 ? returnSize : 0;
+	    if (footerPresent) {
+	      return returnSize + 20;
+	    }
+	    return returnSize + 10;
+	  };
+	  var getId3Offset = function getId3Offset(data, offset) {
+	    if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {
+	      return offset;
+	    }
+	    offset += parseId3TagSize(data, offset);
+	    return getId3Offset(data, offset);
+	  };
+
+	  // TODO: use vhs-utils
+	  var isLikelyAacData$1 = function isLikelyAacData(data) {
+	    var offset = getId3Offset(data, 0);
+	    return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 &&
+	    // verify that the 2 layer bits are 0, aka this
+	    // is not mp3 data but aac data.
+	    (data[offset + 1] & 0x16) === 0x10;
+	  };
+	  var parseSyncSafeInteger = function parseSyncSafeInteger(data) {
+	    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+	  };
+
+	  // return a percent-encoded representation of the specified byte range
+	  // @see http://en.wikipedia.org/wiki/Percent-encoding
+	  var percentEncode = function percentEncode(bytes, start, end) {
+	    var i,
+	      result = '';
+	    for (i = start; i < end; i++) {
+	      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+	    }
+	    return result;
+	  };
+
+	  // return the string representation of the specified byte range,
+	  // interpreted as ISO-8859-1.
+	  var parseIso88591 = function parseIso88591(bytes, start, end) {
+	    return unescape(percentEncode(bytes, start, end)); // jshint ignore:line
+	  };
+
+	  var parseAdtsSize = function parseAdtsSize(header, byteIndex) {
+	    var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,
+	      middle = header[byteIndex + 4] << 3,
+	      highTwo = header[byteIndex + 3] & 0x3 << 11;
+	    return highTwo | middle | lowThree;
+	  };
+	  var parseType = function parseType(header, byteIndex) {
+	    if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {
+	      return 'timed-metadata';
+	    } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {
+	      return 'audio';
+	    }
+	    return null;
+	  };
+	  var parseSampleRate = function parseSampleRate(packet) {
+	    var i = 0;
+	    while (i + 5 < packet.length) {
+	      if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {
+	        // If a valid header was not found,  jump one forward and attempt to
+	        // find a valid ADTS header starting at the next byte
+	        i++;
+	        continue;
+	      }
+	      return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];
+	    }
+	    return null;
+	  };
+	  var parseAacTimestamp = function parseAacTimestamp(packet) {
+	    var frameStart, frameSize, frame, frameHeader;
+
+	    // find the start of the first frame and the end of the tag
+	    frameStart = 10;
+	    if (packet[5] & 0x40) {
+	      // advance the frame start past the extended header
+	      frameStart += 4; // header size field
+	      frameStart += parseSyncSafeInteger(packet.subarray(10, 14));
+	    }
+
+	    // parse one or more ID3 frames
+	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+	    do {
+	      // determine the number of bytes in this frame
+	      frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));
+	      if (frameSize < 1) {
+	        return null;
+	      }
+	      frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);
+	      if (frameHeader === 'PRIV') {
+	        frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);
+	        for (var i = 0; i < frame.byteLength; i++) {
+	          if (frame[i] === 0) {
+	            var owner = parseIso88591(frame, 0, i);
+	            if (owner === 'com.apple.streaming.transportStreamTimestamp') {
+	              var d = frame.subarray(i + 1);
+	              var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+	              size *= 4;
+	              size += d[7] & 0x03;
+	              return size;
+	            }
+	            break;
+	          }
+	        }
+	      }
+	      frameStart += 10; // advance past the frame header
+	      frameStart += frameSize; // advance past the frame body
+	    } while (frameStart < packet.byteLength);
+	    return null;
+	  };
+	  var utils = {
+	    isLikelyAacData: isLikelyAacData$1,
+	    parseId3TagSize: parseId3TagSize,
+	    parseAdtsSize: parseAdtsSize,
+	    parseType: parseType,
+	    parseSampleRate: parseSampleRate,
+	    parseAacTimestamp: parseAacTimestamp
+	  };
+
+	  // Constants
+	  var _AacStream;
+
+	  /**
+	   * Splits an incoming stream of binary data into ADTS and ID3 Frames.
+	   */
+
+	  _AacStream = function AacStream() {
+	    var everything = new Uint8Array(),
+	      timeStamp = 0;
+	    _AacStream.prototype.init.call(this);
+	    this.setTimestamp = function (timestamp) {
+	      timeStamp = timestamp;
+	    };
+	    this.push = function (bytes) {
+	      var frameSize = 0,
+	        byteIndex = 0,
+	        bytesLeft,
+	        chunk,
+	        packet,
+	        tempLength;
+
+	      // If there are bytes remaining from the last segment, prepend them to the
+	      // bytes that were pushed in
+	      if (everything.length) {
+	        tempLength = everything.length;
+	        everything = new Uint8Array(bytes.byteLength + tempLength);
+	        everything.set(everything.subarray(0, tempLength));
+	        everything.set(bytes, tempLength);
+	      } else {
+	        everything = bytes;
+	      }
+	      while (everything.length - byteIndex >= 3) {
+	        if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {
+	          // Exit early because we don't have enough to parse
+	          // the ID3 tag header
+	          if (everything.length - byteIndex < 10) {
+	            break;
+	          }
+
+	          // check framesize
+	          frameSize = utils.parseId3TagSize(everything, byteIndex);
+
+	          // Exit early if we don't have enough in the buffer
+	          // to emit a full packet
+	          // Add to byteIndex to support multiple ID3 tags in sequence
+	          if (byteIndex + frameSize > everything.length) {
+	            break;
+	          }
+	          chunk = {
+	            type: 'timed-metadata',
+	            data: everything.subarray(byteIndex, byteIndex + frameSize)
+	          };
+	          this.trigger('data', chunk);
+	          byteIndex += frameSize;
+	          continue;
+	        } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {
+	          // Exit early because we don't have enough to parse
+	          // the ADTS frame header
+	          if (everything.length - byteIndex < 7) {
+	            break;
+	          }
+	          frameSize = utils.parseAdtsSize(everything, byteIndex);
+
+	          // Exit early if we don't have enough in the buffer
+	          // to emit a full packet
+	          if (byteIndex + frameSize > everything.length) {
+	            break;
+	          }
+	          packet = {
+	            type: 'audio',
+	            data: everything.subarray(byteIndex, byteIndex + frameSize),
+	            pts: timeStamp,
+	            dts: timeStamp
+	          };
+	          this.trigger('data', packet);
+	          byteIndex += frameSize;
+	          continue;
+	        }
+	        byteIndex++;
+	      }
+	      bytesLeft = everything.length - byteIndex;
+	      if (bytesLeft > 0) {
+	        everything = everything.subarray(byteIndex);
+	      } else {
+	        everything = new Uint8Array();
+	      }
+	    };
+	    this.reset = function () {
+	      everything = new Uint8Array();
+	      this.trigger('reset');
+	    };
+	    this.endTimeline = function () {
+	      everything = new Uint8Array();
+	      this.trigger('endedtimeline');
+	    };
+	  };
+	  _AacStream.prototype = new stream();
+	  var aac = _AacStream;
+
+	  // constants
+	  var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];
+	  var audioProperties = AUDIO_PROPERTIES;
+
+	  var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];
+	  var videoProperties = VIDEO_PROPERTIES;
+
+	  var H264Stream = h264.H264Stream;
+	  var isLikelyAacData = utils.isLikelyAacData;
+	  var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;
+
+	  // object types
+	  var _VideoSegmentStream, _AudioSegmentStream, _Transmuxer, _CoalesceStream;
+	  var retriggerForStream = function retriggerForStream(key, event) {
+	    event.stream = key;
+	    this.trigger('log', event);
+	  };
+	  var addPipelineLogRetriggers = function addPipelineLogRetriggers(transmuxer, pipeline) {
+	    var keys = Object.keys(pipeline);
+	    for (var i = 0; i < keys.length; i++) {
+	      var key = keys[i];
+
+	      // skip non-stream keys and headOfPipeline
+	      // which is just a duplicate
+	      if (key === 'headOfPipeline' || !pipeline[key].on) {
+	        continue;
+	      }
+	      pipeline[key].on('log', retriggerForStream.bind(transmuxer, key));
+	    }
+	  };
+
+	  /**
+	   * Compare two arrays (even typed) for same-ness
+	   */
+	  var arrayEquals = function arrayEquals(a, b) {
+	    var i;
+	    if (a.length !== b.length) {
+	      return false;
+	    }
+
+	    // compare the value of each element in the array
+	    for (i = 0; i < a.length; i++) {
+	      if (a[i] !== b[i]) {
+	        return false;
+	      }
+	    }
+	    return true;
+	  };
+	  var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {
+	    var ptsOffsetFromDts = startPts - startDts,
+	      decodeDuration = endDts - startDts,
+	      presentationDuration = endPts - startPts;
+
+	    // The PTS and DTS values are based on the actual stream times from the segment,
+	    // however, the player time values will reflect a start from the baseMediaDecodeTime.
+	    // In order to provide relevant values for the player times, base timing info on the
+	    // baseMediaDecodeTime and the DTS and PTS durations of the segment.
+	    return {
+	      start: {
+	        dts: baseMediaDecodeTime,
+	        pts: baseMediaDecodeTime + ptsOffsetFromDts
+	      },
+	      end: {
+	        dts: baseMediaDecodeTime + decodeDuration,
+	        pts: baseMediaDecodeTime + presentationDuration
+	      },
+	      prependedContentDuration: prependedContentDuration,
+	      baseMediaDecodeTime: baseMediaDecodeTime
+	    };
+	  };
+
+	  /**
+	   * Constructs a single-track, ISO BMFF media segment from AAC data
+	   * events. The output of this stream can be fed to a SourceBuffer
+	   * configured with a suitable initialization segment.
+	   * @param track {object} track metadata configuration
+	   * @param options {object} transmuxer options object
+	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at 0.
+	   */
+	  _AudioSegmentStream = function AudioSegmentStream(track, options) {
+	    var adtsFrames = [],
+	      sequenceNumber,
+	      earliestAllowedDts = 0,
+	      audioAppendStartTs = 0,
+	      videoBaseMediaDecodeTime = Infinity;
+	    options = options || {};
+	    sequenceNumber = options.firstSequenceNumber || 0;
+	    _AudioSegmentStream.prototype.init.call(this);
+	    this.push = function (data) {
+	      trackDecodeInfo.collectDtsInfo(track, data);
+	      if (track) {
+	        audioProperties.forEach(function (prop) {
+	          track[prop] = data[prop];
+	        });
+	      }
+
+	      // buffer audio data until end() is called
+	      adtsFrames.push(data);
+	    };
+	    this.setEarliestDts = function (earliestDts) {
+	      earliestAllowedDts = earliestDts;
+	    };
+	    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+	      videoBaseMediaDecodeTime = baseMediaDecodeTime;
+	    };
+	    this.setAudioAppendStart = function (timestamp) {
+	      audioAppendStartTs = timestamp;
+	    };
+	    this.flush = function () {
+	      var frames, moof, mdat, boxes, frameDuration, segmentDuration, videoClockCyclesOfSilencePrefixed;
+
+	      // return early if no audio data has been observed
+	      if (adtsFrames.length === 0) {
+	        this.trigger('done', 'AudioSegmentStream');
+	        return;
+	      }
+	      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);
+	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+
+	      // amount of audio filled but the value is in video clock rather than audio clock
+	      videoClockCyclesOfSilencePrefixed = audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime);
+
+	      // we have to build the index from byte locations to
+	      // samples (that is, adts frames) in the audio data
+	      track.samples = audioFrameUtils.generateSampleTable(frames);
+
+	      // concatenate the audio data to constuct the mdat
+	      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));
+	      adtsFrames = [];
+	      moof = mp4Generator.moof(sequenceNumber, [track]);
+	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+	      // bump the sequence number for next time
+	      sequenceNumber++;
+	      boxes.set(moof);
+	      boxes.set(mdat, moof.byteLength);
+	      trackDecodeInfo.clearDtsInfo(track);
+	      frameDuration = Math.ceil(ONE_SECOND_IN_TS * 1024 / track.samplerate);
+
+	      // TODO this check was added to maintain backwards compatibility (particularly with
+	      // tests) on adding the timingInfo event. However, it seems unlikely that there's a
+	      // valid use-case where an init segment/data should be triggered without associated
+	      // frames. Leaving for now, but should be looked into.
+	      if (frames.length) {
+	        segmentDuration = frames.length * frameDuration;
+	        this.trigger('segmentTimingInfo', generateSegmentTimingInfo(
+	        // The audio track's baseMediaDecodeTime is in audio clock cycles, but the
+	        // frame info is in video clock cycles. Convert to match expectation of
+	        // listeners (that all timestamps will be based on video clock cycles).
+	        clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate),
+	        // frame times are already in video clock, as is segment duration
+	        frames[0].dts, frames[0].pts, frames[0].dts + segmentDuration, frames[0].pts + segmentDuration, videoClockCyclesOfSilencePrefixed || 0));
+	        this.trigger('timingInfo', {
+	          start: frames[0].pts,
+	          end: frames[0].pts + segmentDuration
+	        });
+	      }
+	      this.trigger('data', {
+	        track: track,
+	        boxes: boxes
+	      });
+	      this.trigger('done', 'AudioSegmentStream');
+	    };
+	    this.reset = function () {
+	      trackDecodeInfo.clearDtsInfo(track);
+	      adtsFrames = [];
+	      this.trigger('reset');
+	    };
+	  };
+	  _AudioSegmentStream.prototype = new stream();
+
+	  /**
+	   * Constructs a single-track, ISO BMFF media segment from H264 data
+	   * events. The output of this stream can be fed to a SourceBuffer
+	   * configured with a suitable initialization segment.
+	   * @param track {object} track metadata configuration
+	   * @param options {object} transmuxer options object
+	   * @param options.alignGopsAtEnd {boolean} If true, start from the end of the
+	   *        gopsToAlignWith list when attempting to align gop pts
+	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at 0.
+	   */
+	  _VideoSegmentStream = function VideoSegmentStream(track, options) {
+	    var sequenceNumber,
+	      nalUnits = [],
+	      gopsToAlignWith = [],
+	      config,
+	      pps;
+	    options = options || {};
+	    sequenceNumber = options.firstSequenceNumber || 0;
+	    _VideoSegmentStream.prototype.init.call(this);
+	    delete track.minPTS;
+	    this.gopCache_ = [];
+
+	    /**
+	      * Constructs a ISO BMFF segment given H264 nalUnits
+	      * @param {Object} nalUnit A data event representing a nalUnit
+	      * @param {String} nalUnit.nalUnitType
+	      * @param {Object} nalUnit.config Properties for a mp4 track
+	      * @param {Uint8Array} nalUnit.data The nalUnit bytes
+	      * @see lib/codecs/h264.js
+	     **/
+	    this.push = function (nalUnit) {
+	      trackDecodeInfo.collectDtsInfo(track, nalUnit);
+
+	      // record the track config
+	      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {
+	        config = nalUnit.config;
+	        track.sps = [nalUnit.data];
+	        videoProperties.forEach(function (prop) {
+	          track[prop] = config[prop];
+	        }, this);
+	      }
+	      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {
+	        pps = nalUnit.data;
+	        track.pps = [nalUnit.data];
+	      }
+
+	      // buffer video until flush() is called
+	      nalUnits.push(nalUnit);
+	    };
+
+	    /**
+	      * Pass constructed ISO BMFF track and boxes on to the
+	      * next stream in the pipeline
+	     **/
+	    this.flush = function () {
+	      var frames,
+	        gopForFusion,
+	        gops,
+	        moof,
+	        mdat,
+	        boxes,
+	        prependedContentDuration = 0,
+	        firstGop,
+	        lastGop;
+
+	      // Throw away nalUnits at the start of the byte stream until
+	      // we find the first AUD
+	      while (nalUnits.length) {
+	        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
+	          break;
+	        }
+	        nalUnits.shift();
+	      }
+
+	      // Return early if no video data has been observed
+	      if (nalUnits.length === 0) {
+	        this.resetStream_();
+	        this.trigger('done', 'VideoSegmentStream');
+	        return;
+	      }
+
+	      // Organize the raw nal-units into arrays that represent
+	      // higher-level constructs such as frames and gops
+	      // (group-of-pictures)
+	      frames = frameUtils.groupNalsIntoFrames(nalUnits);
+	      gops = frameUtils.groupFramesIntoGops(frames);
+
+	      // If the first frame of this fragment is not a keyframe we have
+	      // a problem since MSE (on Chrome) requires a leading keyframe.
+	      //
+	      // We have two approaches to repairing this situation:
+	      // 1) GOP-FUSION:
+	      //    This is where we keep track of the GOPS (group-of-pictures)
+	      //    from previous fragments and attempt to find one that we can
+	      //    prepend to the current fragment in order to create a valid
+	      //    fragment.
+	      // 2) KEYFRAME-PULLING:
+	      //    Here we search for the first keyframe in the fragment and
+	      //    throw away all the frames between the start of the fragment
+	      //    and that keyframe. We then extend the duration and pull the
+	      //    PTS of the keyframe forward so that it covers the time range
+	      //    of the frames that were disposed of.
+	      //
+	      // #1 is far prefereable over #2 which can cause "stuttering" but
+	      // requires more things to be just right.
+	      if (!gops[0][0].keyFrame) {
+	        // Search for a gop for fusion from our gopCache
+	        gopForFusion = this.getGopForFusion_(nalUnits[0], track);
+	        if (gopForFusion) {
+	          // in order to provide more accurate timing information about the segment, save
+	          // the number of seconds prepended to the original segment due to GOP fusion
+	          prependedContentDuration = gopForFusion.duration;
+	          gops.unshift(gopForFusion);
+	          // Adjust Gops' metadata to account for the inclusion of the
+	          // new gop at the beginning
+	          gops.byteLength += gopForFusion.byteLength;
+	          gops.nalCount += gopForFusion.nalCount;
+	          gops.pts = gopForFusion.pts;
+	          gops.dts = gopForFusion.dts;
+	          gops.duration += gopForFusion.duration;
+	        } else {
+	          // If we didn't find a candidate gop fall back to keyframe-pulling
+	          gops = frameUtils.extendFirstKeyFrame(gops);
+	        }
+	      }
+
+	      // Trim gops to align with gopsToAlignWith
+	      if (gopsToAlignWith.length) {
+	        var alignedGops;
+	        if (options.alignGopsAtEnd) {
+	          alignedGops = this.alignGopsAtEnd_(gops);
+	        } else {
+	          alignedGops = this.alignGopsAtStart_(gops);
+	        }
+	        if (!alignedGops) {
+	          // save all the nals in the last GOP into the gop cache
+	          this.gopCache_.unshift({
+	            gop: gops.pop(),
+	            pps: track.pps,
+	            sps: track.sps
+	          });
+
+	          // Keep a maximum of 6 GOPs in the cache
+	          this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+	          // Clear nalUnits
+	          nalUnits = [];
+
+	          // return early no gops can be aligned with desired gopsToAlignWith
+	          this.resetStream_();
+	          this.trigger('done', 'VideoSegmentStream');
+	          return;
+	        }
+
+	        // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct
+	        // when recalculated before sending off to CoalesceStream
+	        trackDecodeInfo.clearDtsInfo(track);
+	        gops = alignedGops;
+	      }
+	      trackDecodeInfo.collectDtsInfo(track, gops);
+
+	      // First, we have to build the index from byte locations to
+	      // samples (that is, frames) in the video data
+	      track.samples = frameUtils.generateSampleTable(gops);
+
+	      // Concatenate the video data and construct the mdat
+	      mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));
+	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+	      this.trigger('processedGopsInfo', gops.map(function (gop) {
+	        return {
+	          pts: gop.pts,
+	          dts: gop.dts,
+	          byteLength: gop.byteLength
+	        };
+	      }));
+	      firstGop = gops[0];
+	      lastGop = gops[gops.length - 1];
+	      this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));
+	      this.trigger('timingInfo', {
+	        start: gops[0].pts,
+	        end: gops[gops.length - 1].pts + gops[gops.length - 1].duration
+	      });
+
+	      // save all the nals in the last GOP into the gop cache
+	      this.gopCache_.unshift({
+	        gop: gops.pop(),
+	        pps: track.pps,
+	        sps: track.sps
+	      });
+
+	      // Keep a maximum of 6 GOPs in the cache
+	      this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+	      // Clear nalUnits
+	      nalUnits = [];
+	      this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);
+	      this.trigger('timelineStartInfo', track.timelineStartInfo);
+	      moof = mp4Generator.moof(sequenceNumber, [track]);
+
+	      // it would be great to allocate this array up front instead of
+	      // throwing away hundreds of media segment fragments
+	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+	      // Bump the sequence number for next time
+	      sequenceNumber++;
+	      boxes.set(moof);
+	      boxes.set(mdat, moof.byteLength);
+	      this.trigger('data', {
+	        track: track,
+	        boxes: boxes
+	      });
+	      this.resetStream_();
+
+	      // Continue with the flush process now
+	      this.trigger('done', 'VideoSegmentStream');
+	    };
+	    this.reset = function () {
+	      this.resetStream_();
+	      nalUnits = [];
+	      this.gopCache_.length = 0;
+	      gopsToAlignWith.length = 0;
+	      this.trigger('reset');
+	    };
+	    this.resetStream_ = function () {
+	      trackDecodeInfo.clearDtsInfo(track);
+
+	      // reset config and pps because they may differ across segments
+	      // for instance, when we are rendition switching
+	      config = undefined;
+	      pps = undefined;
+	    };
+
+	    // Search for a candidate Gop for gop-fusion from the gop cache and
+	    // return it or return null if no good candidate was found
+	    this.getGopForFusion_ = function (nalUnit) {
+	      var halfSecond = 45000,
+	        // Half-a-second in a 90khz clock
+	        allowableOverlap = 10000,
+	        // About 3 frames @ 30fps
+	        nearestDistance = Infinity,
+	        dtsDistance,
+	        nearestGopObj,
+	        currentGop,
+	        currentGopObj,
+	        i;
+
+	      // Search for the GOP nearest to the beginning of this nal unit
+	      for (i = 0; i < this.gopCache_.length; i++) {
+	        currentGopObj = this.gopCache_[i];
+	        currentGop = currentGopObj.gop;
+
+	        // Reject Gops with different SPS or PPS
+	        if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {
+	          continue;
+	        }
+
+	        // Reject Gops that would require a negative baseMediaDecodeTime
+	        if (currentGop.dts < track.timelineStartInfo.dts) {
+	          continue;
+	        }
+
+	        // The distance between the end of the gop and the start of the nalUnit
+	        dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration;
+
+	        // Only consider GOPS that start before the nal unit and end within
+	        // a half-second of the nal unit
+	        if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {
+	          // Always use the closest GOP we found if there is more than
+	          // one candidate
+	          if (!nearestGopObj || nearestDistance > dtsDistance) {
+	            nearestGopObj = currentGopObj;
+	            nearestDistance = dtsDistance;
+	          }
+	        }
+	      }
+	      if (nearestGopObj) {
+	        return nearestGopObj.gop;
+	      }
+	      return null;
+	    };
+
+	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+	    // of gopsToAlignWith starting from the START of the list
+	    this.alignGopsAtStart_ = function (gops) {
+	      var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;
+	      byteLength = gops.byteLength;
+	      nalCount = gops.nalCount;
+	      duration = gops.duration;
+	      alignIndex = gopIndex = 0;
+	      while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {
+	        align = gopsToAlignWith[alignIndex];
+	        gop = gops[gopIndex];
+	        if (align.pts === gop.pts) {
+	          break;
+	        }
+	        if (gop.pts > align.pts) {
+	          // this current gop starts after the current gop we want to align on, so increment
+	          // align index
+	          alignIndex++;
+	          continue;
+	        }
+
+	        // current gop starts before the current gop we want to align on. so increment gop
+	        // index
+	        gopIndex++;
+	        byteLength -= gop.byteLength;
+	        nalCount -= gop.nalCount;
+	        duration -= gop.duration;
+	      }
+	      if (gopIndex === 0) {
+	        // no gops to trim
+	        return gops;
+	      }
+	      if (gopIndex === gops.length) {
+	        // all gops trimmed, skip appending all gops
+	        return null;
+	      }
+	      alignedGops = gops.slice(gopIndex);
+	      alignedGops.byteLength = byteLength;
+	      alignedGops.duration = duration;
+	      alignedGops.nalCount = nalCount;
+	      alignedGops.pts = alignedGops[0].pts;
+	      alignedGops.dts = alignedGops[0].dts;
+	      return alignedGops;
+	    };
+
+	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+	    // of gopsToAlignWith starting from the END of the list
+	    this.alignGopsAtEnd_ = function (gops) {
+	      var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;
+	      alignIndex = gopsToAlignWith.length - 1;
+	      gopIndex = gops.length - 1;
+	      alignEndIndex = null;
+	      matchFound = false;
+	      while (alignIndex >= 0 && gopIndex >= 0) {
+	        align = gopsToAlignWith[alignIndex];
+	        gop = gops[gopIndex];
+	        if (align.pts === gop.pts) {
+	          matchFound = true;
+	          break;
+	        }
+	        if (align.pts > gop.pts) {
+	          alignIndex--;
+	          continue;
+	        }
+	        if (alignIndex === gopsToAlignWith.length - 1) {
+	          // gop.pts is greater than the last alignment candidate. If no match is found
+	          // by the end of this loop, we still want to append gops that come after this
+	          // point
+	          alignEndIndex = gopIndex;
+	        }
+	        gopIndex--;
+	      }
+	      if (!matchFound && alignEndIndex === null) {
+	        return null;
+	      }
+	      var trimIndex;
+	      if (matchFound) {
+	        trimIndex = gopIndex;
+	      } else {
+	        trimIndex = alignEndIndex;
+	      }
+	      if (trimIndex === 0) {
+	        return gops;
+	      }
+	      var alignedGops = gops.slice(trimIndex);
+	      var metadata = alignedGops.reduce(function (total, gop) {
+	        total.byteLength += gop.byteLength;
+	        total.duration += gop.duration;
+	        total.nalCount += gop.nalCount;
+	        return total;
+	      }, {
+	        byteLength: 0,
+	        duration: 0,
+	        nalCount: 0
+	      });
+	      alignedGops.byteLength = metadata.byteLength;
+	      alignedGops.duration = metadata.duration;
+	      alignedGops.nalCount = metadata.nalCount;
+	      alignedGops.pts = alignedGops[0].pts;
+	      alignedGops.dts = alignedGops[0].dts;
+	      return alignedGops;
+	    };
+	    this.alignGopsWith = function (newGopsToAlignWith) {
+	      gopsToAlignWith = newGopsToAlignWith;
+	    };
+	  };
+	  _VideoSegmentStream.prototype = new stream();
+
+	  /**
+	   * A Stream that can combine multiple streams (ie. audio & video)
+	   * into a single output segment for MSE. Also supports audio-only
+	   * and video-only streams.
+	   * @param options {object} transmuxer options object
+	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at media timeline start.
+	   */
+	  _CoalesceStream = function CoalesceStream(options, metadataStream) {
+	    // Number of Tracks per output segment
+	    // If greater than 1, we combine multiple
+	    // tracks into a single segment
+	    this.numberOfTracks = 0;
+	    this.metadataStream = metadataStream;
+	    options = options || {};
+	    if (typeof options.remux !== 'undefined') {
+	      this.remuxTracks = !!options.remux;
+	    } else {
+	      this.remuxTracks = true;
+	    }
+	    if (typeof options.keepOriginalTimestamps === 'boolean') {
+	      this.keepOriginalTimestamps = options.keepOriginalTimestamps;
+	    } else {
+	      this.keepOriginalTimestamps = false;
+	    }
+	    this.pendingTracks = [];
+	    this.videoTrack = null;
+	    this.pendingBoxes = [];
+	    this.pendingCaptions = [];
+	    this.pendingMetadata = [];
+	    this.pendingBytes = 0;
+	    this.emittedTracks = 0;
+	    _CoalesceStream.prototype.init.call(this);
+
+	    // Take output from multiple
+	    this.push = function (output) {
+	      // buffer incoming captions until the associated video segment
+	      // finishes
+	      if (output.text) {
+	        return this.pendingCaptions.push(output);
+	      }
+	      // buffer incoming id3 tags until the final flush
+	      if (output.frames) {
+	        return this.pendingMetadata.push(output);
+	      }
+
+	      // Add this track to the list of pending tracks and store
+	      // important information required for the construction of
+	      // the final segment
+	      this.pendingTracks.push(output.track);
+	      this.pendingBytes += output.boxes.byteLength;
+
+	      // TODO: is there an issue for this against chrome?
+	      // We unshift audio and push video because
+	      // as of Chrome 75 when switching from
+	      // one init segment to another if the video
+	      // mdat does not appear after the audio mdat
+	      // only audio will play for the duration of our transmux.
+	      if (output.track.type === 'video') {
+	        this.videoTrack = output.track;
+	        this.pendingBoxes.push(output.boxes);
+	      }
+	      if (output.track.type === 'audio') {
+	        this.audioTrack = output.track;
+	        this.pendingBoxes.unshift(output.boxes);
+	      }
+	    };
+	  };
+	  _CoalesceStream.prototype = new stream();
+	  _CoalesceStream.prototype.flush = function (flushSource) {
+	    var offset = 0,
+	      event = {
+	        captions: [],
+	        captionStreams: {},
+	        metadata: [],
+	        info: {}
+	      },
+	      caption,
+	      id3,
+	      initSegment,
+	      timelineStartPts = 0,
+	      i;
+	    if (this.pendingTracks.length < this.numberOfTracks) {
+	      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {
+	        // Return because we haven't received a flush from a data-generating
+	        // portion of the segment (meaning that we have only recieved meta-data
+	        // or captions.)
+	        return;
+	      } else if (this.remuxTracks) {
+	        // Return until we have enough tracks from the pipeline to remux (if we
+	        // are remuxing audio and video into a single MP4)
+	        return;
+	      } else if (this.pendingTracks.length === 0) {
+	        // In the case where we receive a flush without any data having been
+	        // received we consider it an emitted track for the purposes of coalescing
+	        // `done` events.
+	        // We do this for the case where there is an audio and video track in the
+	        // segment but no audio data. (seen in several playlists with alternate
+	        // audio tracks and no audio present in the main TS segments.)
+	        this.emittedTracks++;
+	        if (this.emittedTracks >= this.numberOfTracks) {
+	          this.trigger('done');
+	          this.emittedTracks = 0;
+	        }
+	        return;
+	      }
+	    }
+	    if (this.videoTrack) {
+	      timelineStartPts = this.videoTrack.timelineStartInfo.pts;
+	      videoProperties.forEach(function (prop) {
+	        event.info[prop] = this.videoTrack[prop];
+	      }, this);
+	    } else if (this.audioTrack) {
+	      timelineStartPts = this.audioTrack.timelineStartInfo.pts;
+	      audioProperties.forEach(function (prop) {
+	        event.info[prop] = this.audioTrack[prop];
+	      }, this);
+	    }
+	    if (this.videoTrack || this.audioTrack) {
+	      if (this.pendingTracks.length === 1) {
+	        event.type = this.pendingTracks[0].type;
+	      } else {
+	        event.type = 'combined';
+	      }
+	      this.emittedTracks += this.pendingTracks.length;
+	      initSegment = mp4Generator.initSegment(this.pendingTracks);
+
+	      // Create a new typed array to hold the init segment
+	      event.initSegment = new Uint8Array(initSegment.byteLength);
+
+	      // Create an init segment containing a moov
+	      // and track definitions
+	      event.initSegment.set(initSegment);
+
+	      // Create a new typed array to hold the moof+mdats
+	      event.data = new Uint8Array(this.pendingBytes);
+
+	      // Append each moof+mdat (one per track) together
+	      for (i = 0; i < this.pendingBoxes.length; i++) {
+	        event.data.set(this.pendingBoxes[i], offset);
+	        offset += this.pendingBoxes[i].byteLength;
+	      }
+
+	      // Translate caption PTS times into second offsets to match the
+	      // video timeline for the segment, and add track info
+	      for (i = 0; i < this.pendingCaptions.length; i++) {
+	        caption = this.pendingCaptions[i];
+	        caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);
+	        caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);
+	        event.captionStreams[caption.stream] = true;
+	        event.captions.push(caption);
+	      }
+
+	      // Translate ID3 frame PTS times into second offsets to match the
+	      // video timeline for the segment
+	      for (i = 0; i < this.pendingMetadata.length; i++) {
+	        id3 = this.pendingMetadata[i];
+	        id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);
+	        event.metadata.push(id3);
+	      }
+
+	      // We add this to every single emitted segment even though we only need
+	      // it for the first
+	      event.metadata.dispatchType = this.metadataStream.dispatchType;
+
+	      // Reset stream state
+	      this.pendingTracks.length = 0;
+	      this.videoTrack = null;
+	      this.pendingBoxes.length = 0;
+	      this.pendingCaptions.length = 0;
+	      this.pendingBytes = 0;
+	      this.pendingMetadata.length = 0;
+
+	      // Emit the built segment
+	      // We include captions and ID3 tags for backwards compatibility,
+	      // ideally we should send only video and audio in the data event
+	      this.trigger('data', event);
+	      // Emit each caption to the outside world
+	      // Ideally, this would happen immediately on parsing captions,
+	      // but we need to ensure that video data is sent back first
+	      // so that caption timing can be adjusted to match video timing
+	      for (i = 0; i < event.captions.length; i++) {
+	        caption = event.captions[i];
+	        this.trigger('caption', caption);
+	      }
+	      // Emit each id3 tag to the outside world
+	      // Ideally, this would happen immediately on parsing the tag,
+	      // but we need to ensure that video data is sent back first
+	      // so that ID3 frame timing can be adjusted to match video timing
+	      for (i = 0; i < event.metadata.length; i++) {
+	        id3 = event.metadata[i];
+	        this.trigger('id3Frame', id3);
+	      }
+	    }
+
+	    // Only emit `done` if all tracks have been flushed and emitted
+	    if (this.emittedTracks >= this.numberOfTracks) {
+	      this.trigger('done');
+	      this.emittedTracks = 0;
+	    }
+	  };
+	  _CoalesceStream.prototype.setRemux = function (val) {
+	    this.remuxTracks = val;
+	  };
+	  /**
+	   * A Stream that expects MP2T binary data as input and produces
+	   * corresponding media segments, suitable for use with Media Source
+	   * Extension (MSE) implementations that support the ISO BMFF byte
+	   * stream format, like Chrome.
+	   */
+	  _Transmuxer = function Transmuxer(options) {
+	    var self = this,
+	      hasFlushed = true,
+	      videoTrack,
+	      audioTrack;
+	    _Transmuxer.prototype.init.call(this);
+	    options = options || {};
+	    var duration = this.duration = options.duration || 0xffffffff;
+	    this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;
+	    this.transmuxPipeline_ = {};
+	    this.setupAacPipeline = function () {
+	      var pipeline = {};
+	      this.transmuxPipeline_ = pipeline;
+	      pipeline.type = 'aac';
+	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+	      // set up the parsing pipeline
+	      pipeline.aacStream = new aac();
+	      pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');
+	      pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');
+	      pipeline.adtsStream = new adts();
+	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+	      pipeline.headOfPipeline = pipeline.aacStream;
+	      pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);
+	      pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+	      pipeline.metadataStream.on('timestamp', function (frame) {
+	        pipeline.aacStream.setTimestamp(frame.timeStamp);
+	      });
+	      pipeline.aacStream.on('data', function (data) {
+	        if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {
+	          return;
+	        }
+	        audioTrack = audioTrack || {
+	          timelineStartInfo: {
+	            baseMediaDecodeTime: self.baseMediaDecodeTime
+	          },
+	          codec: 'adts',
+	          type: 'audio'
+	        };
+	        // hook up the audio segment stream to the first track with aac data
+	        pipeline.coalesceStream.numberOfTracks++;
+	        pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+	        pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+	        pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+
+	        // Set up the final part of the audio pipeline
+	        pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+
+	        // emit pmt info
+	        self.trigger('trackinfo', {
+	          hasAudio: !!audioTrack,
+	          hasVideo: !!videoTrack
+	        });
+	      });
+
+	      // Re-emit any data coming from the coalesce stream to the outside world
+	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+	      // Let the consumer know we have finished flushing the entire pipeline
+	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+	      addPipelineLogRetriggers(this, pipeline);
+	    };
+	    this.setupTsPipeline = function () {
+	      var pipeline = {};
+	      this.transmuxPipeline_ = pipeline;
+	      pipeline.type = 'ts';
+	      pipeline.duration = duration * 9e4;
+	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+	      // set up the parsing pipeline
+	      pipeline.packetStream = new m2ts_1.TransportPacketStream();
+	      pipeline.parseStream = new m2ts_1.TransportParseStream();
+	      pipeline.elementaryStream = new m2ts_1.ElementaryStream();
+	      pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();
+	      pipeline.adtsStream = new adts();
+	      pipeline.h264Stream = new H264Stream();
+	      pipeline.captionStream = new m2ts_1.CaptionStream(options);
+	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+	      pipeline.headOfPipeline = pipeline.packetStream;
+
+	      // disassemble MPEG2-TS packets into elementary streams
+	      pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream);
+
+	      // !!THIS ORDER IS IMPORTANT!!
+	      // demux the streams
+	      pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);
+	      pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);
+	      pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+
+	      // Hook up CEA-608/708 caption stream
+	      pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);
+	      pipeline.elementaryStream.on('data', function (data) {
+	        var i;
+	        if (data.type === 'metadata') {
+	          i = data.tracks.length;
+
+	          // scan the tracks listed in the metadata
+	          while (i--) {
+	            if (!videoTrack && data.tracks[i].type === 'video') {
+	              videoTrack = data.tracks[i];
+	              videoTrack.duration = pipeline.duration / 2;
+	              videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+	            } else if (!audioTrack && data.tracks[i].type === 'audio') {
+	              audioTrack = data.tracks[i];
+	              audioTrack.duration = pipeline.duration / 2;
+	              audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+	            }
+	          }
+
+	          // hook up the video segment stream to the first track with h264 data
+	          if (videoTrack && !pipeline.videoSegmentStream) {
+	            pipeline.coalesceStream.numberOfTracks++;
+	            pipeline.videoSegmentStream = new _VideoSegmentStream(videoTrack, options);
+	            pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));
+	            pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {
+	              // When video emits timelineStartInfo data after a flush, we forward that
+	              // info to the AudioSegmentStream, if it exists, because video timeline
+	              // data takes precedence.  Do not do this if keepOriginalTimestamps is set,
+	              // because this is a particularly subtle form of timestamp alteration.
+	              if (audioTrack && !options.keepOriginalTimestamps) {
+	                audioTrack.timelineStartInfo = timelineStartInfo;
+	                // On the first segment we trim AAC frames that exist before the
+	                // very earliest DTS we have seen in video because Chrome will
+	                // interpret any video track with a baseMediaDecodeTime that is
+	                // non-zero as a gap.
+	                pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);
+	              }
+	            });
+	            pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));
+	            pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));
+	            pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {
+	              if (audioTrack) {
+	                pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);
+	              }
+	            });
+	            pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo'));
+
+	            // Set up the final part of the video pipeline
+	            pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);
+	          }
+	          if (audioTrack && !pipeline.audioSegmentStream) {
+	            // hook up the audio segment stream to the first track with aac data
+	            pipeline.coalesceStream.numberOfTracks++;
+	            pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+	            pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+	            pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+	            pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo'));
+
+	            // Set up the final part of the audio pipeline
+	            pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+	          }
+
+	          // emit pmt info
+	          self.trigger('trackinfo', {
+	            hasAudio: !!audioTrack,
+	            hasVideo: !!videoTrack
+	          });
+	        }
+	      });
+
+	      // Re-emit any data coming from the coalesce stream to the outside world
+	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+	      pipeline.coalesceStream.on('id3Frame', function (id3Frame) {
+	        id3Frame.dispatchType = pipeline.metadataStream.dispatchType;
+	        self.trigger('id3Frame', id3Frame);
+	      });
+	      pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption'));
+	      // Let the consumer know we have finished flushing the entire pipeline
+	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+	      addPipelineLogRetriggers(this, pipeline);
+	    };
+
+	    // hook up the segment streams once track metadata is delivered
+	    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+	      var pipeline = this.transmuxPipeline_;
+	      if (!options.keepOriginalTimestamps) {
+	        this.baseMediaDecodeTime = baseMediaDecodeTime;
+	      }
+	      if (audioTrack) {
+	        audioTrack.timelineStartInfo.dts = undefined;
+	        audioTrack.timelineStartInfo.pts = undefined;
+	        trackDecodeInfo.clearDtsInfo(audioTrack);
+	        if (pipeline.audioTimestampRolloverStream) {
+	          pipeline.audioTimestampRolloverStream.discontinuity();
+	        }
+	      }
+	      if (videoTrack) {
+	        if (pipeline.videoSegmentStream) {
+	          pipeline.videoSegmentStream.gopCache_ = [];
+	        }
+	        videoTrack.timelineStartInfo.dts = undefined;
+	        videoTrack.timelineStartInfo.pts = undefined;
+	        trackDecodeInfo.clearDtsInfo(videoTrack);
+	        pipeline.captionStream.reset();
+	      }
+	      if (pipeline.timestampRolloverStream) {
+	        pipeline.timestampRolloverStream.discontinuity();
+	      }
+	    };
+	    this.setAudioAppendStart = function (timestamp) {
+	      if (audioTrack) {
+	        this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);
+	      }
+	    };
+	    this.setRemux = function (val) {
+	      var pipeline = this.transmuxPipeline_;
+	      options.remux = val;
+	      if (pipeline && pipeline.coalesceStream) {
+	        pipeline.coalesceStream.setRemux(val);
+	      }
+	    };
+	    this.alignGopsWith = function (gopsToAlignWith) {
+	      if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {
+	        this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);
+	      }
+	    };
+	    this.getLogTrigger_ = function (key) {
+	      var self = this;
+	      return function (event) {
+	        event.stream = key;
+	        self.trigger('log', event);
+	      };
+	    };
+	    // feed incoming data to the front of the parsing pipeline
+	    this.push = function (data) {
+	      if (hasFlushed) {
+	        var isAac = isLikelyAacData(data);
+	        if (isAac && this.transmuxPipeline_.type !== 'aac') {
+	          this.setupAacPipeline();
+	        } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {
+	          this.setupTsPipeline();
+	        }
+	        hasFlushed = false;
+	      }
+	      this.transmuxPipeline_.headOfPipeline.push(data);
+	    };
+
+	    // flush any buffered data
+	    this.flush = function () {
+	      hasFlushed = true;
+	      // Start at the top of the pipeline and flush all pending work
+	      this.transmuxPipeline_.headOfPipeline.flush();
+	    };
+	    this.endTimeline = function () {
+	      this.transmuxPipeline_.headOfPipeline.endTimeline();
+	    };
+	    this.reset = function () {
+	      if (this.transmuxPipeline_.headOfPipeline) {
+	        this.transmuxPipeline_.headOfPipeline.reset();
+	      }
+	    };
+
+	    // Caption data has to be reset when seeking outside buffered range
+	    this.resetCaptions = function () {
+	      if (this.transmuxPipeline_.captionStream) {
+	        this.transmuxPipeline_.captionStream.reset();
+	      }
+	    };
+	  };
+	  _Transmuxer.prototype = new stream();
+	  var transmuxer = _Transmuxer;
+
+	  return transmuxer;
+
+	})); 
+} (mp4Transmuxer));
+
+var mp4TransmuxerExports = mp4Transmuxer.exports;
+var Transmuxer = /*@__PURE__*/getDefaultExportFromCjs(mp4TransmuxerExports);
+
 var aesJs = {exports: {}};
 
 /*! MIT License. Copyright 2015-2018 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */
@@ -884,7 +7324,23 @@ var aesJs = {exports: {}};
 var aesJsExports = aesJs.exports;
 var aesjs = /*@__PURE__*/getDefaultExportFromCjs(aesJsExports);
 
-var createFFmpeg = FFmpeg.createFFmpeg, fetchFile = FFmpeg.fetchFile;
+function fetchFile(url) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, arrayBuffer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch(url)];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    arrayBuffer = _a.sent();
+                    return [2 /*return*/, new Uint8Array(arrayBuffer)];
+            }
+        });
+    });
+}
+
 var TaskType;
 (function (TaskType) {
     TaskType[TaskType["loadFFmeg"] = 0] = "loadFFmeg";
@@ -903,11 +7359,11 @@ function parseUrl(url, path) {
 }
 var Hls2Mp4 = /** @class */ (function () {
     function Hls2Mp4(_a, onProgress) {
-        var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c, options = __rest(_a, ["maxRetry", "tsDownloadConcurrency"]);
+        var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c;
         this.loadRetryTime = 0;
         this.totalSegments = 0;
-        this.savedSegments = 0;
-        this.instance = createFFmpeg(options);
+        this.duration = 0;
+        this.savedSegments = new Map();
         this.maxRetry = maxRetry;
         this.onProgress = onProgress;
         this.tsDownloadConcurrency = tsDownloadConcurrency;
@@ -1013,7 +7469,7 @@ var Hls2Mp4 = /** @class */ (function () {
             var _this = this;
             return __generator(this, function (_a) {
                 return [2 /*return*/, Promise.all(segs.map(function (_a) {
-                        var name = _a.name, url = _a.url, source = _a.source;
+                        var index = _a.index, url = _a.url;
                         return __awaiter(_this, void 0, void 0, function () {
                             var tsData, buffer;
                             var _b;
@@ -1023,14 +7479,9 @@ var Hls2Mp4 = /** @class */ (function () {
                                     case 1:
                                         tsData = _c.sent();
                                         buffer = key ? this.aesDecrypt(tsData, key, iv) : this.transformBuffer(tsData);
-                                        this.instance.FS('writeFile', name, buffer);
-                                        this.savedSegments += 1;
-                                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments / this.totalSegments);
-                                        return [2 /*return*/, {
-                                                source: source,
-                                                url: url,
-                                                name: name
-                                            }];
+                                        this.savedSegments.set(index, buffer);
+                                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments.size / this.totalSegments);
+                                        return [2 /*return*/];
                                 }
                             });
                         });
@@ -1038,9 +7489,20 @@ var Hls2Mp4 = /** @class */ (function () {
             });
         });
     };
+    Hls2Mp4.prototype.computeTotalDuration = function (content) {
+        var duration = 0;
+        var tags = content.match(/#EXTINF:\d+(.\d+)?/gi);
+        tags === null || tags === void 0 ? void 0 : tags.forEach(function (tag) {
+            var dur = tag.match(/\d+(.\d+)?/);
+            if (dur) {
+                duration += Number(dur[0]);
+            }
+        });
+        return duration;
+    };
     Hls2Mp4.prototype.downloadM3u8 = function (url) {
         return __awaiter(this, void 0, void 0, function () {
-            var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1, m3u8;
+            var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1;
             var e_1, _b;
             return __generator(this, function (_c) {
                 switch (_c.label) {
@@ -1055,31 +7517,29 @@ var Hls2Mp4 = /** @class */ (function () {
                         if (!matches) {
                             throw new Error('Invalid m3u8 file, no ts file found');
                         }
+                        this.duration = this.computeTotalDuration(content);
                         segments = [];
-                        if (matches) {
-                            for (i = 0; i < matches.length; i++) {
-                                matched = matches[i];
-                                if (matched.match(/#EXT-X-KEY/)) {
-                                    matchedKey = matched.match(keyMatchRegExp);
-                                    matchedIV = matched.match(/(?<=IV=)\w+$/);
-                                    segments.push({
-                                        key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
-                                        iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
-                                        segments: []
-                                    });
-                                }
-                                else if (i === 0) {
-                                    segments.push({
-                                        segments: [matched]
-                                    });
-                                }
-                                else {
-                                    segments[segments.length - 1].segments.push(matched);
-                                }
+                        for (i = 0; i < matches.length; i++) {
+                            matched = matches[i];
+                            if (matched.match(/#EXT-X-KEY/)) {
+                                matchedKey = matched.match(keyMatchRegExp);
+                                matchedIV = matched.match(/(?<=IV=)\w+$/);
+                                segments.push({
+                                    key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
+                                    iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
+                                    segments: []
+                                });
+                            }
+                            else if (i === 0) {
+                                segments.push({
+                                    segments: [matched]
+                                });
+                            }
+                            else {
+                                segments[segments.length - 1].segments.push(matched);
                             }
                         }
                         this.totalSegments = segments.reduce(function (prev, current) { return prev + current.segments.length; }, 0);
-                        this.savedSegments = 0;
                         batch = this.tsDownloadConcurrency;
                         treatedSegments = 0;
                         _c.label = 2;
@@ -1100,34 +7560,17 @@ var Hls2Mp4 = /** @class */ (function () {
                         _c.label = 5;
                     case 5:
                         _loop_1 = function (i) {
-                            var downloadSegs, downloadSegs_1, downloadSegs_1_1, _d, source, name_1;
-                            var e_2, _e;
-                            return __generator(this, function (_f) {
-                                switch (_f.label) {
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
                                     case 0: return [4 /*yield*/, this_1.downloadSegments(group.segments.slice(i * batch, Math.min(total, (i + 1) * batch)).map(function (seg, j) {
                                             var url = parseUrl(parsedUrl, seg);
-                                            var name = "seg-".concat(treatedSegments + i * batch + j, ".ts");
                                             return {
-                                                source: seg,
-                                                url: url,
-                                                name: name
+                                                index: treatedSegments + i * batch + j,
+                                                url: url
                                             };
                                         }), keyBuffer, group.iv)];
                                     case 1:
-                                        downloadSegs = _f.sent();
-                                        try {
-                                            for (downloadSegs_1 = (e_2 = void 0, __values(downloadSegs)), downloadSegs_1_1 = downloadSegs_1.next(); !downloadSegs_1_1.done; downloadSegs_1_1 = downloadSegs_1.next()) {
-                                                _d = downloadSegs_1_1.value, source = _d.source, name_1 = _d.name;
-                                                content = content.replace(source, name_1);
-                                            }
-                                        }
-                                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                                        finally {
-                                            try {
-                                                if (downloadSegs_1_1 && !downloadSegs_1_1.done && (_e = downloadSegs_1.return)) _e.call(downloadSegs_1);
-                                            }
-                                            finally { if (e_2) throw e_2.error; }
-                                        }
+                                        _d.sent();
                                         return [2 /*return*/];
                                 }
                             });
@@ -1161,11 +7604,7 @@ var Hls2Mp4 = /** @class */ (function () {
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 14:
-                        content = content.replace(keyTagMatchRegExp, '');
-                        m3u8 = 'temp.m3u8';
-                        this.instance.FS('writeFile', m3u8, content);
-                        return [2 /*return*/, m3u8];
+                    case 14: return [2 /*return*/];
                 }
             });
         });
@@ -1200,49 +7639,100 @@ var Hls2Mp4 = /** @class */ (function () {
             });
         });
     };
-    Hls2Mp4.prototype.loadFFmpeg = function () {
+    Hls2Mp4.prototype.mergeDataArray = function (data) {
+        var e_2, _a;
+        var totalByteLength = data.reduce(function (prev, current) { return prev + current.byteLength; }, 0);
+        var dataArray = new Uint8Array(totalByteLength);
+        var byteOffset = 0;
+        try {
+            for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                var part = data_1_1.value;
+                dataArray.set(part, byteOffset);
+                byteOffset += part.byteLength;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return dataArray;
+    };
+    Hls2Mp4.prototype.transmuxerSegments = function () {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var done;
-            var _this = this;
+            var transmuxer, transmuxerFirstSegment, transmuxerSegment, chunks, i, segment, chunk, data;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.loadFFmeg, 0);
-                        return [4 /*yield*/, this.loopLoadFile(function () { return _this.instance.load(); })];
+                        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
+                        transmuxer = new Transmuxer({
+                            duration: this.duration
+                        });
+                        transmuxerFirstSegment = function (data) {
+                            return new Promise(function (resolve) {
+                                transmuxer.on('data', function (segment) {
+                                    var data = new Uint8Array(segment.initSegment.byteLength + segment.data.byteLength);
+                                    data.set(segment.initSegment, 0);
+                                    data.set(segment.data, segment.initSegment.byteLength);
+                                    resolve(data);
+                                });
+                                transmuxer.push(data);
+                                transmuxer.flush();
+                            });
+                        };
+                        transmuxerSegment = function (buffer) {
+                            return new Promise(function (resolve) {
+                                transmuxer.off('data');
+                                transmuxer.on('data', function (segment) { return resolve(segment.data); });
+                                transmuxer.push(buffer);
+                                transmuxer.flush();
+                            });
+                        };
+                        chunks = [];
+                        i = 0;
+                        _c.label = 1;
                     case 1:
-                        done = (_c.sent()).done;
-                        if (done) {
-                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.loadFFmeg, done ? 1 : -1);
-                        }
-                        else {
-                            throw new Error('FFmpeg load failed');
-                        }
-                        return [2 /*return*/];
+                        if (!(i < this.savedSegments.size)) return [3 /*break*/, 7];
+                        segment = this.savedSegments.get(i);
+                        chunk = void 0;
+                        if (!(i === 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, transmuxerFirstSegment(segment)];
+                    case 2:
+                        chunk = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, transmuxerSegment(segment)];
+                    case 4:
+                        chunk = _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        chunks.push(chunk);
+                        _c.label = 6;
+                    case 6:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 7:
+                        data = this.mergeDataArray(chunks);
+                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
+                        return [2 /*return*/, data];
                 }
             });
         });
     };
     Hls2Mp4.prototype.download = function (url) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var m3u8, data;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.loadFFmpeg()];
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.downloadM3u8(url)];
                     case 1:
-                        _c.sent();
-                        return [4 /*yield*/, this.downloadM3u8(url)];
+                        _a.sent();
+                        return [4 /*yield*/, this.transmuxerSegments()];
                     case 2:
-                        m3u8 = _c.sent();
-                        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
-                        return [4 /*yield*/, this.instance.run('-i', m3u8, '-c', 'copy', 'temp.mp4', '-loglevel', 'debug')];
-                    case 3:
-                        _c.sent();
-                        data = this.instance.FS('readFile', 'temp.mp4');
-                        this.instance.exit();
-                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
-                        return [2 /*return*/, data.buffer];
+                        data = _a.sent();
+                        return [2 /*return*/, data];
                 }
             });
         });
@@ -1255,7 +7745,7 @@ var Hls2Mp4 = /** @class */ (function () {
         anchor.click();
         setTimeout(function () { return URL.revokeObjectURL(objectUrl); }, 100);
     };
-    Hls2Mp4.version = '1.1.8';
+    Hls2Mp4.version = '2.0';
     Hls2Mp4.TaskType = TaskType;
     return Hls2Mp4;
 }());
diff --git a/dist/hls2mp4.js b/dist/hls2mp4.js
index 2903087..6e318a7 100644
--- a/dist/hls2mp4.js
+++ b/dist/hls2mp4.js
@@ -1,4 +1,4 @@
-var Hls2Mp4 = (function (FFmpeg) {
+var Hls2Mp4 = (function () {
     'use strict';
 
     /******************************************************************************
@@ -18,18 +18,6 @@ var Hls2Mp4 = (function (FFmpeg) {
     /* global Reflect, Promise */
 
 
-    function __rest(s, e) {
-        var t = {};
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-            t[p] = s[p];
-        if (s != null && typeof Object.getOwnPropertySymbols === "function")
-            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                    t[p[i]] = s[p[i]];
-            }
-        return t;
-    }
-
     function __awaiter(thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
         return new (P || (P = Promise))(function (resolve, reject) {
@@ -80,10 +68,6464 @@ var Hls2Mp4 = (function (FFmpeg) {
         throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
     }
 
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
     function getDefaultExportFromCjs (x) {
     	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
     }
 
+    var mp4Transmuxer = {exports: {}};
+
+    /*! @name mux.js @version 6.3.0 @license Apache-2.0 */
+
+    (function (module, exports) {
+    	(function (global, factory) {
+    	  module.exports = factory() ;
+    	})(commonjsGlobal, (function () {
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   *
+    	   * A lightweight readable stream implemention that handles event dispatching.
+    	   * Objects that inherit from streams should call init in their constructors.
+    	   */
+
+    	  var Stream = function Stream() {
+    	    this.init = function () {
+    	      var listeners = {};
+    	      /**
+    	       * Add a listener for a specified event type.
+    	       * @param type {string} the event name
+    	       * @param listener {function} the callback to be invoked when an event of
+    	       * the specified type occurs
+    	       */
+    	      this.on = function (type, listener) {
+    	        if (!listeners[type]) {
+    	          listeners[type] = [];
+    	        }
+    	        listeners[type] = listeners[type].concat(listener);
+    	      };
+    	      /**
+    	       * Remove a listener for a specified event type.
+    	       * @param type {string} the event name
+    	       * @param listener {function} a function previously registered for this
+    	       * type of event through `on`
+    	       */
+    	      this.off = function (type, listener) {
+    	        var index;
+    	        if (!listeners[type]) {
+    	          return false;
+    	        }
+    	        index = listeners[type].indexOf(listener);
+    	        listeners[type] = listeners[type].slice();
+    	        listeners[type].splice(index, 1);
+    	        return index > -1;
+    	      };
+    	      /**
+    	       * Trigger an event of the specified type on this stream. Any additional
+    	       * arguments to this function are passed as parameters to event listeners.
+    	       * @param type {string} the event name
+    	       */
+    	      this.trigger = function (type) {
+    	        var callbacks, i, length, args;
+    	        callbacks = listeners[type];
+    	        if (!callbacks) {
+    	          return;
+    	        }
+    	        // Slicing the arguments on every invocation of this method
+    	        // can add a significant amount of overhead. Avoid the
+    	        // intermediate object creation for the common case of a
+    	        // single callback argument
+    	        if (arguments.length === 2) {
+    	          length = callbacks.length;
+    	          for (i = 0; i < length; ++i) {
+    	            callbacks[i].call(this, arguments[1]);
+    	          }
+    	        } else {
+    	          args = [];
+    	          i = arguments.length;
+    	          for (i = 1; i < arguments.length; ++i) {
+    	            args.push(arguments[i]);
+    	          }
+    	          length = callbacks.length;
+    	          for (i = 0; i < length; ++i) {
+    	            callbacks[i].apply(this, args);
+    	          }
+    	        }
+    	      };
+    	      /**
+    	       * Destroys the stream and cleans up.
+    	       */
+    	      this.dispose = function () {
+    	        listeners = {};
+    	      };
+    	    };
+    	  };
+
+    	  /**
+    	   * Forwards all `data` events on this stream to the destination stream. The
+    	   * destination stream should provide a method `push` to receive the data
+    	   * events as they arrive.
+    	   * @param destination {stream} the stream that will receive all `data` events
+    	   * @param autoFlush {boolean} if false, we will not call `flush` on the destination
+    	   *                            when the current stream emits a 'done' event
+    	   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
+    	   */
+    	  Stream.prototype.pipe = function (destination) {
+    	    this.on('data', function (data) {
+    	      destination.push(data);
+    	    });
+    	    this.on('done', function (flushSource) {
+    	      destination.flush(flushSource);
+    	    });
+    	    this.on('partialdone', function (flushSource) {
+    	      destination.partialFlush(flushSource);
+    	    });
+    	    this.on('endedtimeline', function (flushSource) {
+    	      destination.endTimeline(flushSource);
+    	    });
+    	    this.on('reset', function (flushSource) {
+    	      destination.reset(flushSource);
+    	    });
+    	    return destination;
+    	  };
+
+    	  // Default stream functions that are expected to be overridden to perform
+    	  // actual work. These are provided by the prototype as a sort of no-op
+    	  // implementation so that we don't have to check for their existence in the
+    	  // `pipe` function above.
+    	  Stream.prototype.push = function (data) {
+    	    this.trigger('data', data);
+    	  };
+    	  Stream.prototype.flush = function (flushSource) {
+    	    this.trigger('done', flushSource);
+    	  };
+    	  Stream.prototype.partialFlush = function (flushSource) {
+    	    this.trigger('partialdone', flushSource);
+    	  };
+    	  Stream.prototype.endTimeline = function (flushSource) {
+    	    this.trigger('endedtimeline', flushSource);
+    	  };
+    	  Stream.prototype.reset = function (flushSource) {
+    	    this.trigger('reset', flushSource);
+    	  };
+    	  var stream = Stream;
+
+    	  var MAX_UINT32$1 = Math.pow(2, 32);
+    	  var getUint64 = function getUint64(uint8) {
+    	    var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+    	    var value;
+    	    if (dv.getBigUint64) {
+    	      value = dv.getBigUint64(0);
+    	      if (value < Number.MAX_SAFE_INTEGER) {
+    	        return Number(value);
+    	      }
+    	      return value;
+    	    }
+    	    return dv.getUint32(0) * MAX_UINT32$1 + dv.getUint32(4);
+    	  };
+    	  var numbers = {
+    	    getUint64: getUint64,
+    	    MAX_UINT32: MAX_UINT32$1
+    	  };
+
+    	  var MAX_UINT32 = numbers.MAX_UINT32;
+    	  var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS;
+
+    	  // pre-calculate constants
+    	  (function () {
+    	    var i;
+    	    types = {
+    	      avc1: [],
+    	      // codingname
+    	      avcC: [],
+    	      btrt: [],
+    	      dinf: [],
+    	      dref: [],
+    	      esds: [],
+    	      ftyp: [],
+    	      hdlr: [],
+    	      mdat: [],
+    	      mdhd: [],
+    	      mdia: [],
+    	      mfhd: [],
+    	      minf: [],
+    	      moof: [],
+    	      moov: [],
+    	      mp4a: [],
+    	      // codingname
+    	      mvex: [],
+    	      mvhd: [],
+    	      pasp: [],
+    	      sdtp: [],
+    	      smhd: [],
+    	      stbl: [],
+    	      stco: [],
+    	      stsc: [],
+    	      stsd: [],
+    	      stsz: [],
+    	      stts: [],
+    	      styp: [],
+    	      tfdt: [],
+    	      tfhd: [],
+    	      traf: [],
+    	      trak: [],
+    	      trun: [],
+    	      trex: [],
+    	      tkhd: [],
+    	      vmhd: []
+    	    };
+
+    	    // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we
+    	    // don't throw an error
+    	    if (typeof Uint8Array === 'undefined') {
+    	      return;
+    	    }
+    	    for (i in types) {
+    	      if (types.hasOwnProperty(i)) {
+    	        types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
+    	      }
+    	    }
+    	    MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);
+    	    AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);
+    	    MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);
+    	    VIDEO_HDLR = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // pre_defined
+    	    0x76, 0x69, 0x64, 0x65,
+    	    // handler_type: 'vide'
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
+    	    ]);
+
+    	    AUDIO_HDLR = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // pre_defined
+    	    0x73, 0x6f, 0x75, 0x6e,
+    	    // handler_type: 'soun'
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
+    	    ]);
+
+    	    HDLR_TYPES = {
+    	      video: VIDEO_HDLR,
+    	      audio: AUDIO_HDLR
+    	    };
+    	    DREF = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // entry_count
+    	    0x00, 0x00, 0x00, 0x0c,
+    	    // entry_size
+    	    0x75, 0x72, 0x6c, 0x20,
+    	    // 'url' type
+    	    0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x01 // entry_flags
+    	    ]);
+
+    	    SMHD = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00,
+    	    // balance, 0 means centered
+    	    0x00, 0x00 // reserved
+    	    ]);
+
+    	    STCO = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00 // entry_count
+    	    ]);
+
+    	    STSC = STCO;
+    	    STSZ = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // sample_size
+    	    0x00, 0x00, 0x00, 0x00 // sample_count
+    	    ]);
+
+    	    STTS = STCO;
+    	    VMHD = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x01,
+    	    // flags
+    	    0x00, 0x00,
+    	    // graphicsmode
+    	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
+    	    ]);
+    	  })();
+
+    	  box = function box(type) {
+    	    var payload = [],
+    	      size = 0,
+    	      i,
+    	      result,
+    	      view;
+    	    for (i = 1; i < arguments.length; i++) {
+    	      payload.push(arguments[i]);
+    	    }
+    	    i = payload.length;
+
+    	    // calculate the total size we need to allocate
+    	    while (i--) {
+    	      size += payload[i].byteLength;
+    	    }
+    	    result = new Uint8Array(size + 8);
+    	    view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+    	    view.setUint32(0, result.byteLength);
+    	    result.set(type, 4);
+
+    	    // copy the payload into the result
+    	    for (i = 0, size = 8; i < payload.length; i++) {
+    	      result.set(payload[i], size);
+    	      size += payload[i].byteLength;
+    	    }
+    	    return result;
+    	  };
+    	  dinf = function dinf() {
+    	    return box(types.dinf, box(types.dref, DREF));
+    	  };
+    	  esds = function esds(track) {
+    	    return box(types.esds, new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+
+    	    // ES_Descriptor
+    	    0x03,
+    	    // tag, ES_DescrTag
+    	    0x19,
+    	    // length
+    	    0x00, 0x00,
+    	    // ES_ID
+    	    0x00,
+    	    // streamDependenceFlag, URL_flag, reserved, streamPriority
+
+    	    // DecoderConfigDescriptor
+    	    0x04,
+    	    // tag, DecoderConfigDescrTag
+    	    0x11,
+    	    // length
+    	    0x40,
+    	    // object type
+    	    0x15,
+    	    // streamType
+    	    0x00, 0x06, 0x00,
+    	    // bufferSizeDB
+    	    0x00, 0x00, 0xda, 0xc0,
+    	    // maxBitrate
+    	    0x00, 0x00, 0xda, 0xc0,
+    	    // avgBitrate
+
+    	    // DecoderSpecificInfo
+    	    0x05,
+    	    // tag, DecoderSpecificInfoTag
+    	    0x02,
+    	    // length
+    	    // ISO/IEC 14496-3, AudioSpecificConfig
+    	    // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
+    	    track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig
+    	    ]));
+    	  };
+
+    	  ftyp = function ftyp() {
+    	    return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);
+    	  };
+    	  hdlr = function hdlr(type) {
+    	    return box(types.hdlr, HDLR_TYPES[type]);
+    	  };
+    	  mdat = function mdat(data) {
+    	    return box(types.mdat, data);
+    	  };
+    	  mdhd = function mdhd(track) {
+    	    var result = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x02,
+    	    // creation_time
+    	    0x00, 0x00, 0x00, 0x03,
+    	    // modification_time
+    	    0x00, 0x01, 0x5f, 0x90,
+    	    // timescale, 90,000 "ticks" per second
+
+    	    track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF,
+    	    // duration
+    	    0x55, 0xc4,
+    	    // 'und' language (undetermined)
+    	    0x00, 0x00]);
+
+    	    // Use the sample rate from the track metadata, when it is
+    	    // defined. The sample rate can be parsed out of an ADTS header, for
+    	    // instance.
+    	    if (track.samplerate) {
+    	      result[12] = track.samplerate >>> 24 & 0xFF;
+    	      result[13] = track.samplerate >>> 16 & 0xFF;
+    	      result[14] = track.samplerate >>> 8 & 0xFF;
+    	      result[15] = track.samplerate & 0xFF;
+    	    }
+    	    return box(types.mdhd, result);
+    	  };
+    	  mdia = function mdia(track) {
+    	    return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));
+    	  };
+    	  mfhd = function mfhd(sequenceNumber) {
+    	    return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
+    	    // flags
+    	    (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number
+    	    ]));
+    	  };
+
+    	  minf = function minf(track) {
+    	    return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));
+    	  };
+    	  moof = function moof(sequenceNumber, tracks) {
+    	    var trackFragments = [],
+    	      i = tracks.length;
+    	    // build traf boxes for each track fragment
+    	    while (i--) {
+    	      trackFragments[i] = traf(tracks[i]);
+    	    }
+    	    return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));
+    	  };
+    	  /**
+    	   * Returns a movie box.
+    	   * @param tracks {array} the tracks associated with this movie
+    	   * @see ISO/IEC 14496-12:2012(E), section 8.2.1
+    	   */
+    	  moov = function moov(tracks, duration) {
+    	    var i = tracks.length,
+    	      boxes = [];
+    	    while (i--) {
+    	      boxes[i] = trak(tracks[i]);
+    	    }
+    	    return box.apply(null, [types.moov, mvhd(duration || 0xffffffff)].concat(boxes).concat(mvex(tracks)));
+    	  };
+    	  mvex = function mvex(tracks) {
+    	    var i = tracks.length,
+    	      boxes = [];
+    	    while (i--) {
+    	      boxes[i] = trex(tracks[i]);
+    	    }
+    	    return box.apply(null, [types.mvex].concat(boxes));
+    	  };
+    	  mvhd = function mvhd(duration) {
+    	    var bytes = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // creation_time
+    	    0x00, 0x00, 0x00, 0x02,
+    	    // modification_time
+    	    0x00, 0x01, 0x5f, 0x90,
+    	    // timescale, 90,000 "ticks" per second
+    	    (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF,
+    	    // duration
+    	    0x00, 0x01, 0x00, 0x00,
+    	    // 1.0 rate
+    	    0x01, 0x00,
+    	    // 1.0 volume
+    	    0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    	    // transformation: unity matrix
+    	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	    // pre_defined
+    	    0xff, 0xff, 0xff, 0xff // next_track_ID
+    	    ]);
+
+    	    return box(types.mvhd, bytes);
+    	  };
+    	  sdtp = function sdtp(track) {
+    	    var samples = track.samples || [],
+    	      bytes = new Uint8Array(4 + samples.length),
+    	      flags,
+    	      i;
+
+    	    // leave the full box header (4 bytes) all zero
+
+    	    // write the sample table
+    	    for (i = 0; i < samples.length; i++) {
+    	      flags = samples[i].flags;
+    	      bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
+    	    }
+    	    return box(types.sdtp, bytes);
+    	  };
+    	  stbl = function stbl(track) {
+    	    return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));
+    	  };
+    	  (function () {
+    	    var videoSample, audioSample;
+    	    stsd = function stsd(track) {
+    	      return box(types.stsd, new Uint8Array([0x00,
+    	      // version 0
+    	      0x00, 0x00, 0x00,
+    	      // flags
+    	      0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));
+    	    };
+    	    videoSample = function videoSample(track) {
+    	      var sps = track.sps || [],
+    	        pps = track.pps || [],
+    	        sequenceParameterSets = [],
+    	        pictureParameterSets = [],
+    	        i,
+    	        avc1Box;
+
+    	      // assemble the SPSs
+    	      for (i = 0; i < sps.length; i++) {
+    	        sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);
+    	        sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength
+    	        sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS
+    	      }
+
+    	      // assemble the PPSs
+    	      for (i = 0; i < pps.length; i++) {
+    	        pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);
+    	        pictureParameterSets.push(pps[i].byteLength & 0xFF);
+    	        pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));
+    	      }
+    	      avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x01,
+    	      // data_reference_index
+    	      0x00, 0x00,
+    	      // pre_defined
+    	      0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // pre_defined
+    	      (track.width & 0xff00) >> 8, track.width & 0xff,
+    	      // width
+    	      (track.height & 0xff00) >> 8, track.height & 0xff,
+    	      // height
+    	      0x00, 0x48, 0x00, 0x00,
+    	      // horizresolution
+    	      0x00, 0x48, 0x00, 0x00,
+    	      // vertresolution
+    	      0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x01,
+    	      // frame_count
+    	      0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // compressorname
+    	      0x00, 0x18,
+    	      // depth = 24
+    	      0x11, 0x11 // pre_defined = -1
+    	      ]), box(types.avcC, new Uint8Array([0x01,
+    	      // configurationVersion
+    	      track.profileIdc,
+    	      // AVCProfileIndication
+    	      track.profileCompatibility,
+    	      // profile_compatibility
+    	      track.levelIdc,
+    	      // AVCLevelIndication
+    	      0xff // lengthSizeMinusOne, hard-coded to 4 bytes
+    	      ].concat([sps.length],
+    	      // numOfSequenceParameterSets
+    	      sequenceParameterSets,
+    	      // "SPS"
+    	      [pps.length],
+    	      // numOfPictureParameterSets
+    	      pictureParameterSets // "PPS"
+    	      ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
+    	      // bufferSizeDB
+    	      0x00, 0x2d, 0xc6, 0xc0,
+    	      // maxBitrate
+    	      0x00, 0x2d, 0xc6, 0xc0 // avgBitrate
+    	      ]))];
+
+    	      if (track.sarRatio) {
+    	        var hSpacing = track.sarRatio[0],
+    	          vSpacing = track.sarRatio[1];
+    	        avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));
+    	      }
+    	      return box.apply(null, avc1Box);
+    	    };
+    	    audioSample = function audioSample(track) {
+    	      return box(types.mp4a, new Uint8Array([
+    	      // SampleEntry, ISO/IEC 14496-12
+    	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x01,
+    	      // data_reference_index
+
+    	      // AudioSampleEntry, ISO/IEC 14496-12
+    	      0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff,
+    	      // channelcount
+
+    	      (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff,
+    	      // samplesize
+    	      0x00, 0x00,
+    	      // pre_defined
+    	      0x00, 0x00,
+    	      // reserved
+
+    	      (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16
+
+    	      // MP4AudioSampleEntry, ISO/IEC 14496-14
+    	      ]), esds(track));
+    	    };
+    	  })();
+    	  tkhd = function tkhd(track) {
+    	    var result = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x07,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // creation_time
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // modification_time
+    	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    	    // track_ID
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF,
+    	    // duration
+    	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00,
+    	    // layer
+    	    0x00, 0x00,
+    	    // alternate_group
+    	    0x01, 0x00,
+    	    // non-audio track volume
+    	    0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    	    // transformation: unity matrix
+    	    (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00,
+    	    // width
+    	    (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height
+    	    ]);
+
+    	    return box(types.tkhd, result);
+    	  };
+
+    	  /**
+    	   * Generate a track fragment (traf) box. A traf box collects metadata
+    	   * about tracks in a movie fragment (moof) box.
+    	   */
+    	  traf = function traf(track) {
+    	    var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;
+    	    trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x3a,
+    	    // flags
+    	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    	    // track_ID
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // sample_description_index
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_duration
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_size
+    	    0x00, 0x00, 0x00, 0x00 // default_sample_flags
+    	    ]));
+
+    	    upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / MAX_UINT32);
+    	    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % MAX_UINT32);
+    	    trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01,
+    	    // version 1
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    // baseMediaDecodeTime
+    	    upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF]));
+
+    	    // the data offset specifies the number of bytes from the start of
+    	    // the containing moof to the first payload byte of the associated
+    	    // mdat
+    	    dataOffset = 32 +
+    	    // tfhd
+    	    20 +
+    	    // tfdt
+    	    8 +
+    	    // traf header
+    	    16 +
+    	    // mfhd
+    	    8 +
+    	    // moof header
+    	    8; // mdat header
+
+    	    // audio tracks require less metadata
+    	    if (track.type === 'audio') {
+    	      trackFragmentRun = trun(track, dataOffset);
+    	      return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);
+    	    }
+
+    	    // video tracks should contain an independent and disposable samples
+    	    // box (sdtp)
+    	    // generate one and adjust offsets to match
+    	    sampleDependencyTable = sdtp(track);
+    	    trackFragmentRun = trun(track, sampleDependencyTable.length + dataOffset);
+    	    return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);
+    	  };
+
+    	  /**
+    	   * Generate a track box.
+    	   * @param track {object} a track definition
+    	   * @return {Uint8Array} the track box
+    	   */
+    	  trak = function trak(track) {
+    	    track.duration = track.duration || 0xffffffff;
+    	    return box(types.trak, tkhd(track), mdia(track));
+    	  };
+    	  trex = function trex(track) {
+    	    var result = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    	    // track_ID
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // default_sample_description_index
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_duration
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_size
+    	    0x00, 0x01, 0x00, 0x01 // default_sample_flags
+    	    ]);
+    	    // the last two bytes of default_sample_flags is the sample
+    	    // degradation priority, a hint about the importance of this sample
+    	    // relative to others. Lower the degradation priority for all sample
+    	    // types other than video.
+    	    if (track.type !== 'video') {
+    	      result[result.length - 1] = 0x00;
+    	    }
+    	    return box(types.trex, result);
+    	  };
+    	  (function () {
+    	    var audioTrun, videoTrun, trunHeader;
+
+    	    // This method assumes all samples are uniform. That is, if a
+    	    // duration is present for the first sample, it will be present for
+    	    // all subsequent samples.
+    	    // see ISO/IEC 14496-12:2012, Section 8.8.8.1
+    	    trunHeader = function trunHeader(samples, offset) {
+    	      var durationPresent = 0,
+    	        sizePresent = 0,
+    	        flagsPresent = 0,
+    	        compositionTimeOffset = 0;
+
+    	      // trun flag constants
+    	      if (samples.length) {
+    	        if (samples[0].duration !== undefined) {
+    	          durationPresent = 0x1;
+    	        }
+    	        if (samples[0].size !== undefined) {
+    	          sizePresent = 0x2;
+    	        }
+    	        if (samples[0].flags !== undefined) {
+    	          flagsPresent = 0x4;
+    	        }
+    	        if (samples[0].compositionTimeOffset !== undefined) {
+    	          compositionTimeOffset = 0x8;
+    	        }
+    	      }
+    	      return [0x00,
+    	      // version 0
+    	      0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01,
+    	      // flags
+    	      (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF,
+    	      // sample_count
+    	      (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset
+    	      ];
+    	    };
+
+    	    videoTrun = function videoTrun(track, offset) {
+    	      var bytesOffest, bytes, header, samples, sample, i;
+    	      samples = track.samples || [];
+    	      offset += 8 + 12 + 16 * samples.length;
+    	      header = trunHeader(samples, offset);
+    	      bytes = new Uint8Array(header.length + samples.length * 16);
+    	      bytes.set(header);
+    	      bytesOffest = header.length;
+    	      for (i = 0; i < samples.length; i++) {
+    	        sample = samples[i];
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+    	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+    	        bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;
+    	        bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;
+    	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;
+    	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags
+    	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset
+    	      }
+
+    	      return box(types.trun, bytes);
+    	    };
+    	    audioTrun = function audioTrun(track, offset) {
+    	      var bytes, bytesOffest, header, samples, sample, i;
+    	      samples = track.samples || [];
+    	      offset += 8 + 12 + 8 * samples.length;
+    	      header = trunHeader(samples, offset);
+    	      bytes = new Uint8Array(header.length + samples.length * 8);
+    	      bytes.set(header);
+    	      bytesOffest = header.length;
+    	      for (i = 0; i < samples.length; i++) {
+    	        sample = samples[i];
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+    	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+    	      }
+
+    	      return box(types.trun, bytes);
+    	    };
+    	    trun = function trun(track, offset) {
+    	      if (track.type === 'audio') {
+    	        return audioTrun(track, offset);
+    	      }
+    	      return videoTrun(track, offset);
+    	    };
+    	  })();
+    	  var mp4Generator = {
+    	    ftyp: ftyp,
+    	    mdat: mdat,
+    	    moof: moof,
+    	    moov: moov,
+    	    initSegment: function initSegment(tracks) {
+    	      var duration = tracks.reduce(function (p, n) {
+    	        return p + n.duration;
+    	      }, 0);
+    	      var fileType = ftyp(),
+    	        movie = moov(tracks, duration),
+    	        result;
+    	      result = new Uint8Array(fileType.byteLength + movie.byteLength);
+    	      result.set(fileType);
+    	      result.set(movie, fileType.byteLength);
+    	      return result;
+    	    }
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  // Convert an array of nal units into an array of frames with each frame being
+    	  // composed of the nal units that make up that frame
+    	  // Also keep track of cummulative data about the frame from the nal units such
+    	  // as the frame duration, starting pts, etc.
+    	  var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {
+    	    var i,
+    	      currentNal,
+    	      currentFrame = [],
+    	      frames = [];
+
+    	    // TODO added for LHLS, make sure this is OK
+    	    frames.byteLength = 0;
+    	    frames.nalCount = 0;
+    	    frames.duration = 0;
+    	    currentFrame.byteLength = 0;
+    	    for (i = 0; i < nalUnits.length; i++) {
+    	      currentNal = nalUnits[i];
+
+    	      // Split on 'aud'-type nal units
+    	      if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
+    	        // Since the very first nal unit is expected to be an AUD
+    	        // only push to the frames array when currentFrame is not empty
+    	        if (currentFrame.length) {
+    	          currentFrame.duration = currentNal.dts - currentFrame.dts;
+    	          // TODO added for LHLS, make sure this is OK
+    	          frames.byteLength += currentFrame.byteLength;
+    	          frames.nalCount += currentFrame.length;
+    	          frames.duration += currentFrame.duration;
+    	          frames.push(currentFrame);
+    	        }
+    	        currentFrame = [currentNal];
+    	        currentFrame.byteLength = currentNal.data.byteLength;
+    	        currentFrame.pts = currentNal.pts;
+    	        currentFrame.dts = currentNal.dts;
+    	      } else {
+    	        // Specifically flag key frames for ease of use later
+    	        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
+    	          currentFrame.keyFrame = true;
+    	        }
+    	        currentFrame.duration = currentNal.dts - currentFrame.dts;
+    	        currentFrame.byteLength += currentNal.data.byteLength;
+    	        currentFrame.push(currentNal);
+    	      }
+    	    }
+
+    	    // For the last frame, use the duration of the previous frame if we
+    	    // have nothing better to go on
+    	    if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {
+    	      currentFrame.duration = frames[frames.length - 1].duration;
+    	    }
+
+    	    // Push the final frame
+    	    // TODO added for LHLS, make sure this is OK
+    	    frames.byteLength += currentFrame.byteLength;
+    	    frames.nalCount += currentFrame.length;
+    	    frames.duration += currentFrame.duration;
+    	    frames.push(currentFrame);
+    	    return frames;
+    	  };
+
+    	  // Convert an array of frames into an array of Gop with each Gop being composed
+    	  // of the frames that make up that Gop
+    	  // Also keep track of cummulative data about the Gop from the frames such as the
+    	  // Gop duration, starting pts, etc.
+    	  var groupFramesIntoGops = function groupFramesIntoGops(frames) {
+    	    var i,
+    	      currentFrame,
+    	      currentGop = [],
+    	      gops = [];
+
+    	    // We must pre-set some of the values on the Gop since we
+    	    // keep running totals of these values
+    	    currentGop.byteLength = 0;
+    	    currentGop.nalCount = 0;
+    	    currentGop.duration = 0;
+    	    currentGop.pts = frames[0].pts;
+    	    currentGop.dts = frames[0].dts;
+
+    	    // store some metadata about all the Gops
+    	    gops.byteLength = 0;
+    	    gops.nalCount = 0;
+    	    gops.duration = 0;
+    	    gops.pts = frames[0].pts;
+    	    gops.dts = frames[0].dts;
+    	    for (i = 0; i < frames.length; i++) {
+    	      currentFrame = frames[i];
+    	      if (currentFrame.keyFrame) {
+    	        // Since the very first frame is expected to be an keyframe
+    	        // only push to the gops array when currentGop is not empty
+    	        if (currentGop.length) {
+    	          gops.push(currentGop);
+    	          gops.byteLength += currentGop.byteLength;
+    	          gops.nalCount += currentGop.nalCount;
+    	          gops.duration += currentGop.duration;
+    	        }
+    	        currentGop = [currentFrame];
+    	        currentGop.nalCount = currentFrame.length;
+    	        currentGop.byteLength = currentFrame.byteLength;
+    	        currentGop.pts = currentFrame.pts;
+    	        currentGop.dts = currentFrame.dts;
+    	        currentGop.duration = currentFrame.duration;
+    	      } else {
+    	        currentGop.duration += currentFrame.duration;
+    	        currentGop.nalCount += currentFrame.length;
+    	        currentGop.byteLength += currentFrame.byteLength;
+    	        currentGop.push(currentFrame);
+    	      }
+    	    }
+    	    if (gops.length && currentGop.duration <= 0) {
+    	      currentGop.duration = gops[gops.length - 1].duration;
+    	    }
+    	    gops.byteLength += currentGop.byteLength;
+    	    gops.nalCount += currentGop.nalCount;
+    	    gops.duration += currentGop.duration;
+
+    	    // push the final Gop
+    	    gops.push(currentGop);
+    	    return gops;
+    	  };
+
+    	  /*
+    	   * Search for the first keyframe in the GOPs and throw away all frames
+    	   * until that keyframe. Then extend the duration of the pulled keyframe
+    	   * and pull the PTS and DTS of the keyframe so that it covers the time
+    	   * range of the frames that were disposed.
+    	   *
+    	   * @param {Array} gops video GOPs
+    	   * @returns {Array} modified video GOPs
+    	   */
+    	  var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {
+    	    var currentGop;
+    	    if (!gops[0][0].keyFrame && gops.length > 1) {
+    	      // Remove the first GOP
+    	      currentGop = gops.shift();
+    	      gops.byteLength -= currentGop.byteLength;
+    	      gops.nalCount -= currentGop.nalCount;
+
+    	      // Extend the first frame of what is now the
+    	      // first gop to cover the time period of the
+    	      // frames we just removed
+    	      gops[0][0].dts = currentGop.dts;
+    	      gops[0][0].pts = currentGop.pts;
+    	      gops[0][0].duration += currentGop.duration;
+    	    }
+    	    return gops;
+    	  };
+
+    	  /**
+    	   * Default sample object
+    	   * see ISO/IEC 14496-12:2012, section 8.6.4.3
+    	   */
+    	  var createDefaultSample = function createDefaultSample() {
+    	    return {
+    	      size: 0,
+    	      flags: {
+    	        isLeading: 0,
+    	        dependsOn: 1,
+    	        isDependedOn: 0,
+    	        hasRedundancy: 0,
+    	        degradationPriority: 0,
+    	        isNonSyncSample: 1
+    	      }
+    	    };
+    	  };
+
+    	  /*
+    	   * Collates information from a video frame into an object for eventual
+    	   * entry into an MP4 sample table.
+    	   *
+    	   * @param {Object} frame the video frame
+    	   * @param {Number} dataOffset the byte offset to position the sample
+    	   * @return {Object} object containing sample table info for a frame
+    	   */
+    	  var sampleForFrame = function sampleForFrame(frame, dataOffset) {
+    	    var sample = createDefaultSample();
+    	    sample.dataOffset = dataOffset;
+    	    sample.compositionTimeOffset = frame.pts - frame.dts;
+    	    sample.duration = frame.duration;
+    	    sample.size = 4 * frame.length; // Space for nal unit size
+    	    sample.size += frame.byteLength;
+    	    if (frame.keyFrame) {
+    	      sample.flags.dependsOn = 2;
+    	      sample.flags.isNonSyncSample = 0;
+    	    }
+    	    return sample;
+    	  };
+
+    	  // generate the track's sample table from an array of gops
+    	  var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {
+    	    var h,
+    	      i,
+    	      sample,
+    	      currentGop,
+    	      currentFrame,
+    	      dataOffset = baseDataOffset || 0,
+    	      samples = [];
+    	    for (h = 0; h < gops.length; h++) {
+    	      currentGop = gops[h];
+    	      for (i = 0; i < currentGop.length; i++) {
+    	        currentFrame = currentGop[i];
+    	        sample = sampleForFrame(currentFrame, dataOffset);
+    	        dataOffset += sample.size;
+    	        samples.push(sample);
+    	      }
+    	    }
+    	    return samples;
+    	  };
+
+    	  // generate the track's raw mdat data from an array of gops
+    	  var concatenateNalData = function concatenateNalData(gops) {
+    	    var h,
+    	      i,
+    	      j,
+    	      currentGop,
+    	      currentFrame,
+    	      currentNal,
+    	      dataOffset = 0,
+    	      nalsByteLength = gops.byteLength,
+    	      numberOfNals = gops.nalCount,
+    	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+    	      data = new Uint8Array(totalByteLength),
+    	      view = new DataView(data.buffer);
+
+    	    // For each Gop..
+    	    for (h = 0; h < gops.length; h++) {
+    	      currentGop = gops[h];
+
+    	      // For each Frame..
+    	      for (i = 0; i < currentGop.length; i++) {
+    	        currentFrame = currentGop[i];
+
+    	        // For each NAL..
+    	        for (j = 0; j < currentFrame.length; j++) {
+    	          currentNal = currentFrame[j];
+    	          view.setUint32(dataOffset, currentNal.data.byteLength);
+    	          dataOffset += 4;
+    	          data.set(currentNal.data, dataOffset);
+    	          dataOffset += currentNal.data.byteLength;
+    	        }
+    	      }
+    	    }
+    	    return data;
+    	  };
+
+    	  // generate the track's sample table from a frame
+    	  var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {
+    	    var sample,
+    	      dataOffset = baseDataOffset || 0,
+    	      samples = [];
+    	    sample = sampleForFrame(frame, dataOffset);
+    	    samples.push(sample);
+    	    return samples;
+    	  };
+
+    	  // generate the track's raw mdat data from a frame
+    	  var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {
+    	    var i,
+    	      currentNal,
+    	      dataOffset = 0,
+    	      nalsByteLength = frame.byteLength,
+    	      numberOfNals = frame.length,
+    	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+    	      data = new Uint8Array(totalByteLength),
+    	      view = new DataView(data.buffer);
+
+    	    // For each NAL..
+    	    for (i = 0; i < frame.length; i++) {
+    	      currentNal = frame[i];
+    	      view.setUint32(dataOffset, currentNal.data.byteLength);
+    	      dataOffset += 4;
+    	      data.set(currentNal.data, dataOffset);
+    	      dataOffset += currentNal.data.byteLength;
+    	    }
+    	    return data;
+    	  };
+    	  var frameUtils = {
+    	    groupNalsIntoFrames: groupNalsIntoFrames,
+    	    groupFramesIntoGops: groupFramesIntoGops,
+    	    extendFirstKeyFrame: extendFirstKeyFrame,
+    	    generateSampleTable: generateSampleTable$1,
+    	    concatenateNalData: concatenateNalData,
+    	    generateSampleTableForFrame: generateSampleTableForFrame,
+    	    concatenateNalDataForFrame: concatenateNalDataForFrame
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  var highPrefix = [33, 16, 5, 32, 164, 27];
+    	  var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];
+    	  var zeroFill = function zeroFill(count) {
+    	    var a = [];
+    	    while (count--) {
+    	      a.push(0);
+    	    }
+    	    return a;
+    	  };
+    	  var makeTable = function makeTable(metaTable) {
+    	    return Object.keys(metaTable).reduce(function (obj, key) {
+    	      obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {
+    	        return arr.concat(part);
+    	      }, []));
+    	      return obj;
+    	    }, {});
+    	  };
+    	  var silence;
+    	  var silence_1 = function silence_1() {
+    	    if (!silence) {
+    	      // Frames-of-silence to use for filling in missing AAC frames
+    	      var coneOfSilence = {
+    	        96000: [highPrefix, [227, 64], zeroFill(154), [56]],
+    	        88200: [highPrefix, [231], zeroFill(170), [56]],
+    	        64000: [highPrefix, [248, 192], zeroFill(240), [56]],
+    	        48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],
+    	        44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],
+    	        32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],
+    	        24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],
+    	        16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],
+    	        12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],
+    	        11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],
+    	        8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]
+    	      };
+    	      silence = makeTable(coneOfSilence);
+    	    }
+    	    return silence;
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  var ONE_SECOND_IN_TS$3 = 90000,
+    	    // 90kHz clock
+    	    secondsToVideoTs,
+    	    secondsToAudioTs,
+    	    videoTsToSeconds,
+    	    audioTsToSeconds,
+    	    audioTsToVideoTs,
+    	    videoTsToAudioTs,
+    	    metadataTsToSeconds;
+    	  secondsToVideoTs = function secondsToVideoTs(seconds) {
+    	    return seconds * ONE_SECOND_IN_TS$3;
+    	  };
+    	  secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {
+    	    return seconds * sampleRate;
+    	  };
+    	  videoTsToSeconds = function videoTsToSeconds(timestamp) {
+    	    return timestamp / ONE_SECOND_IN_TS$3;
+    	  };
+    	  audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {
+    	    return timestamp / sampleRate;
+    	  };
+    	  audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {
+    	    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
+    	  };
+    	  videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {
+    	    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
+    	  };
+
+    	  /**
+    	   * Adjust ID3 tag or caption timing information by the timeline pts values
+    	   * (if keepOriginalTimestamps is false) and convert to seconds
+    	   */
+    	  metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {
+    	    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
+    	  };
+    	  var clock = {
+    	    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$3,
+    	    secondsToVideoTs: secondsToVideoTs,
+    	    secondsToAudioTs: secondsToAudioTs,
+    	    videoTsToSeconds: videoTsToSeconds,
+    	    audioTsToSeconds: audioTsToSeconds,
+    	    audioTsToVideoTs: audioTsToVideoTs,
+    	    videoTsToAudioTs: videoTsToAudioTs,
+    	    metadataTsToSeconds: metadataTsToSeconds
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+
+    	  /**
+    	   * Sum the `byteLength` properties of the data in each AAC frame
+    	   */
+    	  var sumFrameByteLengths = function sumFrameByteLengths(array) {
+    	    var i,
+    	      currentObj,
+    	      sum = 0;
+
+    	    // sum the byteLength's all each nal unit in the frame
+    	    for (i = 0; i < array.length; i++) {
+    	      currentObj = array[i];
+    	      sum += currentObj.data.byteLength;
+    	    }
+    	    return sum;
+    	  };
+
+    	  // Possibly pad (prefix) the audio track with silence if appending this track
+    	  // would lead to the introduction of a gap in the audio buffer
+    	  var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {
+    	    var baseMediaDecodeTimeTs,
+    	      frameDuration = 0,
+    	      audioGapDuration = 0,
+    	      audioFillFrameCount = 0,
+    	      audioFillDuration = 0,
+    	      silentFrame,
+    	      i,
+    	      firstFrame;
+    	    if (!frames.length) {
+    	      return;
+    	    }
+    	    baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate);
+    	    // determine frame clock duration based on sample rate, round up to avoid overfills
+    	    frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));
+    	    if (audioAppendStartTs && videoBaseMediaDecodeTime) {
+    	      // insert the shortest possible amount (audio gap or audio to video gap)
+    	      audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime);
+    	      // number of full frames in the audio gap
+    	      audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);
+    	      audioFillDuration = audioFillFrameCount * frameDuration;
+    	    }
+
+    	    // don't attempt to fill gaps smaller than a single frame or larger
+    	    // than a half second
+    	    if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {
+    	      return;
+    	    }
+    	    silentFrame = silence_1()[track.samplerate];
+    	    if (!silentFrame) {
+    	      // we don't have a silent frame pregenerated for the sample rate, so use a frame
+    	      // from the content instead
+    	      silentFrame = frames[0].data;
+    	    }
+    	    for (i = 0; i < audioFillFrameCount; i++) {
+    	      firstFrame = frames[0];
+    	      frames.splice(0, 0, {
+    	        data: silentFrame,
+    	        dts: firstFrame.dts - frameDuration,
+    	        pts: firstFrame.pts - frameDuration
+    	      });
+    	    }
+    	    track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));
+    	    return audioFillDuration;
+    	  };
+
+    	  // If the audio segment extends before the earliest allowed dts
+    	  // value, remove AAC frames until starts at or after the earliest
+    	  // allowed DTS so that we don't end up with a negative baseMedia-
+    	  // DecodeTime for the audio track
+    	  var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {
+    	    if (track.minSegmentDts >= earliestAllowedDts) {
+    	      return adtsFrames;
+    	    }
+
+    	    // We will need to recalculate the earliest segment Dts
+    	    track.minSegmentDts = Infinity;
+    	    return adtsFrames.filter(function (currentFrame) {
+    	      // If this is an allowed frame, keep it and record it's Dts
+    	      if (currentFrame.dts >= earliestAllowedDts) {
+    	        track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);
+    	        track.minSegmentPts = track.minSegmentDts;
+    	        return true;
+    	      }
+    	      // Otherwise, discard it
+    	      return false;
+    	    });
+    	  };
+
+    	  // generate the track's raw mdat data from an array of frames
+    	  var generateSampleTable = function generateSampleTable(frames) {
+    	    var i,
+    	      currentFrame,
+    	      samples = [];
+    	    for (i = 0; i < frames.length; i++) {
+    	      currentFrame = frames[i];
+    	      samples.push({
+    	        size: currentFrame.data.byteLength,
+    	        duration: 1024 // For AAC audio, all samples contain 1024 samples
+    	      });
+    	    }
+
+    	    return samples;
+    	  };
+
+    	  // generate the track's sample table from an array of frames
+    	  var concatenateFrameData = function concatenateFrameData(frames) {
+    	    var i,
+    	      currentFrame,
+    	      dataOffset = 0,
+    	      data = new Uint8Array(sumFrameByteLengths(frames));
+    	    for (i = 0; i < frames.length; i++) {
+    	      currentFrame = frames[i];
+    	      data.set(currentFrame.data, dataOffset);
+    	      dataOffset += currentFrame.data.byteLength;
+    	    }
+    	    return data;
+    	  };
+    	  var audioFrameUtils = {
+    	    prefixWithSilence: prefixWithSilence,
+    	    trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,
+    	    generateSampleTable: generateSampleTable,
+    	    concatenateFrameData: concatenateFrameData
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS;
+
+    	  /**
+    	   * Store information about the start and end of the track and the
+    	   * duration for each frame/sample we process in order to calculate
+    	   * the baseMediaDecodeTime
+    	   */
+    	  var collectDtsInfo = function collectDtsInfo(track, data) {
+    	    if (typeof data.pts === 'number') {
+    	      if (track.timelineStartInfo.pts === undefined) {
+    	        track.timelineStartInfo.pts = data.pts;
+    	      }
+    	      if (track.minSegmentPts === undefined) {
+    	        track.minSegmentPts = data.pts;
+    	      } else {
+    	        track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);
+    	      }
+    	      if (track.maxSegmentPts === undefined) {
+    	        track.maxSegmentPts = data.pts;
+    	      } else {
+    	        track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);
+    	      }
+    	    }
+    	    if (typeof data.dts === 'number') {
+    	      if (track.timelineStartInfo.dts === undefined) {
+    	        track.timelineStartInfo.dts = data.dts;
+    	      }
+    	      if (track.minSegmentDts === undefined) {
+    	        track.minSegmentDts = data.dts;
+    	      } else {
+    	        track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);
+    	      }
+    	      if (track.maxSegmentDts === undefined) {
+    	        track.maxSegmentDts = data.dts;
+    	      } else {
+    	        track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);
+    	      }
+    	    }
+    	  };
+
+    	  /**
+    	   * Clear values used to calculate the baseMediaDecodeTime between
+    	   * tracks
+    	   */
+    	  var clearDtsInfo = function clearDtsInfo(track) {
+    	    delete track.minSegmentDts;
+    	    delete track.maxSegmentDts;
+    	    delete track.minSegmentPts;
+    	    delete track.maxSegmentPts;
+    	  };
+
+    	  /**
+    	   * Calculate the track's baseMediaDecodeTime based on the earliest
+    	   * DTS the transmuxer has ever seen and the minimum DTS for the
+    	   * current track
+    	   * @param track {object} track metadata configuration
+    	   * @param keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at 0.
+    	   */
+    	  var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {
+    	    var baseMediaDecodeTime,
+    	      scale,
+    	      minSegmentDts = track.minSegmentDts;
+
+    	    // Optionally adjust the time so the first segment starts at zero.
+    	    if (!keepOriginalTimestamps) {
+    	      minSegmentDts -= track.timelineStartInfo.dts;
+    	    }
+
+    	    // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where
+    	    // we want the start of the first segment to be placed
+    	    baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime;
+
+    	    // Add to that the distance this segment is from the very first
+    	    baseMediaDecodeTime += minSegmentDts;
+
+    	    // baseMediaDecodeTime must not become negative
+    	    baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);
+    	    if (track.type === 'audio') {
+    	      // Audio has a different clock equal to the sampling_rate so we need to
+    	      // scale the PTS values into the clock rate of the track
+    	      scale = track.samplerate / ONE_SECOND_IN_TS$2;
+    	      baseMediaDecodeTime *= scale;
+    	      baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);
+    	    }
+    	    return baseMediaDecodeTime;
+    	  };
+    	  var trackDecodeInfo = {
+    	    clearDtsInfo: clearDtsInfo,
+    	    calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,
+    	    collectDtsInfo: collectDtsInfo
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   *
+    	   * Reads in-band caption information from a video elementary
+    	   * stream. Captions must follow the CEA-708 standard for injection
+    	   * into an MPEG-2 transport streams.
+    	   * @see https://en.wikipedia.org/wiki/CEA-708
+    	   * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf
+    	   */
+
+    	  // Supplemental enhancement information (SEI) NAL units have a
+    	  // payload type field to indicate how they are to be
+    	  // interpreted. CEAS-708 caption content is always transmitted with
+    	  // payload type 0x04.
+    	  var USER_DATA_REGISTERED_ITU_T_T35 = 4,
+    	    RBSP_TRAILING_BITS = 128;
+
+    	  /**
+    	    * Parse a supplemental enhancement information (SEI) NAL unit.
+    	    * Stops parsing once a message of type ITU T T35 has been found.
+    	    *
+    	    * @param bytes {Uint8Array} the bytes of a SEI NAL unit
+    	    * @return {object} the parsed SEI payload
+    	    * @see Rec. ITU-T H.264, 7.3.2.3.1
+    	    */
+    	  var parseSei = function parseSei(bytes) {
+    	    var i = 0,
+    	      result = {
+    	        payloadType: -1,
+    	        payloadSize: 0
+    	      },
+    	      payloadType = 0,
+    	      payloadSize = 0;
+
+    	    // go through the sei_rbsp parsing each each individual sei_message
+    	    while (i < bytes.byteLength) {
+    	      // stop once we have hit the end of the sei_rbsp
+    	      if (bytes[i] === RBSP_TRAILING_BITS) {
+    	        break;
+    	      }
+
+    	      // Parse payload type
+    	      while (bytes[i] === 0xFF) {
+    	        payloadType += 255;
+    	        i++;
+    	      }
+    	      payloadType += bytes[i++];
+
+    	      // Parse payload size
+    	      while (bytes[i] === 0xFF) {
+    	        payloadSize += 255;
+    	        i++;
+    	      }
+    	      payloadSize += bytes[i++];
+
+    	      // this sei_message is a 608/708 caption so save it and break
+    	      // there can only ever be one caption message in a frame's sei
+    	      if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {
+    	        var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);
+    	        if (userIdentifier === 'GA94') {
+    	          result.payloadType = payloadType;
+    	          result.payloadSize = payloadSize;
+    	          result.payload = bytes.subarray(i, i + payloadSize);
+    	          break;
+    	        } else {
+    	          result.payload = void 0;
+    	        }
+    	      }
+
+    	      // skip the payload and parse the next message
+    	      i += payloadSize;
+    	      payloadType = 0;
+    	      payloadSize = 0;
+    	    }
+    	    return result;
+    	  };
+
+    	  // see ANSI/SCTE 128-1 (2013), section 8.1
+    	  var parseUserData = function parseUserData(sei) {
+    	    // itu_t_t35_contry_code must be 181 (United States) for
+    	    // captions
+    	    if (sei.payload[0] !== 181) {
+    	      return null;
+    	    }
+
+    	    // itu_t_t35_provider_code should be 49 (ATSC) for captions
+    	    if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {
+    	      return null;
+    	    }
+
+    	    // the user_identifier should be "GA94" to indicate ATSC1 data
+    	    if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {
+    	      return null;
+    	    }
+
+    	    // finally, user_data_type_code should be 0x03 for caption data
+    	    if (sei.payload[7] !== 0x03) {
+    	      return null;
+    	    }
+
+    	    // return the user_data_type_structure and strip the trailing
+    	    // marker bits
+    	    return sei.payload.subarray(8, sei.payload.length - 1);
+    	  };
+
+    	  // see CEA-708-D, section 4.4
+    	  var parseCaptionPackets = function parseCaptionPackets(pts, userData) {
+    	    var results = [],
+    	      i,
+    	      count,
+    	      offset,
+    	      data;
+
+    	    // if this is just filler, return immediately
+    	    if (!(userData[0] & 0x40)) {
+    	      return results;
+    	    }
+
+    	    // parse out the cc_data_1 and cc_data_2 fields
+    	    count = userData[0] & 0x1f;
+    	    for (i = 0; i < count; i++) {
+    	      offset = i * 3;
+    	      data = {
+    	        type: userData[offset + 2] & 0x03,
+    	        pts: pts
+    	      };
+
+    	      // capture cc data when cc_valid is 1
+    	      if (userData[offset + 2] & 0x04) {
+    	        data.ccData = userData[offset + 3] << 8 | userData[offset + 4];
+    	        results.push(data);
+    	      }
+    	    }
+    	    return results;
+    	  };
+    	  var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+    	    var length = data.byteLength,
+    	      emulationPreventionBytesPositions = [],
+    	      i = 1,
+    	      newLength,
+    	      newData;
+
+    	    // Find all `Emulation Prevention Bytes`
+    	    while (i < length - 2) {
+    	      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+    	        emulationPreventionBytesPositions.push(i + 2);
+    	        i += 2;
+    	      } else {
+    	        i++;
+    	      }
+    	    }
+
+    	    // If no Emulation Prevention Bytes were found just return the original
+    	    // array
+    	    if (emulationPreventionBytesPositions.length === 0) {
+    	      return data;
+    	    }
+
+    	    // Create a new array to hold the NAL unit data
+    	    newLength = length - emulationPreventionBytesPositions.length;
+    	    newData = new Uint8Array(newLength);
+    	    var sourceIndex = 0;
+    	    for (i = 0; i < newLength; sourceIndex++, i++) {
+    	      if (sourceIndex === emulationPreventionBytesPositions[0]) {
+    	        // Skip this byte
+    	        sourceIndex++;
+    	        // Remove this position index
+    	        emulationPreventionBytesPositions.shift();
+    	      }
+    	      newData[i] = data[sourceIndex];
+    	    }
+    	    return newData;
+    	  };
+
+    	  // exports
+    	  var captionPacketParser = {
+    	    parseSei: parseSei,
+    	    parseUserData: parseUserData,
+    	    parseCaptionPackets: parseCaptionPackets,
+    	    discardEmulationPreventionBytes: discardEmulationPreventionBytes,
+    	    USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35
+    	  };
+
+    	  // -----------------
+    	  // Link To Transport
+    	  // -----------------
+
+    	  var CaptionStream = function CaptionStream(options) {
+    	    options = options || {};
+    	    CaptionStream.prototype.init.call(this);
+
+    	    // parse708captions flag, default to true
+    	    this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;
+    	    this.captionPackets_ = [];
+    	    this.ccStreams_ = [new Cea608Stream(0, 0),
+    	    // eslint-disable-line no-use-before-define
+    	    new Cea608Stream(0, 1),
+    	    // eslint-disable-line no-use-before-define
+    	    new Cea608Stream(1, 0),
+    	    // eslint-disable-line no-use-before-define
+    	    new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define
+    	    ];
+
+    	    if (this.parse708captions_) {
+    	      this.cc708Stream_ = new Cea708Stream({
+    	        captionServices: options.captionServices
+    	      }); // eslint-disable-line no-use-before-define
+    	    }
+
+    	    this.reset();
+
+    	    // forward data and done events from CCs to this CaptionStream
+    	    this.ccStreams_.forEach(function (cc) {
+    	      cc.on('data', this.trigger.bind(this, 'data'));
+    	      cc.on('partialdone', this.trigger.bind(this, 'partialdone'));
+    	      cc.on('done', this.trigger.bind(this, 'done'));
+    	    }, this);
+    	    if (this.parse708captions_) {
+    	      this.cc708Stream_.on('data', this.trigger.bind(this, 'data'));
+    	      this.cc708Stream_.on('partialdone', this.trigger.bind(this, 'partialdone'));
+    	      this.cc708Stream_.on('done', this.trigger.bind(this, 'done'));
+    	    }
+    	  };
+    	  CaptionStream.prototype = new stream();
+    	  CaptionStream.prototype.push = function (event) {
+    	    var sei, userData, newCaptionPackets;
+
+    	    // only examine SEI NALs
+    	    if (event.nalUnitType !== 'sei_rbsp') {
+    	      return;
+    	    }
+
+    	    // parse the sei
+    	    sei = captionPacketParser.parseSei(event.escapedRBSP);
+
+    	    // no payload data, skip
+    	    if (!sei.payload) {
+    	      return;
+    	    }
+
+    	    // ignore everything but user_data_registered_itu_t_t35
+    	    if (sei.payloadType !== captionPacketParser.USER_DATA_REGISTERED_ITU_T_T35) {
+    	      return;
+    	    }
+
+    	    // parse out the user data payload
+    	    userData = captionPacketParser.parseUserData(sei);
+
+    	    // ignore unrecognized userData
+    	    if (!userData) {
+    	      return;
+    	    }
+
+    	    // Sometimes, the same segment # will be downloaded twice. To stop the
+    	    // caption data from being processed twice, we track the latest dts we've
+    	    // received and ignore everything with a dts before that. However, since
+    	    // data for a specific dts can be split across packets on either side of
+    	    // a segment boundary, we need to make sure we *don't* ignore the packets
+    	    // from the *next* segment that have dts === this.latestDts_. By constantly
+    	    // tracking the number of packets received with dts === this.latestDts_, we
+    	    // know how many should be ignored once we start receiving duplicates.
+    	    if (event.dts < this.latestDts_) {
+    	      // We've started getting older data, so set the flag.
+    	      this.ignoreNextEqualDts_ = true;
+    	      return;
+    	    } else if (event.dts === this.latestDts_ && this.ignoreNextEqualDts_) {
+    	      this.numSameDts_--;
+    	      if (!this.numSameDts_) {
+    	        // We've received the last duplicate packet, time to start processing again
+    	        this.ignoreNextEqualDts_ = false;
+    	      }
+    	      return;
+    	    }
+
+    	    // parse out CC data packets and save them for later
+    	    newCaptionPackets = captionPacketParser.parseCaptionPackets(event.pts, userData);
+    	    this.captionPackets_ = this.captionPackets_.concat(newCaptionPackets);
+    	    if (this.latestDts_ !== event.dts) {
+    	      this.numSameDts_ = 0;
+    	    }
+    	    this.numSameDts_++;
+    	    this.latestDts_ = event.dts;
+    	  };
+    	  CaptionStream.prototype.flushCCStreams = function (flushType) {
+    	    this.ccStreams_.forEach(function (cc) {
+    	      return flushType === 'flush' ? cc.flush() : cc.partialFlush();
+    	    }, this);
+    	  };
+    	  CaptionStream.prototype.flushStream = function (flushType) {
+    	    // make sure we actually parsed captions before proceeding
+    	    if (!this.captionPackets_.length) {
+    	      this.flushCCStreams(flushType);
+    	      return;
+    	    }
+
+    	    // In Chrome, the Array#sort function is not stable so add a
+    	    // presortIndex that we can use to ensure we get a stable-sort
+    	    this.captionPackets_.forEach(function (elem, idx) {
+    	      elem.presortIndex = idx;
+    	    });
+
+    	    // sort caption byte-pairs based on their PTS values
+    	    this.captionPackets_.sort(function (a, b) {
+    	      if (a.pts === b.pts) {
+    	        return a.presortIndex - b.presortIndex;
+    	      }
+    	      return a.pts - b.pts;
+    	    });
+    	    this.captionPackets_.forEach(function (packet) {
+    	      if (packet.type < 2) {
+    	        // Dispatch packet to the right Cea608Stream
+    	        this.dispatchCea608Packet(packet);
+    	      } else {
+    	        // Dispatch packet to the Cea708Stream
+    	        this.dispatchCea708Packet(packet);
+    	      }
+    	    }, this);
+    	    this.captionPackets_.length = 0;
+    	    this.flushCCStreams(flushType);
+    	  };
+    	  CaptionStream.prototype.flush = function () {
+    	    return this.flushStream('flush');
+    	  };
+
+    	  // Only called if handling partial data
+    	  CaptionStream.prototype.partialFlush = function () {
+    	    return this.flushStream('partialFlush');
+    	  };
+    	  CaptionStream.prototype.reset = function () {
+    	    this.latestDts_ = null;
+    	    this.ignoreNextEqualDts_ = false;
+    	    this.numSameDts_ = 0;
+    	    this.activeCea608Channel_ = [null, null];
+    	    this.ccStreams_.forEach(function (ccStream) {
+    	      ccStream.reset();
+    	    });
+    	  };
+
+    	  // From the CEA-608 spec:
+    	  /*
+    	   * When XDS sub-packets are interleaved with other services, the end of each sub-packet shall be followed
+    	   * by a control pair to change to a different service. When any of the control codes from 0x10 to 0x1F is
+    	   * used to begin a control code pair, it indicates the return to captioning or Text data. The control code pair
+    	   * and subsequent data should then be processed according to the FCC rules. It may be necessary for the
+    	   * line 21 data encoder to automatically insert a control code pair (i.e. RCL, RU2, RU3, RU4, RDC, or RTD)
+    	   * to switch to captioning or Text.
+    	  */
+    	  // With that in mind, we ignore any data between an XDS control code and a
+    	  // subsequent closed-captioning control code.
+    	  CaptionStream.prototype.dispatchCea608Packet = function (packet) {
+    	    // NOTE: packet.type is the CEA608 field
+    	    if (this.setsTextOrXDSActive(packet)) {
+    	      this.activeCea608Channel_[packet.type] = null;
+    	    } else if (this.setsChannel1Active(packet)) {
+    	      this.activeCea608Channel_[packet.type] = 0;
+    	    } else if (this.setsChannel2Active(packet)) {
+    	      this.activeCea608Channel_[packet.type] = 1;
+    	    }
+    	    if (this.activeCea608Channel_[packet.type] === null) {
+    	      // If we haven't received anything to set the active channel, or the
+    	      // packets are Text/XDS data, discard the data; we don't want jumbled
+    	      // captions
+    	      return;
+    	    }
+    	    this.ccStreams_[(packet.type << 1) + this.activeCea608Channel_[packet.type]].push(packet);
+    	  };
+    	  CaptionStream.prototype.setsChannel1Active = function (packet) {
+    	    return (packet.ccData & 0x7800) === 0x1000;
+    	  };
+    	  CaptionStream.prototype.setsChannel2Active = function (packet) {
+    	    return (packet.ccData & 0x7800) === 0x1800;
+    	  };
+    	  CaptionStream.prototype.setsTextOrXDSActive = function (packet) {
+    	    return (packet.ccData & 0x7100) === 0x0100 || (packet.ccData & 0x78fe) === 0x102a || (packet.ccData & 0x78fe) === 0x182a;
+    	  };
+    	  CaptionStream.prototype.dispatchCea708Packet = function (packet) {
+    	    if (this.parse708captions_) {
+    	      this.cc708Stream_.push(packet);
+    	    }
+    	  };
+
+    	  // ----------------------
+    	  // Session to Application
+    	  // ----------------------
+
+    	  // This hash maps special and extended character codes to their
+    	  // proper Unicode equivalent. The first one-byte key is just a
+    	  // non-standard character code. The two-byte keys that follow are
+    	  // the extended CEA708 character codes, along with the preceding
+    	  // 0x10 extended character byte to distinguish these codes from
+    	  // non-extended character codes. Every CEA708 character code that
+    	  // is not in this object maps directly to a standard unicode
+    	  // character code.
+    	  // The transparent space and non-breaking transparent space are
+    	  // technically not fully supported since there is no code to
+    	  // make them transparent, so they have normal non-transparent
+    	  // stand-ins.
+    	  // The special closed caption (CC) character isn't a standard
+    	  // unicode character, so a fairly similar unicode character was
+    	  // chosen in it's place.
+    	  var CHARACTER_TRANSLATION_708 = {
+    	    0x7f: 0x266a,
+    	    // ♪
+    	    0x1020: 0x20,
+    	    // Transparent Space
+    	    0x1021: 0xa0,
+    	    // Nob-breaking Transparent Space
+    	    0x1025: 0x2026,
+    	    // …
+    	    0x102a: 0x0160,
+    	    // Š
+    	    0x102c: 0x0152,
+    	    // Œ
+    	    0x1030: 0x2588,
+    	    // █
+    	    0x1031: 0x2018,
+    	    // ‘
+    	    0x1032: 0x2019,
+    	    // ’
+    	    0x1033: 0x201c,
+    	    // “
+    	    0x1034: 0x201d,
+    	    // ”
+    	    0x1035: 0x2022,
+    	    // •
+    	    0x1039: 0x2122,
+    	    // ™
+    	    0x103a: 0x0161,
+    	    // š
+    	    0x103c: 0x0153,
+    	    // œ
+    	    0x103d: 0x2120,
+    	    // ℠
+    	    0x103f: 0x0178,
+    	    // Ÿ
+    	    0x1076: 0x215b,
+    	    // ⅛
+    	    0x1077: 0x215c,
+    	    // ⅜
+    	    0x1078: 0x215d,
+    	    // ⅝
+    	    0x1079: 0x215e,
+    	    // ⅞
+    	    0x107a: 0x23d0,
+    	    // ⏐
+    	    0x107b: 0x23a4,
+    	    // ⎤
+    	    0x107c: 0x23a3,
+    	    // ⎣
+    	    0x107d: 0x23af,
+    	    // ⎯
+    	    0x107e: 0x23a6,
+    	    // ⎦
+    	    0x107f: 0x23a1,
+    	    // ⎡
+    	    0x10a0: 0x3138 // ㄸ (CC char)
+    	  };
+
+    	  var get708CharFromCode = function get708CharFromCode(code) {
+    	    var newCode = CHARACTER_TRANSLATION_708[code] || code;
+    	    if (code & 0x1000 && code === newCode) {
+    	      // Invalid extended code
+    	      return '';
+    	    }
+    	    return String.fromCharCode(newCode);
+    	  };
+    	  var within708TextBlock = function within708TextBlock(b) {
+    	    return 0x20 <= b && b <= 0x7f || 0xa0 <= b && b <= 0xff;
+    	  };
+    	  var Cea708Window = function Cea708Window(windowNum) {
+    	    this.windowNum = windowNum;
+    	    this.reset();
+    	  };
+    	  Cea708Window.prototype.reset = function () {
+    	    this.clearText();
+    	    this.pendingNewLine = false;
+    	    this.winAttr = {};
+    	    this.penAttr = {};
+    	    this.penLoc = {};
+    	    this.penColor = {};
+
+    	    // These default values are arbitrary,
+    	    // defineWindow will usually override them
+    	    this.visible = 0;
+    	    this.rowLock = 0;
+    	    this.columnLock = 0;
+    	    this.priority = 0;
+    	    this.relativePositioning = 0;
+    	    this.anchorVertical = 0;
+    	    this.anchorHorizontal = 0;
+    	    this.anchorPoint = 0;
+    	    this.rowCount = 1;
+    	    this.virtualRowCount = this.rowCount + 1;
+    	    this.columnCount = 41;
+    	    this.windowStyle = 0;
+    	    this.penStyle = 0;
+    	  };
+    	  Cea708Window.prototype.getText = function () {
+    	    return this.rows.join('\n');
+    	  };
+    	  Cea708Window.prototype.clearText = function () {
+    	    this.rows = [''];
+    	    this.rowIdx = 0;
+    	  };
+    	  Cea708Window.prototype.newLine = function (pts) {
+    	    if (this.rows.length >= this.virtualRowCount && typeof this.beforeRowOverflow === 'function') {
+    	      this.beforeRowOverflow(pts);
+    	    }
+    	    if (this.rows.length > 0) {
+    	      this.rows.push('');
+    	      this.rowIdx++;
+    	    }
+
+    	    // Show all virtual rows since there's no visible scrolling
+    	    while (this.rows.length > this.virtualRowCount) {
+    	      this.rows.shift();
+    	      this.rowIdx--;
+    	    }
+    	  };
+    	  Cea708Window.prototype.isEmpty = function () {
+    	    if (this.rows.length === 0) {
+    	      return true;
+    	    } else if (this.rows.length === 1) {
+    	      return this.rows[0] === '';
+    	    }
+    	    return false;
+    	  };
+    	  Cea708Window.prototype.addText = function (text) {
+    	    this.rows[this.rowIdx] += text;
+    	  };
+    	  Cea708Window.prototype.backspace = function () {
+    	    if (!this.isEmpty()) {
+    	      var row = this.rows[this.rowIdx];
+    	      this.rows[this.rowIdx] = row.substr(0, row.length - 1);
+    	    }
+    	  };
+    	  var Cea708Service = function Cea708Service(serviceNum, encoding, stream) {
+    	    this.serviceNum = serviceNum;
+    	    this.text = '';
+    	    this.currentWindow = new Cea708Window(-1);
+    	    this.windows = [];
+    	    this.stream = stream;
+
+    	    // Try to setup a TextDecoder if an `encoding` value was provided
+    	    if (typeof encoding === 'string') {
+    	      this.createTextDecoder(encoding);
+    	    }
+    	  };
+
+    	  /**
+    	   * Initialize service windows
+    	   * Must be run before service use
+    	   *
+    	   * @param  {Integer}  pts               PTS value
+    	   * @param  {Function} beforeRowOverflow Function to execute before row overflow of a window
+    	   */
+    	  Cea708Service.prototype.init = function (pts, beforeRowOverflow) {
+    	    this.startPts = pts;
+    	    for (var win = 0; win < 8; win++) {
+    	      this.windows[win] = new Cea708Window(win);
+    	      if (typeof beforeRowOverflow === 'function') {
+    	        this.windows[win].beforeRowOverflow = beforeRowOverflow;
+    	      }
+    	    }
+    	  };
+
+    	  /**
+    	   * Set current window of service to be affected by commands
+    	   *
+    	   * @param  {Integer} windowNum Window number
+    	   */
+    	  Cea708Service.prototype.setCurrentWindow = function (windowNum) {
+    	    this.currentWindow = this.windows[windowNum];
+    	  };
+
+    	  /**
+    	   * Try to create a TextDecoder if it is natively supported
+    	   */
+    	  Cea708Service.prototype.createTextDecoder = function (encoding) {
+    	    if (typeof TextDecoder === 'undefined') {
+    	      this.stream.trigger('log', {
+    	        level: 'warn',
+    	        message: 'The `encoding` option is unsupported without TextDecoder support'
+    	      });
+    	    } else {
+    	      try {
+    	        this.textDecoder_ = new TextDecoder(encoding);
+    	      } catch (error) {
+    	        this.stream.trigger('log', {
+    	          level: 'warn',
+    	          message: 'TextDecoder could not be created with ' + encoding + ' encoding. ' + error
+    	        });
+    	      }
+    	    }
+    	  };
+    	  var Cea708Stream = function Cea708Stream(options) {
+    	    options = options || {};
+    	    Cea708Stream.prototype.init.call(this);
+    	    var self = this;
+    	    var captionServices = options.captionServices || {};
+    	    var captionServiceEncodings = {};
+    	    var serviceProps;
+
+    	    // Get service encodings from captionServices option block
+    	    Object.keys(captionServices).forEach(function (serviceName) {
+    	      serviceProps = captionServices[serviceName];
+    	      if (/^SERVICE/.test(serviceName)) {
+    	        captionServiceEncodings[serviceName] = serviceProps.encoding;
+    	      }
+    	    });
+    	    this.serviceEncodings = captionServiceEncodings;
+    	    this.current708Packet = null;
+    	    this.services = {};
+    	    this.push = function (packet) {
+    	      if (packet.type === 3) {
+    	        // 708 packet start
+    	        self.new708Packet();
+    	        self.add708Bytes(packet);
+    	      } else {
+    	        if (self.current708Packet === null) {
+    	          // This should only happen at the start of a file if there's no packet start.
+    	          self.new708Packet();
+    	        }
+    	        self.add708Bytes(packet);
+    	      }
+    	    };
+    	  };
+    	  Cea708Stream.prototype = new stream();
+
+    	  /**
+    	   * Push current 708 packet, create new 708 packet.
+    	   */
+    	  Cea708Stream.prototype.new708Packet = function () {
+    	    if (this.current708Packet !== null) {
+    	      this.push708Packet();
+    	    }
+    	    this.current708Packet = {
+    	      data: [],
+    	      ptsVals: []
+    	    };
+    	  };
+
+    	  /**
+    	   * Add pts and both bytes from packet into current 708 packet.
+    	   */
+    	  Cea708Stream.prototype.add708Bytes = function (packet) {
+    	    var data = packet.ccData;
+    	    var byte0 = data >>> 8;
+    	    var byte1 = data & 0xff;
+
+    	    // I would just keep a list of packets instead of bytes, but it isn't clear in the spec
+    	    // that service blocks will always line up with byte pairs.
+    	    this.current708Packet.ptsVals.push(packet.pts);
+    	    this.current708Packet.data.push(byte0);
+    	    this.current708Packet.data.push(byte1);
+    	  };
+
+    	  /**
+    	   * Parse completed 708 packet into service blocks and push each service block.
+    	   */
+    	  Cea708Stream.prototype.push708Packet = function () {
+    	    var packet708 = this.current708Packet;
+    	    var packetData = packet708.data;
+    	    var serviceNum = null;
+    	    var blockSize = null;
+    	    var i = 0;
+    	    var b = packetData[i++];
+    	    packet708.seq = b >> 6;
+    	    packet708.sizeCode = b & 0x3f; // 0b00111111;
+
+    	    for (; i < packetData.length; i++) {
+    	      b = packetData[i++];
+    	      serviceNum = b >> 5;
+    	      blockSize = b & 0x1f; // 0b00011111
+
+    	      if (serviceNum === 7 && blockSize > 0) {
+    	        // Extended service num
+    	        b = packetData[i++];
+    	        serviceNum = b;
+    	      }
+    	      this.pushServiceBlock(serviceNum, i, blockSize);
+    	      if (blockSize > 0) {
+    	        i += blockSize - 1;
+    	      }
+    	    }
+    	  };
+
+    	  /**
+    	   * Parse service block, execute commands, read text.
+    	   *
+    	   * Note: While many of these commands serve important purposes,
+    	   * many others just parse out the parameters or attributes, but
+    	   * nothing is done with them because this is not a full and complete
+    	   * implementation of the entire 708 spec.
+    	   *
+    	   * @param  {Integer} serviceNum Service number
+    	   * @param  {Integer} start      Start index of the 708 packet data
+    	   * @param  {Integer} size       Block size
+    	   */
+    	  Cea708Stream.prototype.pushServiceBlock = function (serviceNum, start, size) {
+    	    var b;
+    	    var i = start;
+    	    var packetData = this.current708Packet.data;
+    	    var service = this.services[serviceNum];
+    	    if (!service) {
+    	      service = this.initService(serviceNum, i);
+    	    }
+    	    for (; i < start + size && i < packetData.length; i++) {
+    	      b = packetData[i];
+    	      if (within708TextBlock(b)) {
+    	        i = this.handleText(i, service);
+    	      } else if (b === 0x18) {
+    	        i = this.multiByteCharacter(i, service);
+    	      } else if (b === 0x10) {
+    	        i = this.extendedCommands(i, service);
+    	      } else if (0x80 <= b && b <= 0x87) {
+    	        i = this.setCurrentWindow(i, service);
+    	      } else if (0x98 <= b && b <= 0x9f) {
+    	        i = this.defineWindow(i, service);
+    	      } else if (b === 0x88) {
+    	        i = this.clearWindows(i, service);
+    	      } else if (b === 0x8c) {
+    	        i = this.deleteWindows(i, service);
+    	      } else if (b === 0x89) {
+    	        i = this.displayWindows(i, service);
+    	      } else if (b === 0x8a) {
+    	        i = this.hideWindows(i, service);
+    	      } else if (b === 0x8b) {
+    	        i = this.toggleWindows(i, service);
+    	      } else if (b === 0x97) {
+    	        i = this.setWindowAttributes(i, service);
+    	      } else if (b === 0x90) {
+    	        i = this.setPenAttributes(i, service);
+    	      } else if (b === 0x91) {
+    	        i = this.setPenColor(i, service);
+    	      } else if (b === 0x92) {
+    	        i = this.setPenLocation(i, service);
+    	      } else if (b === 0x8f) {
+    	        service = this.reset(i, service);
+    	      } else if (b === 0x08) {
+    	        // BS: Backspace
+    	        service.currentWindow.backspace();
+    	      } else if (b === 0x0c) {
+    	        // FF: Form feed
+    	        service.currentWindow.clearText();
+    	      } else if (b === 0x0d) {
+    	        // CR: Carriage return
+    	        service.currentWindow.pendingNewLine = true;
+    	      } else if (b === 0x0e) {
+    	        // HCR: Horizontal carriage return
+    	        service.currentWindow.clearText();
+    	      } else if (b === 0x8d) {
+    	        // DLY: Delay, nothing to do
+    	        i++;
+    	      } else ;
+    	    }
+    	  };
+
+    	  /**
+    	   * Execute an extended command
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.extendedCommands = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    if (within708TextBlock(b)) {
+    	      i = this.handleText(i, service, {
+    	        isExtended: true
+    	      });
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Get PTS value of a given byte index
+    	   *
+    	   * @param  {Integer} byteIndex  Index of the byte
+    	   * @return {Integer}            PTS
+    	   */
+    	  Cea708Stream.prototype.getPts = function (byteIndex) {
+    	    // There's 1 pts value per 2 bytes
+    	    return this.current708Packet.ptsVals[Math.floor(byteIndex / 2)];
+    	  };
+
+    	  /**
+    	   * Initializes a service
+    	   *
+    	   * @param  {Integer} serviceNum Service number
+    	   * @return {Service}            Initialized service object
+    	   */
+    	  Cea708Stream.prototype.initService = function (serviceNum, i) {
+    	    var serviceName = 'SERVICE' + serviceNum;
+    	    var self = this;
+    	    var serviceName;
+    	    var encoding;
+    	    if (serviceName in this.serviceEncodings) {
+    	      encoding = this.serviceEncodings[serviceName];
+    	    }
+    	    this.services[serviceNum] = new Cea708Service(serviceNum, encoding, self);
+    	    this.services[serviceNum].init(this.getPts(i), function (pts) {
+    	      self.flushDisplayed(pts, self.services[serviceNum]);
+    	    });
+    	    return this.services[serviceNum];
+    	  };
+
+    	  /**
+    	   * Execute text writing to current window
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.handleText = function (i, service, options) {
+    	    var isExtended = options && options.isExtended;
+    	    var isMultiByte = options && options.isMultiByte;
+    	    var packetData = this.current708Packet.data;
+    	    var extended = isExtended ? 0x1000 : 0x0000;
+    	    var currentByte = packetData[i];
+    	    var nextByte = packetData[i + 1];
+    	    var win = service.currentWindow;
+    	    var char;
+    	    var charCodeArray;
+
+    	    // Use the TextDecoder if one was created for this service
+    	    if (service.textDecoder_ && !isExtended) {
+    	      if (isMultiByte) {
+    	        charCodeArray = [currentByte, nextByte];
+    	        i++;
+    	      } else {
+    	        charCodeArray = [currentByte];
+    	      }
+    	      char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
+    	    } else {
+    	      char = get708CharFromCode(extended | currentByte);
+    	    }
+    	    if (win.pendingNewLine && !win.isEmpty()) {
+    	      win.newLine(this.getPts(i));
+    	    }
+    	    win.pendingNewLine = false;
+    	    win.addText(char);
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Handle decoding of multibyte character
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.multiByteCharacter = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var firstByte = packetData[i + 1];
+    	    var secondByte = packetData[i + 2];
+    	    if (within708TextBlock(firstByte) && within708TextBlock(secondByte)) {
+    	      i = this.handleText(++i, service, {
+    	        isMultiByte: true
+    	      });
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the CW# command.
+    	   *
+    	   * Set the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setCurrentWindow = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var windowNum = b & 0x07;
+    	    service.setCurrentWindow(windowNum);
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the DF# command.
+    	   *
+    	   * Define a window and set it as the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.defineWindow = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var windowNum = b & 0x07;
+    	    service.setCurrentWindow(windowNum);
+    	    var win = service.currentWindow;
+    	    b = packetData[++i];
+    	    win.visible = (b & 0x20) >> 5; // v
+    	    win.rowLock = (b & 0x10) >> 4; // rl
+    	    win.columnLock = (b & 0x08) >> 3; // cl
+    	    win.priority = b & 0x07; // p
+
+    	    b = packetData[++i];
+    	    win.relativePositioning = (b & 0x80) >> 7; // rp
+    	    win.anchorVertical = b & 0x7f; // av
+
+    	    b = packetData[++i];
+    	    win.anchorHorizontal = b; // ah
+
+    	    b = packetData[++i];
+    	    win.anchorPoint = (b & 0xf0) >> 4; // ap
+    	    win.rowCount = b & 0x0f; // rc
+
+    	    b = packetData[++i];
+    	    win.columnCount = b & 0x3f; // cc
+
+    	    b = packetData[++i];
+    	    win.windowStyle = (b & 0x38) >> 3; // ws
+    	    win.penStyle = b & 0x07; // ps
+
+    	    // The spec says there are (rowCount+1) "virtual rows"
+    	    win.virtualRowCount = win.rowCount + 1;
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SWA command.
+    	   *
+    	   * Set attributes of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setWindowAttributes = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var winAttr = service.currentWindow.winAttr;
+    	    b = packetData[++i];
+    	    winAttr.fillOpacity = (b & 0xc0) >> 6; // fo
+    	    winAttr.fillRed = (b & 0x30) >> 4; // fr
+    	    winAttr.fillGreen = (b & 0x0c) >> 2; // fg
+    	    winAttr.fillBlue = b & 0x03; // fb
+
+    	    b = packetData[++i];
+    	    winAttr.borderType = (b & 0xc0) >> 6; // bt
+    	    winAttr.borderRed = (b & 0x30) >> 4; // br
+    	    winAttr.borderGreen = (b & 0x0c) >> 2; // bg
+    	    winAttr.borderBlue = b & 0x03; // bb
+
+    	    b = packetData[++i];
+    	    winAttr.borderType += (b & 0x80) >> 5; // bt
+    	    winAttr.wordWrap = (b & 0x40) >> 6; // ww
+    	    winAttr.printDirection = (b & 0x30) >> 4; // pd
+    	    winAttr.scrollDirection = (b & 0x0c) >> 2; // sd
+    	    winAttr.justify = b & 0x03; // j
+
+    	    b = packetData[++i];
+    	    winAttr.effectSpeed = (b & 0xf0) >> 4; // es
+    	    winAttr.effectDirection = (b & 0x0c) >> 2; // ed
+    	    winAttr.displayEffect = b & 0x03; // de
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Gather text from all displayed windows and push a caption to output.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   */
+    	  Cea708Stream.prototype.flushDisplayed = function (pts, service) {
+    	    var displayedText = [];
+
+    	    // TODO: Positioning not supported, displaying multiple windows will not necessarily
+    	    // display text in the correct order, but sample files so far have not shown any issue.
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (service.windows[winId].visible && !service.windows[winId].isEmpty()) {
+    	        displayedText.push(service.windows[winId].getText());
+    	      }
+    	    }
+    	    service.endPts = pts;
+    	    service.text = displayedText.join('\n\n');
+    	    this.pushCaption(service);
+    	    service.startPts = pts;
+    	  };
+
+    	  /**
+    	   * Push a caption to output if the caption contains text.
+    	   *
+    	   * @param  {Service} service  The service object to be affected
+    	   */
+    	  Cea708Stream.prototype.pushCaption = function (service) {
+    	    if (service.text !== '') {
+    	      this.trigger('data', {
+    	        startPts: service.startPts,
+    	        endPts: service.endPts,
+    	        text: service.text,
+    	        stream: 'cc708_' + service.serviceNum
+    	      });
+    	      service.text = '';
+    	      service.startPts = service.endPts;
+    	    }
+    	  };
+
+    	  /**
+    	   * Parse and execute the DSW command.
+    	   *
+    	   * Set visible property of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.displayWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].visible = 1;
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the HDW command.
+    	   *
+    	   * Set visible property of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.hideWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].visible = 0;
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the TGW command.
+    	   *
+    	   * Set visible property of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.toggleWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].visible ^= 1;
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the CLW command.
+    	   *
+    	   * Clear text of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.clearWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].clearText();
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the DLW command.
+    	   *
+    	   * Re-initialize windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.deleteWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].reset();
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SPA command.
+    	   *
+    	   * Set pen attributes of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setPenAttributes = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var penAttr = service.currentWindow.penAttr;
+    	    b = packetData[++i];
+    	    penAttr.textTag = (b & 0xf0) >> 4; // tt
+    	    penAttr.offset = (b & 0x0c) >> 2; // o
+    	    penAttr.penSize = b & 0x03; // s
+
+    	    b = packetData[++i];
+    	    penAttr.italics = (b & 0x80) >> 7; // i
+    	    penAttr.underline = (b & 0x40) >> 6; // u
+    	    penAttr.edgeType = (b & 0x38) >> 3; // et
+    	    penAttr.fontStyle = b & 0x07; // fs
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SPC command.
+    	   *
+    	   * Set pen color of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setPenColor = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var penColor = service.currentWindow.penColor;
+    	    b = packetData[++i];
+    	    penColor.fgOpacity = (b & 0xc0) >> 6; // fo
+    	    penColor.fgRed = (b & 0x30) >> 4; // fr
+    	    penColor.fgGreen = (b & 0x0c) >> 2; // fg
+    	    penColor.fgBlue = b & 0x03; // fb
+
+    	    b = packetData[++i];
+    	    penColor.bgOpacity = (b & 0xc0) >> 6; // bo
+    	    penColor.bgRed = (b & 0x30) >> 4; // br
+    	    penColor.bgGreen = (b & 0x0c) >> 2; // bg
+    	    penColor.bgBlue = b & 0x03; // bb
+
+    	    b = packetData[++i];
+    	    penColor.edgeRed = (b & 0x30) >> 4; // er
+    	    penColor.edgeGreen = (b & 0x0c) >> 2; // eg
+    	    penColor.edgeBlue = b & 0x03; // eb
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SPL command.
+    	   *
+    	   * Set pen location of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setPenLocation = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var penLoc = service.currentWindow.penLoc;
+
+    	    // Positioning isn't really supported at the moment, so this essentially just inserts a linebreak
+    	    service.currentWindow.pendingNewLine = true;
+    	    b = packetData[++i];
+    	    penLoc.row = b & 0x0f; // r
+
+    	    b = packetData[++i];
+    	    penLoc.column = b & 0x3f; // c
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Execute the RST command.
+    	   *
+    	   * Reset service to a clean slate. Re-initialize.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Service}          Re-initialized service
+    	   */
+    	  Cea708Stream.prototype.reset = function (i, service) {
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    return this.initService(service.serviceNum, i);
+    	  };
+
+    	  // This hash maps non-ASCII, special, and extended character codes to their
+    	  // proper Unicode equivalent. The first keys that are only a single byte
+    	  // are the non-standard ASCII characters, which simply map the CEA608 byte
+    	  // to the standard ASCII/Unicode. The two-byte keys that follow are the CEA608
+    	  // character codes, but have their MSB bitmasked with 0x03 so that a lookup
+    	  // can be performed regardless of the field and data channel on which the
+    	  // character code was received.
+    	  var CHARACTER_TRANSLATION = {
+    	    0x2a: 0xe1,
+    	    // á
+    	    0x5c: 0xe9,
+    	    // é
+    	    0x5e: 0xed,
+    	    // í
+    	    0x5f: 0xf3,
+    	    // ó
+    	    0x60: 0xfa,
+    	    // ú
+    	    0x7b: 0xe7,
+    	    // ç
+    	    0x7c: 0xf7,
+    	    // ÷
+    	    0x7d: 0xd1,
+    	    // Ñ
+    	    0x7e: 0xf1,
+    	    // ñ
+    	    0x7f: 0x2588,
+    	    // █
+    	    0x0130: 0xae,
+    	    // ®
+    	    0x0131: 0xb0,
+    	    // °
+    	    0x0132: 0xbd,
+    	    // ½
+    	    0x0133: 0xbf,
+    	    // ¿
+    	    0x0134: 0x2122,
+    	    // ™
+    	    0x0135: 0xa2,
+    	    // ¢
+    	    0x0136: 0xa3,
+    	    // £
+    	    0x0137: 0x266a,
+    	    // ♪
+    	    0x0138: 0xe0,
+    	    // à
+    	    0x0139: 0xa0,
+    	    //
+    	    0x013a: 0xe8,
+    	    // è
+    	    0x013b: 0xe2,
+    	    // â
+    	    0x013c: 0xea,
+    	    // ê
+    	    0x013d: 0xee,
+    	    // î
+    	    0x013e: 0xf4,
+    	    // ô
+    	    0x013f: 0xfb,
+    	    // û
+    	    0x0220: 0xc1,
+    	    // Á
+    	    0x0221: 0xc9,
+    	    // É
+    	    0x0222: 0xd3,
+    	    // Ó
+    	    0x0223: 0xda,
+    	    // Ú
+    	    0x0224: 0xdc,
+    	    // Ü
+    	    0x0225: 0xfc,
+    	    // ü
+    	    0x0226: 0x2018,
+    	    // ‘
+    	    0x0227: 0xa1,
+    	    // ¡
+    	    0x0228: 0x2a,
+    	    // *
+    	    0x0229: 0x27,
+    	    // '
+    	    0x022a: 0x2014,
+    	    // —
+    	    0x022b: 0xa9,
+    	    // ©
+    	    0x022c: 0x2120,
+    	    // ℠
+    	    0x022d: 0x2022,
+    	    // •
+    	    0x022e: 0x201c,
+    	    // “
+    	    0x022f: 0x201d,
+    	    // ”
+    	    0x0230: 0xc0,
+    	    // À
+    	    0x0231: 0xc2,
+    	    // Â
+    	    0x0232: 0xc7,
+    	    // Ç
+    	    0x0233: 0xc8,
+    	    // È
+    	    0x0234: 0xca,
+    	    // Ê
+    	    0x0235: 0xcb,
+    	    // Ë
+    	    0x0236: 0xeb,
+    	    // ë
+    	    0x0237: 0xce,
+    	    // Î
+    	    0x0238: 0xcf,
+    	    // Ï
+    	    0x0239: 0xef,
+    	    // ï
+    	    0x023a: 0xd4,
+    	    // Ô
+    	    0x023b: 0xd9,
+    	    // Ù
+    	    0x023c: 0xf9,
+    	    // ù
+    	    0x023d: 0xdb,
+    	    // Û
+    	    0x023e: 0xab,
+    	    // «
+    	    0x023f: 0xbb,
+    	    // »
+    	    0x0320: 0xc3,
+    	    // Ã
+    	    0x0321: 0xe3,
+    	    // ã
+    	    0x0322: 0xcd,
+    	    // Í
+    	    0x0323: 0xcc,
+    	    // Ì
+    	    0x0324: 0xec,
+    	    // ì
+    	    0x0325: 0xd2,
+    	    // Ò
+    	    0x0326: 0xf2,
+    	    // ò
+    	    0x0327: 0xd5,
+    	    // Õ
+    	    0x0328: 0xf5,
+    	    // õ
+    	    0x0329: 0x7b,
+    	    // {
+    	    0x032a: 0x7d,
+    	    // }
+    	    0x032b: 0x5c,
+    	    // \
+    	    0x032c: 0x5e,
+    	    // ^
+    	    0x032d: 0x5f,
+    	    // _
+    	    0x032e: 0x7c,
+    	    // |
+    	    0x032f: 0x7e,
+    	    // ~
+    	    0x0330: 0xc4,
+    	    // Ä
+    	    0x0331: 0xe4,
+    	    // ä
+    	    0x0332: 0xd6,
+    	    // Ö
+    	    0x0333: 0xf6,
+    	    // ö
+    	    0x0334: 0xdf,
+    	    // ß
+    	    0x0335: 0xa5,
+    	    // ¥
+    	    0x0336: 0xa4,
+    	    // ¤
+    	    0x0337: 0x2502,
+    	    // │
+    	    0x0338: 0xc5,
+    	    // Å
+    	    0x0339: 0xe5,
+    	    // å
+    	    0x033a: 0xd8,
+    	    // Ø
+    	    0x033b: 0xf8,
+    	    // ø
+    	    0x033c: 0x250c,
+    	    // ┌
+    	    0x033d: 0x2510,
+    	    // ┐
+    	    0x033e: 0x2514,
+    	    // └
+    	    0x033f: 0x2518 // ┘
+    	  };
+
+    	  var getCharFromCode = function getCharFromCode(code) {
+    	    if (code === null) {
+    	      return '';
+    	    }
+    	    code = CHARACTER_TRANSLATION[code] || code;
+    	    return String.fromCharCode(code);
+    	  };
+
+    	  // the index of the last row in a CEA-608 display buffer
+    	  var BOTTOM_ROW = 14;
+
+    	  // This array is used for mapping PACs -> row #, since there's no way of
+    	  // getting it through bit logic.
+    	  var ROWS = [0x1100, 0x1120, 0x1200, 0x1220, 0x1500, 0x1520, 0x1600, 0x1620, 0x1700, 0x1720, 0x1000, 0x1300, 0x1320, 0x1400, 0x1420];
+
+    	  // CEA-608 captions are rendered onto a 34x15 matrix of character
+    	  // cells. The "bottom" row is the last element in the outer array.
+    	  var createDisplayBuffer = function createDisplayBuffer() {
+    	    var result = [],
+    	      i = BOTTOM_ROW + 1;
+    	    while (i--) {
+    	      result.push('');
+    	    }
+    	    return result;
+    	  };
+    	  var Cea608Stream = function Cea608Stream(field, dataChannel) {
+    	    Cea608Stream.prototype.init.call(this);
+    	    this.field_ = field || 0;
+    	    this.dataChannel_ = dataChannel || 0;
+    	    this.name_ = 'CC' + ((this.field_ << 1 | this.dataChannel_) + 1);
+    	    this.setConstants();
+    	    this.reset();
+    	    this.push = function (packet) {
+    	      var data, swap, char0, char1, text;
+    	      // remove the parity bits
+    	      data = packet.ccData & 0x7f7f;
+
+    	      // ignore duplicate control codes; the spec demands they're sent twice
+    	      if (data === this.lastControlCode_) {
+    	        this.lastControlCode_ = null;
+    	        return;
+    	      }
+
+    	      // Store control codes
+    	      if ((data & 0xf000) === 0x1000) {
+    	        this.lastControlCode_ = data;
+    	      } else if (data !== this.PADDING_) {
+    	        this.lastControlCode_ = null;
+    	      }
+    	      char0 = data >>> 8;
+    	      char1 = data & 0xff;
+    	      if (data === this.PADDING_) {
+    	        return;
+    	      } else if (data === this.RESUME_CAPTION_LOADING_) {
+    	        this.mode_ = 'popOn';
+    	      } else if (data === this.END_OF_CAPTION_) {
+    	        // If an EOC is received while in paint-on mode, the displayed caption
+    	        // text should be swapped to non-displayed memory as if it was a pop-on
+    	        // caption. Because of that, we should explicitly switch back to pop-on
+    	        // mode
+    	        this.mode_ = 'popOn';
+    	        this.clearFormatting(packet.pts);
+    	        // if a caption was being displayed, it's gone now
+    	        this.flushDisplayed(packet.pts);
+
+    	        // flip memory
+    	        swap = this.displayed_;
+    	        this.displayed_ = this.nonDisplayed_;
+    	        this.nonDisplayed_ = swap;
+
+    	        // start measuring the time to display the caption
+    	        this.startPts_ = packet.pts;
+    	      } else if (data === this.ROLL_UP_2_ROWS_) {
+    	        this.rollUpRows_ = 2;
+    	        this.setRollUp(packet.pts);
+    	      } else if (data === this.ROLL_UP_3_ROWS_) {
+    	        this.rollUpRows_ = 3;
+    	        this.setRollUp(packet.pts);
+    	      } else if (data === this.ROLL_UP_4_ROWS_) {
+    	        this.rollUpRows_ = 4;
+    	        this.setRollUp(packet.pts);
+    	      } else if (data === this.CARRIAGE_RETURN_) {
+    	        this.clearFormatting(packet.pts);
+    	        this.flushDisplayed(packet.pts);
+    	        this.shiftRowsUp_();
+    	        this.startPts_ = packet.pts;
+    	      } else if (data === this.BACKSPACE_) {
+    	        if (this.mode_ === 'popOn') {
+    	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+    	        } else {
+    	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+    	        }
+    	      } else if (data === this.ERASE_DISPLAYED_MEMORY_) {
+    	        this.flushDisplayed(packet.pts);
+    	        this.displayed_ = createDisplayBuffer();
+    	      } else if (data === this.ERASE_NON_DISPLAYED_MEMORY_) {
+    	        this.nonDisplayed_ = createDisplayBuffer();
+    	      } else if (data === this.RESUME_DIRECT_CAPTIONING_) {
+    	        if (this.mode_ !== 'paintOn') {
+    	          // NOTE: This should be removed when proper caption positioning is
+    	          // implemented
+    	          this.flushDisplayed(packet.pts);
+    	          this.displayed_ = createDisplayBuffer();
+    	        }
+    	        this.mode_ = 'paintOn';
+    	        this.startPts_ = packet.pts;
+
+    	        // Append special characters to caption text
+    	      } else if (this.isSpecialCharacter(char0, char1)) {
+    	        // Bitmask char0 so that we can apply character transformations
+    	        // regardless of field and data channel.
+    	        // Then byte-shift to the left and OR with char1 so we can pass the
+    	        // entire character code to `getCharFromCode`.
+    	        char0 = (char0 & 0x03) << 8;
+    	        text = getCharFromCode(char0 | char1);
+    	        this[this.mode_](packet.pts, text);
+    	        this.column_++;
+
+    	        // Append extended characters to caption text
+    	      } else if (this.isExtCharacter(char0, char1)) {
+    	        // Extended characters always follow their "non-extended" equivalents.
+    	        // IE if a "è" is desired, you'll always receive "eè"; non-compliant
+    	        // decoders are supposed to drop the "è", while compliant decoders
+    	        // backspace the "e" and insert "è".
+
+    	        // Delete the previous character
+    	        if (this.mode_ === 'popOn') {
+    	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+    	        } else {
+    	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+    	        }
+
+    	        // Bitmask char0 so that we can apply character transformations
+    	        // regardless of field and data channel.
+    	        // Then byte-shift to the left and OR with char1 so we can pass the
+    	        // entire character code to `getCharFromCode`.
+    	        char0 = (char0 & 0x03) << 8;
+    	        text = getCharFromCode(char0 | char1);
+    	        this[this.mode_](packet.pts, text);
+    	        this.column_++;
+
+    	        // Process mid-row codes
+    	      } else if (this.isMidRowCode(char0, char1)) {
+    	        // Attributes are not additive, so clear all formatting
+    	        this.clearFormatting(packet.pts);
+
+    	        // According to the standard, mid-row codes
+    	        // should be replaced with spaces, so add one now
+    	        this[this.mode_](packet.pts, ' ');
+    	        this.column_++;
+    	        if ((char1 & 0xe) === 0xe) {
+    	          this.addFormatting(packet.pts, ['i']);
+    	        }
+    	        if ((char1 & 0x1) === 0x1) {
+    	          this.addFormatting(packet.pts, ['u']);
+    	        }
+
+    	        // Detect offset control codes and adjust cursor
+    	      } else if (this.isOffsetControlCode(char0, char1)) {
+    	        // Cursor position is set by indent PAC (see below) in 4-column
+    	        // increments, with an additional offset code of 1-3 to reach any
+    	        // of the 32 columns specified by CEA-608. So all we need to do
+    	        // here is increment the column cursor by the given offset.
+    	        this.column_ += char1 & 0x03;
+
+    	        // Detect PACs (Preamble Address Codes)
+    	      } else if (this.isPAC(char0, char1)) {
+    	        // There's no logic for PAC -> row mapping, so we have to just
+    	        // find the row code in an array and use its index :(
+    	        var row = ROWS.indexOf(data & 0x1f20);
+
+    	        // Configure the caption window if we're in roll-up mode
+    	        if (this.mode_ === 'rollUp') {
+    	          // This implies that the base row is incorrectly set.
+    	          // As per the recommendation in CEA-608(Base Row Implementation), defer to the number
+    	          // of roll-up rows set.
+    	          if (row - this.rollUpRows_ + 1 < 0) {
+    	            row = this.rollUpRows_ - 1;
+    	          }
+    	          this.setRollUp(packet.pts, row);
+    	        }
+    	        if (row !== this.row_) {
+    	          // formatting is only persistent for current row
+    	          this.clearFormatting(packet.pts);
+    	          this.row_ = row;
+    	        }
+    	        // All PACs can apply underline, so detect and apply
+    	        // (All odd-numbered second bytes set underline)
+    	        if (char1 & 0x1 && this.formatting_.indexOf('u') === -1) {
+    	          this.addFormatting(packet.pts, ['u']);
+    	        }
+    	        if ((data & 0x10) === 0x10) {
+    	          // We've got an indent level code. Each successive even number
+    	          // increments the column cursor by 4, so we can get the desired
+    	          // column position by bit-shifting to the right (to get n/2)
+    	          // and multiplying by 4.
+    	          this.column_ = ((data & 0xe) >> 1) * 4;
+    	        }
+    	        if (this.isColorPAC(char1)) {
+    	          // it's a color code, though we only support white, which
+    	          // can be either normal or italicized. white italics can be
+    	          // either 0x4e or 0x6e depending on the row, so we just
+    	          // bitwise-and with 0xe to see if italics should be turned on
+    	          if ((char1 & 0xe) === 0xe) {
+    	            this.addFormatting(packet.pts, ['i']);
+    	          }
+    	        }
+
+    	        // We have a normal character in char0, and possibly one in char1
+    	      } else if (this.isNormalChar(char0)) {
+    	        if (char1 === 0x00) {
+    	          char1 = null;
+    	        }
+    	        text = getCharFromCode(char0);
+    	        text += getCharFromCode(char1);
+    	        this[this.mode_](packet.pts, text);
+    	        this.column_ += text.length;
+    	      } // finish data processing
+    	    };
+    	  };
+
+    	  Cea608Stream.prototype = new stream();
+    	  // Trigger a cue point that captures the current state of the
+    	  // display buffer
+    	  Cea608Stream.prototype.flushDisplayed = function (pts) {
+    	    var content = this.displayed_
+    	    // remove spaces from the start and end of the string
+    	    .map(function (row, index) {
+    	      try {
+    	        return row.trim();
+    	      } catch (e) {
+    	        // Ordinarily, this shouldn't happen. However, caption
+    	        // parsing errors should not throw exceptions and
+    	        // break playback.
+    	        this.trigger('log', {
+    	          level: 'warn',
+    	          message: 'Skipping a malformed 608 caption at index ' + index + '.'
+    	        });
+    	        return '';
+    	      }
+    	    }, this)
+    	    // combine all text rows to display in one cue
+    	    .join('\n')
+    	    // and remove blank rows from the start and end, but not the middle
+    	    .replace(/^\n+|\n+$/g, '');
+    	    if (content.length) {
+    	      this.trigger('data', {
+    	        startPts: this.startPts_,
+    	        endPts: pts,
+    	        text: content,
+    	        stream: this.name_
+    	      });
+    	    }
+    	  };
+
+    	  /**
+    	   * Zero out the data, used for startup and on seek
+    	   */
+    	  Cea608Stream.prototype.reset = function () {
+    	    this.mode_ = 'popOn';
+    	    // When in roll-up mode, the index of the last row that will
+    	    // actually display captions. If a caption is shifted to a row
+    	    // with a lower index than this, it is cleared from the display
+    	    // buffer
+    	    this.topRow_ = 0;
+    	    this.startPts_ = 0;
+    	    this.displayed_ = createDisplayBuffer();
+    	    this.nonDisplayed_ = createDisplayBuffer();
+    	    this.lastControlCode_ = null;
+
+    	    // Track row and column for proper line-breaking and spacing
+    	    this.column_ = 0;
+    	    this.row_ = BOTTOM_ROW;
+    	    this.rollUpRows_ = 2;
+
+    	    // This variable holds currently-applied formatting
+    	    this.formatting_ = [];
+    	  };
+
+    	  /**
+    	   * Sets up control code and related constants for this instance
+    	   */
+    	  Cea608Stream.prototype.setConstants = function () {
+    	    // The following attributes have these uses:
+    	    // ext_ :    char0 for mid-row codes, and the base for extended
+    	    //           chars (ext_+0, ext_+1, and ext_+2 are char0s for
+    	    //           extended codes)
+    	    // control_: char0 for control codes, except byte-shifted to the
+    	    //           left so that we can do this.control_ | CONTROL_CODE
+    	    // offset_:  char0 for tab offset codes
+    	    //
+    	    // It's also worth noting that control codes, and _only_ control codes,
+    	    // differ between field 1 and field2. Field 2 control codes are always
+    	    // their field 1 value plus 1. That's why there's the "| field" on the
+    	    // control value.
+    	    if (this.dataChannel_ === 0) {
+    	      this.BASE_ = 0x10;
+    	      this.EXT_ = 0x11;
+    	      this.CONTROL_ = (0x14 | this.field_) << 8;
+    	      this.OFFSET_ = 0x17;
+    	    } else if (this.dataChannel_ === 1) {
+    	      this.BASE_ = 0x18;
+    	      this.EXT_ = 0x19;
+    	      this.CONTROL_ = (0x1c | this.field_) << 8;
+    	      this.OFFSET_ = 0x1f;
+    	    }
+
+    	    // Constants for the LSByte command codes recognized by Cea608Stream. This
+    	    // list is not exhaustive. For a more comprehensive listing and semantics see
+    	    // http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf
+    	    // Padding
+    	    this.PADDING_ = 0x0000;
+    	    // Pop-on Mode
+    	    this.RESUME_CAPTION_LOADING_ = this.CONTROL_ | 0x20;
+    	    this.END_OF_CAPTION_ = this.CONTROL_ | 0x2f;
+    	    // Roll-up Mode
+    	    this.ROLL_UP_2_ROWS_ = this.CONTROL_ | 0x25;
+    	    this.ROLL_UP_3_ROWS_ = this.CONTROL_ | 0x26;
+    	    this.ROLL_UP_4_ROWS_ = this.CONTROL_ | 0x27;
+    	    this.CARRIAGE_RETURN_ = this.CONTROL_ | 0x2d;
+    	    // paint-on mode
+    	    this.RESUME_DIRECT_CAPTIONING_ = this.CONTROL_ | 0x29;
+    	    // Erasure
+    	    this.BACKSPACE_ = this.CONTROL_ | 0x21;
+    	    this.ERASE_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2c;
+    	    this.ERASE_NON_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2e;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet data is a special character
+    	   *
+    	   * Special characters have a second byte in the range 0x30 to 0x3f,
+    	   * with the first byte being 0x11 (for data channel 1) or 0x19 (for
+    	   * data channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are an special character
+    	   */
+    	  Cea608Stream.prototype.isSpecialCharacter = function (char0, char1) {
+    	    return char0 === this.EXT_ && char1 >= 0x30 && char1 <= 0x3f;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet data is an extended character
+    	   *
+    	   * Extended characters have a second byte in the range 0x20 to 0x3f,
+    	   * with the first byte being 0x12 or 0x13 (for data channel 1) or
+    	   * 0x1a or 0x1b (for data channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are an extended character
+    	   */
+    	  Cea608Stream.prototype.isExtCharacter = function (char0, char1) {
+    	    return (char0 === this.EXT_ + 1 || char0 === this.EXT_ + 2) && char1 >= 0x20 && char1 <= 0x3f;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet is a mid-row code
+    	   *
+    	   * Mid-row codes have a second byte in the range 0x20 to 0x2f, with
+    	   * the first byte being 0x11 (for data channel 1) or 0x19 (for data
+    	   * channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are a mid-row code
+    	   */
+    	  Cea608Stream.prototype.isMidRowCode = function (char0, char1) {
+    	    return char0 === this.EXT_ && char1 >= 0x20 && char1 <= 0x2f;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet is an offset control code
+    	   *
+    	   * Offset control codes have a second byte in the range 0x21 to 0x23,
+    	   * with the first byte being 0x17 (for data channel 1) or 0x1f (for
+    	   * data channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are an offset control code
+    	   */
+    	  Cea608Stream.prototype.isOffsetControlCode = function (char0, char1) {
+    	    return char0 === this.OFFSET_ && char1 >= 0x21 && char1 <= 0x23;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet is a Preamble Address Code
+    	   *
+    	   * PACs have a first byte in the range 0x10 to 0x17 (for data channel 1)
+    	   * or 0x18 to 0x1f (for data channel 2), with the second byte in the
+    	   * range 0x40 to 0x7f.
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are a PAC
+    	   */
+    	  Cea608Stream.prototype.isPAC = function (char0, char1) {
+    	    return char0 >= this.BASE_ && char0 < this.BASE_ + 8 && char1 >= 0x40 && char1 <= 0x7f;
+    	  };
+
+    	  /**
+    	   * Detects if a packet's second byte is in the range of a PAC color code
+    	   *
+    	   * PAC color codes have the second byte be in the range 0x40 to 0x4f, or
+    	   * 0x60 to 0x6f.
+    	   *
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the byte is a color PAC
+    	   */
+    	  Cea608Stream.prototype.isColorPAC = function (char1) {
+    	    return char1 >= 0x40 && char1 <= 0x4f || char1 >= 0x60 && char1 <= 0x7f;
+    	  };
+
+    	  /**
+    	   * Detects if a single byte is in the range of a normal character
+    	   *
+    	   * Normal text bytes are in the range 0x20 to 0x7f.
+    	   *
+    	   * @param  {Integer} char  The byte
+    	   * @return {Boolean}       Whether the byte is a normal character
+    	   */
+    	  Cea608Stream.prototype.isNormalChar = function (char) {
+    	    return char >= 0x20 && char <= 0x7f;
+    	  };
+
+    	  /**
+    	   * Configures roll-up
+    	   *
+    	   * @param  {Integer} pts         Current PTS
+    	   * @param  {Integer} newBaseRow  Used by PACs to slide the current window to
+    	   *                               a new position
+    	   */
+    	  Cea608Stream.prototype.setRollUp = function (pts, newBaseRow) {
+    	    // Reset the base row to the bottom row when switching modes
+    	    if (this.mode_ !== 'rollUp') {
+    	      this.row_ = BOTTOM_ROW;
+    	      this.mode_ = 'rollUp';
+    	      // Spec says to wipe memories when switching to roll-up
+    	      this.flushDisplayed(pts);
+    	      this.nonDisplayed_ = createDisplayBuffer();
+    	      this.displayed_ = createDisplayBuffer();
+    	    }
+    	    if (newBaseRow !== undefined && newBaseRow !== this.row_) {
+    	      // move currently displayed captions (up or down) to the new base row
+    	      for (var i = 0; i < this.rollUpRows_; i++) {
+    	        this.displayed_[newBaseRow - i] = this.displayed_[this.row_ - i];
+    	        this.displayed_[this.row_ - i] = '';
+    	      }
+    	    }
+    	    if (newBaseRow === undefined) {
+    	      newBaseRow = this.row_;
+    	    }
+    	    this.topRow_ = newBaseRow - this.rollUpRows_ + 1;
+    	  };
+
+    	  // Adds the opening HTML tag for the passed character to the caption text,
+    	  // and keeps track of it for later closing
+    	  Cea608Stream.prototype.addFormatting = function (pts, format) {
+    	    this.formatting_ = this.formatting_.concat(format);
+    	    var text = format.reduce(function (text, format) {
+    	      return text + '<' + format + '>';
+    	    }, '');
+    	    this[this.mode_](pts, text);
+    	  };
+
+    	  // Adds HTML closing tags for current formatting to caption text and
+    	  // clears remembered formatting
+    	  Cea608Stream.prototype.clearFormatting = function (pts) {
+    	    if (!this.formatting_.length) {
+    	      return;
+    	    }
+    	    var text = this.formatting_.reverse().reduce(function (text, format) {
+    	      return text + '</' + format + '>';
+    	    }, '');
+    	    this.formatting_ = [];
+    	    this[this.mode_](pts, text);
+    	  };
+
+    	  // Mode Implementations
+    	  Cea608Stream.prototype.popOn = function (pts, text) {
+    	    var baseRow = this.nonDisplayed_[this.row_];
+
+    	    // buffer characters
+    	    baseRow += text;
+    	    this.nonDisplayed_[this.row_] = baseRow;
+    	  };
+    	  Cea608Stream.prototype.rollUp = function (pts, text) {
+    	    var baseRow = this.displayed_[this.row_];
+    	    baseRow += text;
+    	    this.displayed_[this.row_] = baseRow;
+    	  };
+    	  Cea608Stream.prototype.shiftRowsUp_ = function () {
+    	    var i;
+    	    // clear out inactive rows
+    	    for (i = 0; i < this.topRow_; i++) {
+    	      this.displayed_[i] = '';
+    	    }
+    	    for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {
+    	      this.displayed_[i] = '';
+    	    }
+    	    // shift displayed rows up
+    	    for (i = this.topRow_; i < this.row_; i++) {
+    	      this.displayed_[i] = this.displayed_[i + 1];
+    	    }
+    	    // clear out the bottom row
+    	    this.displayed_[this.row_] = '';
+    	  };
+    	  Cea608Stream.prototype.paintOn = function (pts, text) {
+    	    var baseRow = this.displayed_[this.row_];
+    	    baseRow += text;
+    	    this.displayed_[this.row_] = baseRow;
+    	  };
+
+    	  // exports
+    	  var captionStream = {
+    	    CaptionStream: CaptionStream,
+    	    Cea608Stream: Cea608Stream,
+    	    Cea708Stream: Cea708Stream
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+
+    	  var streamTypes = {
+    	    H264_STREAM_TYPE: 0x1B,
+    	    ADTS_STREAM_TYPE: 0x0F,
+    	    METADATA_STREAM_TYPE: 0x15
+    	  };
+
+    	  var MAX_TS = 8589934592;
+    	  var RO_THRESH = 4294967296;
+    	  var TYPE_SHARED = 'shared';
+    	  var handleRollover = function handleRollover(value, reference) {
+    	    var direction = 1;
+    	    if (value > reference) {
+    	      // If the current timestamp value is greater than our reference timestamp and we detect a
+    	      // timestamp rollover, this means the roll over is happening in the opposite direction.
+    	      // Example scenario: Enter a long stream/video just after a rollover occurred. The reference
+    	      // point will be set to a small number, e.g. 1. The user then seeks backwards over the
+    	      // rollover point. In loading this segment, the timestamp values will be very large,
+    	      // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust
+    	      // the time stamp to be `value - 2^33`.
+    	      direction = -1;
+    	    }
+
+    	    // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will
+    	    // cause an incorrect adjustment.
+    	    while (Math.abs(reference - value) > RO_THRESH) {
+    	      value += direction * MAX_TS;
+    	    }
+    	    return value;
+    	  };
+    	  var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {
+    	    var lastDTS, referenceDTS;
+    	    TimestampRolloverStream.prototype.init.call(this);
+
+    	    // The "shared" type is used in cases where a stream will contain muxed
+    	    // video and audio. We could use `undefined` here, but having a string
+    	    // makes debugging a little clearer.
+    	    this.type_ = type || TYPE_SHARED;
+    	    this.push = function (data) {
+    	      // Any "shared" rollover streams will accept _all_ data. Otherwise,
+    	      // streams will only accept data that matches their type.
+    	      if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {
+    	        return;
+    	      }
+    	      if (referenceDTS === undefined) {
+    	        referenceDTS = data.dts;
+    	      }
+    	      data.dts = handleRollover(data.dts, referenceDTS);
+    	      data.pts = handleRollover(data.pts, referenceDTS);
+    	      lastDTS = data.dts;
+    	      this.trigger('data', data);
+    	    };
+    	    this.flush = function () {
+    	      referenceDTS = lastDTS;
+    	      this.trigger('done');
+    	    };
+    	    this.endTimeline = function () {
+    	      this.flush();
+    	      this.trigger('endedtimeline');
+    	    };
+    	    this.discontinuity = function () {
+    	      referenceDTS = void 0;
+    	      lastDTS = void 0;
+    	    };
+    	    this.reset = function () {
+    	      this.discontinuity();
+    	      this.trigger('reset');
+    	    };
+    	  };
+    	  TimestampRolloverStream$1.prototype = new stream();
+    	  var timestampRolloverStream = {
+    	    TimestampRolloverStream: TimestampRolloverStream$1,
+    	    handleRollover: handleRollover
+    	  };
+
+    	  // IE11 doesn't support indexOf for TypedArrays.
+    	  // Once IE11 support is dropped, this function should be removed.
+    	  var typedArrayIndexOf$1 = function typedArrayIndexOf(typedArray, element, fromIndex) {
+    	    if (!typedArray) {
+    	      return -1;
+    	    }
+    	    var currentIndex = fromIndex;
+    	    for (; currentIndex < typedArray.length; currentIndex++) {
+    	      if (typedArray[currentIndex] === element) {
+    	        return currentIndex;
+    	      }
+    	    }
+    	    return -1;
+    	  };
+    	  var typedArray = {
+    	    typedArrayIndexOf: typedArrayIndexOf$1
+    	  };
+
+    	  var typedArrayIndexOf = typedArray.typedArrayIndexOf,
+    	    // Frames that allow different types of text encoding contain a text
+    	    // encoding description byte [ID3v2.4.0 section 4.]
+    	    textEncodingDescriptionByte = {
+    	      Iso88591: 0x00,
+    	      // ISO-8859-1, terminated with \0.
+    	      Utf16: 0x01,
+    	      // UTF-16 encoded Unicode BOM, terminated with \0\0
+    	      Utf16be: 0x02,
+    	      // UTF-16BE encoded Unicode, without BOM, terminated with \0\0
+    	      Utf8: 0x03 // UTF-8 encoded Unicode, terminated with \0
+    	    },
+    	    // return a percent-encoded representation of the specified byte range
+    	    // @see http://en.wikipedia.org/wiki/Percent-encoding 
+    	    percentEncode$1 = function percentEncode(bytes, start, end) {
+    	      var i,
+    	        result = '';
+    	      for (i = start; i < end; i++) {
+    	        result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+    	      }
+    	      return result;
+    	    },
+    	    // return the string representation of the specified byte range,
+    	    // interpreted as UTf-8.
+    	    parseUtf8 = function parseUtf8(bytes, start, end) {
+    	      return decodeURIComponent(percentEncode$1(bytes, start, end));
+    	    },
+    	    // return the string representation of the specified byte range,
+    	    // interpreted as ISO-8859-1.
+    	    parseIso88591$1 = function parseIso88591(bytes, start, end) {
+    	      return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line
+    	    },
+    	    parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {
+    	      return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+    	    },
+    	    frameParsers = {
+    	      'APIC': function APIC(frame) {
+    	        var i = 1,
+    	          mimeTypeEndIndex,
+    	          descriptionEndIndex,
+    	          LINK_MIME_TYPE = '-->';
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+
+    	        // parsing fields [ID3v2.4.0 section 4.14.]
+    	        mimeTypeEndIndex = typedArrayIndexOf(frame.data, 0, i);
+    	        if (mimeTypeEndIndex < 0) {
+    	          // malformed frame
+    	          return;
+    	        }
+
+    	        // parsing Mime type field (terminated with \0)
+    	        frame.mimeType = parseIso88591$1(frame.data, i, mimeTypeEndIndex);
+    	        i = mimeTypeEndIndex + 1;
+
+    	        // parsing 1-byte Picture Type field
+    	        frame.pictureType = frame.data[i];
+    	        i++;
+    	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, i);
+    	        if (descriptionEndIndex < 0) {
+    	          // malformed frame
+    	          return;
+    	        }
+
+    	        // parsing Description field (terminated with \0)
+    	        frame.description = parseUtf8(frame.data, i, descriptionEndIndex);
+    	        i = descriptionEndIndex + 1;
+    	        if (frame.mimeType === LINK_MIME_TYPE) {
+    	          // parsing Picture Data field as URL (always represented as ISO-8859-1 [ID3v2.4.0 section 4.])
+    	          frame.url = parseIso88591$1(frame.data, i, frame.data.length);
+    	        } else {
+    	          // parsing Picture Data field as binary data
+    	          frame.pictureData = frame.data.subarray(i, frame.data.length);
+    	        }
+    	      },
+    	      'T*': function T(frame) {
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+
+    	        // parse text field, do not include null terminator in the frame value
+    	        // frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
+    	        frame.value = parseUtf8(frame.data, 1, frame.data.length).replace(/\0*$/, '');
+    	        // text information frames supports multiple strings, stored as a terminator separated list [ID3v2.4.0 section 4.2.]
+    	        frame.values = frame.value.split('\0');
+    	      },
+    	      'TXXX': function TXXX(frame) {
+    	        var descriptionEndIndex;
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+    	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+    	        if (descriptionEndIndex === -1) {
+    	          return;
+    	        }
+
+    	        // parse the text fields
+    	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+    	        // do not include the null terminator in the tag value
+    	        // frames that allow different types of encoding contain terminated text
+    	        // [ID3v2.4.0 section 4.]
+    	        frame.value = parseUtf8(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0*$/, '');
+    	        frame.data = frame.value;
+    	      },
+    	      'W*': function W(frame) {
+    	        // parse URL field; URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+    	        // if the value is followed by a string termination all the following information should be ignored [ID3v2.4.0 section 4.3]
+    	        frame.url = parseIso88591$1(frame.data, 0, frame.data.length).replace(/\0.*$/, '');
+    	      },
+    	      'WXXX': function WXXX(frame) {
+    	        var descriptionEndIndex;
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+    	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+    	        if (descriptionEndIndex === -1) {
+    	          return;
+    	        }
+
+    	        // parse the description and URL fields
+    	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+    	        // URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+    	        // if the value is followed by a string termination all the following information
+    	        // should be ignored [ID3v2.4.0 section 4.3]
+    	        frame.url = parseIso88591$1(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0.*$/, '');
+    	      },
+    	      'PRIV': function PRIV(frame) {
+    	        var i;
+    	        for (i = 0; i < frame.data.length; i++) {
+    	          if (frame.data[i] === 0) {
+    	            // parse the description and URL fields
+    	            frame.owner = parseIso88591$1(frame.data, 0, i);
+    	            break;
+    	          }
+    	        }
+    	        frame.privateData = frame.data.subarray(i + 1);
+    	        frame.data = frame.privateData;
+    	      }
+    	    };
+    	  var parseId3Frames = function parseId3Frames(data) {
+    	    var frameSize,
+    	      frameHeader,
+    	      frameStart = 10,
+    	      tagSize = 0,
+    	      frames = [];
+
+    	    // If we don't have enough data for a header, 10 bytes, 
+    	    // or 'ID3' in the first 3 bytes this is not a valid ID3 tag.
+    	    if (data.length < 10 || data[0] !== 'I'.charCodeAt(0) || data[1] !== 'D'.charCodeAt(0) || data[2] !== '3'.charCodeAt(0)) {
+    	      return;
+    	    }
+    	    // the frame size is transmitted as a 28-bit integer in the
+    	    // last four bytes of the ID3 header.
+    	    // The most significant bit of each byte is dropped and the
+    	    // results concatenated to recover the actual value.
+    	    tagSize = parseSyncSafeInteger$1(data.subarray(6, 10));
+
+    	    // ID3 reports the tag size excluding the header but it's more
+    	    // convenient for our comparisons to include it
+    	    tagSize += 10;
+    	    // check bit 6 of byte 5 for the extended header flag.
+    	    var hasExtendedHeader = data[5] & 0x40;
+    	    if (hasExtendedHeader) {
+    	      // advance the frame start past the extended header
+    	      frameStart += 4; // header size field
+    	      frameStart += parseSyncSafeInteger$1(data.subarray(10, 14));
+    	      tagSize -= parseSyncSafeInteger$1(data.subarray(16, 20)); // clip any padding off the end
+    	    }
+
+    	    // parse one or more ID3 frames
+    	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    	    do {
+    	      // determine the number of bytes in this frame
+    	      frameSize = parseSyncSafeInteger$1(data.subarray(frameStart + 4, frameStart + 8));
+    	      if (frameSize < 1) {
+    	        break;
+    	      }
+    	      frameHeader = String.fromCharCode(data[frameStart], data[frameStart + 1], data[frameStart + 2], data[frameStart + 3]);
+    	      var frame = {
+    	        id: frameHeader,
+    	        data: data.subarray(frameStart + 10, frameStart + frameSize + 10)
+    	      };
+    	      frame.key = frame.id;
+
+    	      // parse frame values
+    	      if (frameParsers[frame.id]) {
+    	        // use frame specific parser
+    	        frameParsers[frame.id](frame);
+    	      } else if (frame.id[0] === 'T') {
+    	        // use text frame generic parser
+    	        frameParsers['T*'](frame);
+    	      } else if (frame.id[0] === 'W') {
+    	        // use URL link frame generic parser
+    	        frameParsers['W*'](frame);
+    	      }
+    	      frames.push(frame);
+    	      frameStart += 10; // advance past the frame header
+    	      frameStart += frameSize; // advance past the frame body
+    	    } while (frameStart < tagSize);
+    	    return frames;
+    	  };
+    	  var parseId3 = {
+    	    parseId3Frames: parseId3Frames,
+    	    parseSyncSafeInteger: parseSyncSafeInteger$1,
+    	    frameParsers: frameParsers
+    	  };
+
+    	  var _MetadataStream;
+    	  _MetadataStream = function MetadataStream(options) {
+    	    var settings = {
+    	        // the bytes of the program-level descriptor field in MP2T
+    	        // see ISO/IEC 13818-1:2013 (E), section 2.6 "Program and
+    	        // program element descriptors"
+    	        descriptor: options && options.descriptor
+    	      },
+    	      // the total size in bytes of the ID3 tag being parsed
+    	      tagSize = 0,
+    	      // tag data that is not complete enough to be parsed
+    	      buffer = [],
+    	      // the total number of bytes currently in the buffer
+    	      bufferSize = 0,
+    	      i;
+    	    _MetadataStream.prototype.init.call(this);
+
+    	    // calculate the text track in-band metadata track dispatch type
+    	    // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
+    	    this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);
+    	    if (settings.descriptor) {
+    	      for (i = 0; i < settings.descriptor.length; i++) {
+    	        this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);
+    	      }
+    	    }
+    	    this.push = function (chunk) {
+    	      var tag, frameStart, frameSize, frame, i, frameHeader;
+    	      if (chunk.type !== 'timed-metadata') {
+    	        return;
+    	      }
+
+    	      // if data_alignment_indicator is set in the PES header,
+    	      // we must have the start of a new ID3 tag. Assume anything
+    	      // remaining in the buffer was malformed and throw it out
+    	      if (chunk.dataAlignmentIndicator) {
+    	        bufferSize = 0;
+    	        buffer.length = 0;
+    	      }
+
+    	      // ignore events that don't look like ID3 data
+    	      if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {
+    	        this.trigger('log', {
+    	          level: 'warn',
+    	          message: 'Skipping unrecognized metadata packet'
+    	        });
+    	        return;
+    	      }
+
+    	      // add this chunk to the data we've collected so far
+
+    	      buffer.push(chunk);
+    	      bufferSize += chunk.data.byteLength;
+
+    	      // grab the size of the entire frame from the ID3 header
+    	      if (buffer.length === 1) {
+    	        // the frame size is transmitted as a 28-bit integer in the
+    	        // last four bytes of the ID3 header.
+    	        // The most significant bit of each byte is dropped and the
+    	        // results concatenated to recover the actual value.
+    	        tagSize = parseId3.parseSyncSafeInteger(chunk.data.subarray(6, 10));
+
+    	        // ID3 reports the tag size excluding the header but it's more
+    	        // convenient for our comparisons to include it
+    	        tagSize += 10;
+    	      }
+
+    	      // if the entire frame has not arrived, wait for more data
+    	      if (bufferSize < tagSize) {
+    	        return;
+    	      }
+
+    	      // collect the entire frame so it can be parsed
+    	      tag = {
+    	        data: new Uint8Array(tagSize),
+    	        frames: [],
+    	        pts: buffer[0].pts,
+    	        dts: buffer[0].dts
+    	      };
+    	      for (i = 0; i < tagSize;) {
+    	        tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);
+    	        i += buffer[0].data.byteLength;
+    	        bufferSize -= buffer[0].data.byteLength;
+    	        buffer.shift();
+    	      }
+
+    	      // find the start of the first frame and the end of the tag
+    	      frameStart = 10;
+    	      if (tag.data[5] & 0x40) {
+    	        // advance the frame start past the extended header
+    	        frameStart += 4; // header size field
+    	        frameStart += parseId3.parseSyncSafeInteger(tag.data.subarray(10, 14));
+
+    	        // clip any padding off the end
+    	        tagSize -= parseId3.parseSyncSafeInteger(tag.data.subarray(16, 20));
+    	      }
+
+    	      // parse one or more ID3 frames
+    	      // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    	      do {
+    	        // determine the number of bytes in this frame
+    	        frameSize = parseId3.parseSyncSafeInteger(tag.data.subarray(frameStart + 4, frameStart + 8));
+    	        if (frameSize < 1) {
+    	          this.trigger('log', {
+    	            level: 'warn',
+    	            message: 'Malformed ID3 frame encountered. Skipping remaining metadata parsing.'
+    	          });
+    	          // If the frame is malformed, don't parse any further frames but allow previous valid parsed frames
+    	          // to be sent along.
+    	          break;
+    	        }
+    	        frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);
+    	        frame = {
+    	          id: frameHeader,
+    	          data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)
+    	        };
+    	        frame.key = frame.id;
+
+    	        // parse frame values
+    	        if (parseId3.frameParsers[frame.id]) {
+    	          // use frame specific parser
+    	          parseId3.frameParsers[frame.id](frame);
+    	        } else if (frame.id[0] === 'T') {
+    	          // use text frame generic parser
+    	          parseId3.frameParsers['T*'](frame);
+    	        } else if (frame.id[0] === 'W') {
+    	          // use URL link frame generic parser
+    	          parseId3.frameParsers['W*'](frame);
+    	        }
+
+    	        // handle the special PRIV frame used to indicate the start
+    	        // time for raw AAC data
+    	        if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {
+    	          var d = frame.data,
+    	            size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+    	          size *= 4;
+    	          size += d[7] & 0x03;
+    	          frame.timeStamp = size;
+    	          // in raw AAC, all subsequent data will be timestamped based
+    	          // on the value of this frame
+    	          // we couldn't have known the appropriate pts and dts before
+    	          // parsing this ID3 tag so set those values now
+    	          if (tag.pts === undefined && tag.dts === undefined) {
+    	            tag.pts = frame.timeStamp;
+    	            tag.dts = frame.timeStamp;
+    	          }
+    	          this.trigger('timestamp', frame);
+    	        }
+    	        tag.frames.push(frame);
+    	        frameStart += 10; // advance past the frame header
+    	        frameStart += frameSize; // advance past the frame body
+    	      } while (frameStart < tagSize);
+    	      this.trigger('data', tag);
+    	    };
+    	  };
+    	  _MetadataStream.prototype = new stream();
+    	  var metadataStream = _MetadataStream;
+
+    	  var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream;
+
+    	  // object types
+    	  var _TransportPacketStream, _TransportParseStream, _ElementaryStream;
+
+    	  // constants
+    	  var MP2T_PACKET_LENGTH = 188,
+    	    // bytes
+    	    SYNC_BYTE = 0x47;
+
+    	  /**
+    	   * Splits an incoming stream of binary data into MPEG-2 Transport
+    	   * Stream packets.
+    	   */
+    	  _TransportPacketStream = function TransportPacketStream() {
+    	    var buffer = new Uint8Array(MP2T_PACKET_LENGTH),
+    	      bytesInBuffer = 0;
+    	    _TransportPacketStream.prototype.init.call(this);
+
+    	    // Deliver new bytes to the stream.
+
+    	    /**
+    	     * Split a stream of data into M2TS packets
+    	    **/
+    	    this.push = function (bytes) {
+    	      var startIndex = 0,
+    	        endIndex = MP2T_PACKET_LENGTH,
+    	        everything;
+
+    	      // If there are bytes remaining from the last segment, prepend them to the
+    	      // bytes that were pushed in
+    	      if (bytesInBuffer) {
+    	        everything = new Uint8Array(bytes.byteLength + bytesInBuffer);
+    	        everything.set(buffer.subarray(0, bytesInBuffer));
+    	        everything.set(bytes, bytesInBuffer);
+    	        bytesInBuffer = 0;
+    	      } else {
+    	        everything = bytes;
+    	      }
+
+    	      // While we have enough data for a packet
+    	      while (endIndex < everything.byteLength) {
+    	        // Look for a pair of start and end sync bytes in the data..
+    	        if (everything[startIndex] === SYNC_BYTE && everything[endIndex] === SYNC_BYTE) {
+    	          // We found a packet so emit it and jump one whole packet forward in
+    	          // the stream
+    	          this.trigger('data', everything.subarray(startIndex, endIndex));
+    	          startIndex += MP2T_PACKET_LENGTH;
+    	          endIndex += MP2T_PACKET_LENGTH;
+    	          continue;
+    	        }
+    	        // If we get here, we have somehow become de-synchronized and we need to step
+    	        // forward one byte at a time until we find a pair of sync bytes that denote
+    	        // a packet
+    	        startIndex++;
+    	        endIndex++;
+    	      }
+
+    	      // If there was some data left over at the end of the segment that couldn't
+    	      // possibly be a whole packet, keep it because it might be the start of a packet
+    	      // that continues in the next segment
+    	      if (startIndex < everything.byteLength) {
+    	        buffer.set(everything.subarray(startIndex), 0);
+    	        bytesInBuffer = everything.byteLength - startIndex;
+    	      }
+    	    };
+
+    	    /**
+    	     * Passes identified M2TS packets to the TransportParseStream to be parsed
+    	    **/
+    	    this.flush = function () {
+    	      // If the buffer contains a whole packet when we are being flushed, emit it
+    	      // and empty the buffer. Otherwise hold onto the data because it may be
+    	      // important for decoding the next segment
+    	      if (bytesInBuffer === MP2T_PACKET_LENGTH && buffer[0] === SYNC_BYTE) {
+    	        this.trigger('data', buffer);
+    	        bytesInBuffer = 0;
+    	      }
+    	      this.trigger('done');
+    	    };
+    	    this.endTimeline = function () {
+    	      this.flush();
+    	      this.trigger('endedtimeline');
+    	    };
+    	    this.reset = function () {
+    	      bytesInBuffer = 0;
+    	      this.trigger('reset');
+    	    };
+    	  };
+    	  _TransportPacketStream.prototype = new stream();
+
+    	  /**
+    	   * Accepts an MP2T TransportPacketStream and emits data events with parsed
+    	   * forms of the individual transport stream packets.
+    	   */
+    	  _TransportParseStream = function TransportParseStream() {
+    	    var parsePsi, parsePat, parsePmt, self;
+    	    _TransportParseStream.prototype.init.call(this);
+    	    self = this;
+    	    this.packetsWaitingForPmt = [];
+    	    this.programMapTable = undefined;
+    	    parsePsi = function parsePsi(payload, psi) {
+    	      var offset = 0;
+
+    	      // PSI packets may be split into multiple sections and those
+    	      // sections may be split into multiple packets. If a PSI
+    	      // section starts in this packet, the payload_unit_start_indicator
+    	      // will be true and the first byte of the payload will indicate
+    	      // the offset from the current position to the start of the
+    	      // section.
+    	      if (psi.payloadUnitStartIndicator) {
+    	        offset += payload[offset] + 1;
+    	      }
+    	      if (psi.type === 'pat') {
+    	        parsePat(payload.subarray(offset), psi);
+    	      } else {
+    	        parsePmt(payload.subarray(offset), psi);
+    	      }
+    	    };
+    	    parsePat = function parsePat(payload, pat) {
+    	      pat.section_number = payload[7]; // eslint-disable-line camelcase
+    	      pat.last_section_number = payload[8]; // eslint-disable-line camelcase
+
+    	      // skip the PSI header and parse the first PMT entry
+    	      self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];
+    	      pat.pmtPid = self.pmtPid;
+    	    };
+
+    	    /**
+    	     * Parse out the relevant fields of a Program Map Table (PMT).
+    	     * @param payload {Uint8Array} the PMT-specific portion of an MP2T
+    	     * packet. The first byte in this array should be the table_id
+    	     * field.
+    	     * @param pmt {object} the object that should be decorated with
+    	     * fields parsed from the PMT.
+    	     */
+    	    parsePmt = function parsePmt(payload, pmt) {
+    	      var sectionLength, tableEnd, programInfoLength, offset;
+
+    	      // PMTs can be sent ahead of the time when they should actually
+    	      // take effect. We don't believe this should ever be the case
+    	      // for HLS but we'll ignore "forward" PMT declarations if we see
+    	      // them. Future PMT declarations have the current_next_indicator
+    	      // set to zero.
+    	      if (!(payload[5] & 0x01)) {
+    	        return;
+    	      }
+
+    	      // overwrite any existing program map table
+    	      self.programMapTable = {
+    	        video: null,
+    	        audio: null,
+    	        'timed-metadata': {}
+    	      };
+
+    	      // the mapping table ends at the end of the current section
+    	      sectionLength = (payload[1] & 0x0f) << 8 | payload[2];
+    	      tableEnd = 3 + sectionLength - 4;
+
+    	      // to determine where the table is, we have to figure out how
+    	      // long the program info descriptors are
+    	      programInfoLength = (payload[10] & 0x0f) << 8 | payload[11];
+
+    	      // advance the offset to the first entry in the mapping table
+    	      offset = 12 + programInfoLength;
+    	      while (offset < tableEnd) {
+    	        var streamType = payload[offset];
+    	        var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2];
+
+    	        // only map a single elementary_pid for audio and video stream types
+    	        // TODO: should this be done for metadata too? for now maintain behavior of
+    	        //       multiple metadata streams
+    	        if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {
+    	          self.programMapTable.video = pid;
+    	        } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {
+    	          self.programMapTable.audio = pid;
+    	        } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {
+    	          // map pid to stream type for metadata streams
+    	          self.programMapTable['timed-metadata'][pid] = streamType;
+    	        }
+
+    	        // move to the next table entry
+    	        // skip past the elementary stream descriptors, if present
+    	        offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;
+    	      }
+
+    	      // record the map on the packet as well
+    	      pmt.programMapTable = self.programMapTable;
+    	    };
+
+    	    /**
+    	     * Deliver a new MP2T packet to the next stream in the pipeline.
+    	     */
+    	    this.push = function (packet) {
+    	      var result = {},
+    	        offset = 4;
+    	      result.payloadUnitStartIndicator = !!(packet[1] & 0x40);
+
+    	      // pid is a 13-bit field starting at the last bit of packet[1]
+    	      result.pid = packet[1] & 0x1f;
+    	      result.pid <<= 8;
+    	      result.pid |= packet[2];
+
+    	      // if an adaption field is present, its length is specified by the
+    	      // fifth byte of the TS packet header. The adaptation field is
+    	      // used to add stuffing to PES packets that don't fill a complete
+    	      // TS packet, and to specify some forms of timing and control data
+    	      // that we do not currently use.
+    	      if ((packet[3] & 0x30) >>> 4 > 0x01) {
+    	        offset += packet[offset] + 1;
+    	      }
+
+    	      // parse the rest of the packet based on the type
+    	      if (result.pid === 0) {
+    	        result.type = 'pat';
+    	        parsePsi(packet.subarray(offset), result);
+    	        this.trigger('data', result);
+    	      } else if (result.pid === this.pmtPid) {
+    	        result.type = 'pmt';
+    	        parsePsi(packet.subarray(offset), result);
+    	        this.trigger('data', result);
+
+    	        // if there are any packets waiting for a PMT to be found, process them now
+    	        while (this.packetsWaitingForPmt.length) {
+    	          this.processPes_.apply(this, this.packetsWaitingForPmt.shift());
+    	        }
+    	      } else if (this.programMapTable === undefined) {
+    	        // When we have not seen a PMT yet, defer further processing of
+    	        // PES packets until one has been parsed
+    	        this.packetsWaitingForPmt.push([packet, offset, result]);
+    	      } else {
+    	        this.processPes_(packet, offset, result);
+    	      }
+    	    };
+    	    this.processPes_ = function (packet, offset, result) {
+    	      // set the appropriate stream type
+    	      if (result.pid === this.programMapTable.video) {
+    	        result.streamType = streamTypes.H264_STREAM_TYPE;
+    	      } else if (result.pid === this.programMapTable.audio) {
+    	        result.streamType = streamTypes.ADTS_STREAM_TYPE;
+    	      } else {
+    	        // if not video or audio, it is timed-metadata or unknown
+    	        // if unknown, streamType will be undefined
+    	        result.streamType = this.programMapTable['timed-metadata'][result.pid];
+    	      }
+    	      result.type = 'pes';
+    	      result.data = packet.subarray(offset);
+    	      this.trigger('data', result);
+    	    };
+    	  };
+    	  _TransportParseStream.prototype = new stream();
+    	  _TransportParseStream.STREAM_TYPES = {
+    	    h264: 0x1b,
+    	    adts: 0x0f
+    	  };
+
+    	  /**
+    	   * Reconsistutes program elementary stream (PES) packets from parsed
+    	   * transport stream packets. That is, if you pipe an
+    	   * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output
+    	   * events will be events which capture the bytes for individual PES
+    	   * packets plus relevant metadata that has been extracted from the
+    	   * container.
+    	   */
+    	  _ElementaryStream = function ElementaryStream() {
+    	    var self = this,
+    	      segmentHadPmt = false,
+    	      // PES packet fragments
+    	      video = {
+    	        data: [],
+    	        size: 0
+    	      },
+    	      audio = {
+    	        data: [],
+    	        size: 0
+    	      },
+    	      timedMetadata = {
+    	        data: [],
+    	        size: 0
+    	      },
+    	      programMapTable,
+    	      parsePes = function parsePes(payload, pes) {
+    	        var ptsDtsFlags;
+    	        var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2];
+    	        // default to an empty array
+    	        pes.data = new Uint8Array();
+    	        // In certain live streams, the start of a TS fragment has ts packets
+    	        // that are frame data that is continuing from the previous fragment. This
+    	        // is to check that the pes data is the start of a new pes payload
+    	        if (startPrefix !== 1) {
+    	          return;
+    	        }
+    	        // get the packet length, this will be 0 for video
+    	        pes.packetLength = 6 + (payload[4] << 8 | payload[5]);
+
+    	        // find out if this packets starts a new keyframe
+    	        pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0;
+    	        // PES packets may be annotated with a PTS value, or a PTS value
+    	        // and a DTS value. Determine what combination of values is
+    	        // available to work with.
+    	        ptsDtsFlags = payload[7];
+
+    	        // PTS and DTS are normally stored as a 33-bit number.  Javascript
+    	        // performs all bitwise operations on 32-bit integers but javascript
+    	        // supports a much greater range (52-bits) of integer using standard
+    	        // mathematical operations.
+    	        // We construct a 31-bit value using bitwise operators over the 31
+    	        // most significant bits and then multiply by 4 (equal to a left-shift
+    	        // of 2) before we add the final 2 least significant bits of the
+    	        // timestamp (equal to an OR.)
+    	        if (ptsDtsFlags & 0xC0) {
+    	          // the PTS and DTS are not written out directly. For information
+    	          // on how they are encoded, see
+    	          // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
+    	          pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;
+    	          pes.pts *= 4; // Left shift by 2
+    	          pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs
+    	          pes.dts = pes.pts;
+    	          if (ptsDtsFlags & 0x40) {
+    	            pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;
+    	            pes.dts *= 4; // Left shift by 2
+    	            pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs
+    	          }
+    	        }
+    	        // the data section starts immediately after the PES header.
+    	        // pes_header_data_length specifies the number of header bytes
+    	        // that follow the last byte of the field.
+    	        pes.data = payload.subarray(9 + payload[8]);
+    	      },
+    	      /**
+    	        * Pass completely parsed PES packets to the next stream in the pipeline
+    	       **/
+    	      flushStream = function flushStream(stream, type, forceFlush) {
+    	        var packetData = new Uint8Array(stream.size),
+    	          event = {
+    	            type: type
+    	          },
+    	          i = 0,
+    	          offset = 0,
+    	          packetFlushable = false,
+    	          fragment;
+
+    	        // do nothing if there is not enough buffered data for a complete
+    	        // PES header
+    	        if (!stream.data.length || stream.size < 9) {
+    	          return;
+    	        }
+    	        event.trackId = stream.data[0].pid;
+
+    	        // reassemble the packet
+    	        for (i = 0; i < stream.data.length; i++) {
+    	          fragment = stream.data[i];
+    	          packetData.set(fragment.data, offset);
+    	          offset += fragment.data.byteLength;
+    	        }
+
+    	        // parse assembled packet's PES header
+    	        parsePes(packetData, event);
+
+    	        // non-video PES packets MUST have a non-zero PES_packet_length
+    	        // check that there is enough stream data to fill the packet
+    	        packetFlushable = type === 'video' || event.packetLength <= stream.size;
+
+    	        // flush pending packets if the conditions are right
+    	        if (forceFlush || packetFlushable) {
+    	          stream.size = 0;
+    	          stream.data.length = 0;
+    	        }
+
+    	        // only emit packets that are complete. this is to avoid assembling
+    	        // incomplete PES packets due to poor segmentation
+    	        if (packetFlushable) {
+    	          self.trigger('data', event);
+    	        }
+    	      };
+    	    _ElementaryStream.prototype.init.call(this);
+
+    	    /**
+    	     * Identifies M2TS packet types and parses PES packets using metadata
+    	     * parsed from the PMT
+    	     **/
+    	    this.push = function (data) {
+    	      ({
+    	        pat: function pat() {
+    	          // we have to wait for the PMT to arrive as well before we
+    	          // have any meaningful metadata
+    	        },
+    	        pes: function pes() {
+    	          var stream, streamType;
+    	          switch (data.streamType) {
+    	            case streamTypes.H264_STREAM_TYPE:
+    	              stream = video;
+    	              streamType = 'video';
+    	              break;
+    	            case streamTypes.ADTS_STREAM_TYPE:
+    	              stream = audio;
+    	              streamType = 'audio';
+    	              break;
+    	            case streamTypes.METADATA_STREAM_TYPE:
+    	              stream = timedMetadata;
+    	              streamType = 'timed-metadata';
+    	              break;
+    	            default:
+    	              // ignore unknown stream types
+    	              return;
+    	          }
+
+    	          // if a new packet is starting, we can flush the completed
+    	          // packet
+    	          if (data.payloadUnitStartIndicator) {
+    	            flushStream(stream, streamType, true);
+    	          }
+
+    	          // buffer this fragment until we are sure we've received the
+    	          // complete payload
+    	          stream.data.push(data);
+    	          stream.size += data.data.byteLength;
+    	        },
+    	        pmt: function pmt() {
+    	          var event = {
+    	            type: 'metadata',
+    	            tracks: []
+    	          };
+    	          programMapTable = data.programMapTable;
+
+    	          // translate audio and video streams to tracks
+    	          if (programMapTable.video !== null) {
+    	            event.tracks.push({
+    	              timelineStartInfo: {
+    	                baseMediaDecodeTime: 0
+    	              },
+    	              id: +programMapTable.video,
+    	              codec: 'avc',
+    	              type: 'video'
+    	            });
+    	          }
+    	          if (programMapTable.audio !== null) {
+    	            event.tracks.push({
+    	              timelineStartInfo: {
+    	                baseMediaDecodeTime: 0
+    	              },
+    	              id: +programMapTable.audio,
+    	              codec: 'adts',
+    	              type: 'audio'
+    	            });
+    	          }
+    	          segmentHadPmt = true;
+    	          self.trigger('data', event);
+    	        }
+    	      })[data.type]();
+    	    };
+    	    this.reset = function () {
+    	      video.size = 0;
+    	      video.data.length = 0;
+    	      audio.size = 0;
+    	      audio.data.length = 0;
+    	      this.trigger('reset');
+    	    };
+
+    	    /**
+    	     * Flush any remaining input. Video PES packets may be of variable
+    	     * length. Normally, the start of a new video packet can trigger the
+    	     * finalization of the previous packet. That is not possible if no
+    	     * more video is forthcoming, however. In that case, some other
+    	     * mechanism (like the end of the file) has to be employed. When it is
+    	     * clear that no additional data is forthcoming, calling this method
+    	     * will flush the buffered packets.
+    	     */
+    	    this.flushStreams_ = function () {
+    	      // !!THIS ORDER IS IMPORTANT!!
+    	      // video first then audio
+    	      flushStream(video, 'video');
+    	      flushStream(audio, 'audio');
+    	      flushStream(timedMetadata, 'timed-metadata');
+    	    };
+    	    this.flush = function () {
+    	      // if on flush we haven't had a pmt emitted
+    	      // and we have a pmt to emit. emit the pmt
+    	      // so that we trigger a trackinfo downstream.
+    	      if (!segmentHadPmt && programMapTable) {
+    	        var pmt = {
+    	          type: 'metadata',
+    	          tracks: []
+    	        };
+    	        // translate audio and video streams to tracks
+    	        if (programMapTable.video !== null) {
+    	          pmt.tracks.push({
+    	            timelineStartInfo: {
+    	              baseMediaDecodeTime: 0
+    	            },
+    	            id: +programMapTable.video,
+    	            codec: 'avc',
+    	            type: 'video'
+    	          });
+    	        }
+    	        if (programMapTable.audio !== null) {
+    	          pmt.tracks.push({
+    	            timelineStartInfo: {
+    	              baseMediaDecodeTime: 0
+    	            },
+    	            id: +programMapTable.audio,
+    	            codec: 'adts',
+    	            type: 'audio'
+    	          });
+    	        }
+    	        self.trigger('data', pmt);
+    	      }
+    	      segmentHadPmt = false;
+    	      this.flushStreams_();
+    	      this.trigger('done');
+    	    };
+    	  };
+    	  _ElementaryStream.prototype = new stream();
+    	  var m2ts = {
+    	    PAT_PID: 0x0000,
+    	    MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH,
+    	    TransportPacketStream: _TransportPacketStream,
+    	    TransportParseStream: _TransportParseStream,
+    	    ElementaryStream: _ElementaryStream,
+    	    TimestampRolloverStream: TimestampRolloverStream,
+    	    CaptionStream: captionStream.CaptionStream,
+    	    Cea608Stream: captionStream.Cea608Stream,
+    	    Cea708Stream: captionStream.Cea708Stream,
+    	    MetadataStream: metadataStream
+    	  };
+    	  for (var type in streamTypes) {
+    	    if (streamTypes.hasOwnProperty(type)) {
+    	      m2ts[type] = streamTypes[type];
+    	    }
+    	  }
+    	  var m2ts_1 = m2ts;
+
+    	  var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;
+    	  var _AdtsStream;
+    	  var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+
+    	  /*
+    	   * Accepts a ElementaryStream and emits data events with parsed
+    	   * AAC Audio Frames of the individual packets. Input audio in ADTS
+    	   * format is unpacked and re-emitted as AAC frames.
+    	   *
+    	   * @see http://wiki.multimedia.cx/index.php?title=ADTS
+    	   * @see http://wiki.multimedia.cx/?title=Understanding_AAC
+    	   */
+    	  _AdtsStream = function AdtsStream(handlePartialSegments) {
+    	    var buffer,
+    	      frameNum = 0;
+    	    _AdtsStream.prototype.init.call(this);
+    	    this.skipWarn_ = function (start, end) {
+    	      this.trigger('log', {
+    	        level: 'warn',
+    	        message: "adts skiping bytes " + start + " to " + end + " in frame " + frameNum + " outside syncword"
+    	      });
+    	    };
+    	    this.push = function (packet) {
+    	      var i = 0,
+    	        frameLength,
+    	        protectionSkipBytes,
+    	        oldBuffer,
+    	        sampleCount,
+    	        adtsFrameDuration;
+    	      if (!handlePartialSegments) {
+    	        frameNum = 0;
+    	      }
+    	      if (packet.type !== 'audio') {
+    	        // ignore non-audio data
+    	        return;
+    	      }
+
+    	      // Prepend any data in the buffer to the input data so that we can parse
+    	      // aac frames the cross a PES packet boundary
+    	      if (buffer && buffer.length) {
+    	        oldBuffer = buffer;
+    	        buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);
+    	        buffer.set(oldBuffer);
+    	        buffer.set(packet.data, oldBuffer.byteLength);
+    	      } else {
+    	        buffer = packet.data;
+    	      }
+
+    	      // unpack any ADTS frames which have been fully received
+    	      // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS
+    	      var skip;
+
+    	      // We use i + 7 here because we want to be able to parse the entire header.
+    	      // If we don't have enough bytes to do that, then we definitely won't have a full frame.
+    	      while (i + 7 < buffer.length) {
+    	        // Look for the start of an ADTS header..
+    	        if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {
+    	          if (typeof skip !== 'number') {
+    	            skip = i;
+    	          }
+    	          // If a valid header was not found,  jump one forward and attempt to
+    	          // find a valid ADTS header starting at the next byte
+    	          i++;
+    	          continue;
+    	        }
+    	        if (typeof skip === 'number') {
+    	          this.skipWarn_(skip, i);
+    	          skip = null;
+    	        }
+
+    	        // The protection skip bit tells us if we have 2 bytes of CRC data at the
+    	        // end of the ADTS header
+    	        protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2;
+
+    	        // Frame length is a 13 bit integer starting 16 bits from the
+    	        // end of the sync sequence
+    	        // NOTE: frame length includes the size of the header
+    	        frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;
+    	        sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;
+    	        adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$1 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2];
+
+    	        // If we don't have enough data to actually finish this ADTS frame,
+    	        // then we have to wait for more data
+    	        if (buffer.byteLength - i < frameLength) {
+    	          break;
+    	        }
+
+    	        // Otherwise, deliver the complete AAC frame
+    	        this.trigger('data', {
+    	          pts: packet.pts + frameNum * adtsFrameDuration,
+    	          dts: packet.dts + frameNum * adtsFrameDuration,
+    	          sampleCount: sampleCount,
+    	          audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,
+    	          channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,
+    	          samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],
+    	          samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,
+    	          // assume ISO/IEC 14496-12 AudioSampleEntry default of 16
+    	          samplesize: 16,
+    	          // data is the frame without it's header
+    	          data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)
+    	        });
+    	        frameNum++;
+    	        i += frameLength;
+    	      }
+    	      if (typeof skip === 'number') {
+    	        this.skipWarn_(skip, i);
+    	        skip = null;
+    	      }
+
+    	      // remove processed bytes from the buffer.
+    	      buffer = buffer.subarray(i);
+    	    };
+    	    this.flush = function () {
+    	      frameNum = 0;
+    	      this.trigger('done');
+    	    };
+    	    this.reset = function () {
+    	      buffer = void 0;
+    	      this.trigger('reset');
+    	    };
+    	    this.endTimeline = function () {
+    	      buffer = void 0;
+    	      this.trigger('endedtimeline');
+    	    };
+    	  };
+    	  _AdtsStream.prototype = new stream();
+    	  var adts = _AdtsStream;
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+
+    	  var ExpGolomb;
+
+    	  /**
+    	   * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+    	   * scheme used by h264.
+    	   */
+    	  ExpGolomb = function ExpGolomb(workingData) {
+    	    var
+    	      // the number of bytes left to examine in workingData
+    	      workingBytesAvailable = workingData.byteLength,
+    	      // the current word being examined
+    	      workingWord = 0,
+    	      // :uint
+
+    	      // the number of bits left to examine in the current word
+    	      workingBitsAvailable = 0; // :uint;
+
+    	    // ():uint
+    	    this.length = function () {
+    	      return 8 * workingBytesAvailable;
+    	    };
+
+    	    // ():uint
+    	    this.bitsAvailable = function () {
+    	      return 8 * workingBytesAvailable + workingBitsAvailable;
+    	    };
+
+    	    // ():void
+    	    this.loadWord = function () {
+    	      var position = workingData.byteLength - workingBytesAvailable,
+    	        workingBytes = new Uint8Array(4),
+    	        availableBytes = Math.min(4, workingBytesAvailable);
+    	      if (availableBytes === 0) {
+    	        throw new Error('no bytes available');
+    	      }
+    	      workingBytes.set(workingData.subarray(position, position + availableBytes));
+    	      workingWord = new DataView(workingBytes.buffer).getUint32(0);
+
+    	      // track the amount of workingData that has been processed
+    	      workingBitsAvailable = availableBytes * 8;
+    	      workingBytesAvailable -= availableBytes;
+    	    };
+
+    	    // (count:int):void
+    	    this.skipBits = function (count) {
+    	      var skipBytes; // :int
+    	      if (workingBitsAvailable > count) {
+    	        workingWord <<= count;
+    	        workingBitsAvailable -= count;
+    	      } else {
+    	        count -= workingBitsAvailable;
+    	        skipBytes = Math.floor(count / 8);
+    	        count -= skipBytes * 8;
+    	        workingBytesAvailable -= skipBytes;
+    	        this.loadWord();
+    	        workingWord <<= count;
+    	        workingBitsAvailable -= count;
+    	      }
+    	    };
+
+    	    // (size:int):uint
+    	    this.readBits = function (size) {
+    	      var bits = Math.min(workingBitsAvailable, size),
+    	        // :uint
+    	        valu = workingWord >>> 32 - bits; // :uint
+    	      // if size > 31, handle error
+    	      workingBitsAvailable -= bits;
+    	      if (workingBitsAvailable > 0) {
+    	        workingWord <<= bits;
+    	      } else if (workingBytesAvailable > 0) {
+    	        this.loadWord();
+    	      }
+    	      bits = size - bits;
+    	      if (bits > 0) {
+    	        return valu << bits | this.readBits(bits);
+    	      }
+    	      return valu;
+    	    };
+
+    	    // ():uint
+    	    this.skipLeadingZeros = function () {
+    	      var leadingZeroCount; // :uint
+    	      for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {
+    	        if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {
+    	          // the first bit of working word is 1
+    	          workingWord <<= leadingZeroCount;
+    	          workingBitsAvailable -= leadingZeroCount;
+    	          return leadingZeroCount;
+    	        }
+    	      }
+
+    	      // we exhausted workingWord and still have not found a 1
+    	      this.loadWord();
+    	      return leadingZeroCount + this.skipLeadingZeros();
+    	    };
+
+    	    // ():void
+    	    this.skipUnsignedExpGolomb = function () {
+    	      this.skipBits(1 + this.skipLeadingZeros());
+    	    };
+
+    	    // ():void
+    	    this.skipExpGolomb = function () {
+    	      this.skipBits(1 + this.skipLeadingZeros());
+    	    };
+
+    	    // ():uint
+    	    this.readUnsignedExpGolomb = function () {
+    	      var clz = this.skipLeadingZeros(); // :uint
+    	      return this.readBits(clz + 1) - 1;
+    	    };
+
+    	    // ():int
+    	    this.readExpGolomb = function () {
+    	      var valu = this.readUnsignedExpGolomb(); // :int
+    	      if (0x01 & valu) {
+    	        // the number is odd if the low order bit is set
+    	        return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
+    	      }
+
+    	      return -1 * (valu >>> 1); // divide by two then make it negative
+    	    };
+
+    	    // Some convenience functions
+    	    // :Boolean
+    	    this.readBoolean = function () {
+    	      return this.readBits(1) === 1;
+    	    };
+
+    	    // ():int
+    	    this.readUnsignedByte = function () {
+    	      return this.readBits(8);
+    	    };
+    	    this.loadWord();
+    	  };
+    	  var expGolomb = ExpGolomb;
+
+    	  var _H264Stream, _NalByteStream;
+    	  var PROFILES_WITH_OPTIONAL_SPS_DATA;
+
+    	  /**
+    	   * Accepts a NAL unit byte stream and unpacks the embedded NAL units.
+    	   */
+    	  _NalByteStream = function NalByteStream() {
+    	    var syncPoint = 0,
+    	      i,
+    	      buffer;
+    	    _NalByteStream.prototype.init.call(this);
+
+    	    /*
+    	     * Scans a byte stream and triggers a data event with the NAL units found.
+    	     * @param {Object} data Event received from H264Stream
+    	     * @param {Uint8Array} data.data The h264 byte stream to be scanned
+    	     *
+    	     * @see H264Stream.push
+    	     */
+    	    this.push = function (data) {
+    	      var swapBuffer;
+    	      if (!buffer) {
+    	        buffer = data.data;
+    	      } else {
+    	        swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);
+    	        swapBuffer.set(buffer);
+    	        swapBuffer.set(data.data, buffer.byteLength);
+    	        buffer = swapBuffer;
+    	      }
+    	      var len = buffer.byteLength;
+
+    	      // Rec. ITU-T H.264, Annex B
+    	      // scan for NAL unit boundaries
+
+    	      // a match looks like this:
+    	      // 0 0 1 .. NAL .. 0 0 1
+    	      // ^ sync point        ^ i
+    	      // or this:
+    	      // 0 0 1 .. NAL .. 0 0 0
+    	      // ^ sync point        ^ i
+
+    	      // advance the sync point to a NAL start, if necessary
+    	      for (; syncPoint < len - 3; syncPoint++) {
+    	        if (buffer[syncPoint + 2] === 1) {
+    	          // the sync point is properly aligned
+    	          i = syncPoint + 5;
+    	          break;
+    	        }
+    	      }
+    	      while (i < len) {
+    	        // look at the current byte to determine if we've hit the end of
+    	        // a NAL unit boundary
+    	        switch (buffer[i]) {
+    	          case 0:
+    	            // skip past non-sync sequences
+    	            if (buffer[i - 1] !== 0) {
+    	              i += 2;
+    	              break;
+    	            } else if (buffer[i - 2] !== 0) {
+    	              i++;
+    	              break;
+    	            }
+
+    	            // deliver the NAL unit if it isn't empty
+    	            if (syncPoint + 3 !== i - 2) {
+    	              this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+    	            }
+
+    	            // drop trailing zeroes
+    	            do {
+    	              i++;
+    	            } while (buffer[i] !== 1 && i < len);
+    	            syncPoint = i - 2;
+    	            i += 3;
+    	            break;
+    	          case 1:
+    	            // skip past non-sync sequences
+    	            if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {
+    	              i += 3;
+    	              break;
+    	            }
+
+    	            // deliver the NAL unit
+    	            this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+    	            syncPoint = i - 2;
+    	            i += 3;
+    	            break;
+    	          default:
+    	            // the current byte isn't a one or zero, so it cannot be part
+    	            // of a sync sequence
+    	            i += 3;
+    	            break;
+    	        }
+    	      }
+    	      // filter out the NAL units that were delivered
+    	      buffer = buffer.subarray(syncPoint);
+    	      i -= syncPoint;
+    	      syncPoint = 0;
+    	    };
+    	    this.reset = function () {
+    	      buffer = null;
+    	      syncPoint = 0;
+    	      this.trigger('reset');
+    	    };
+    	    this.flush = function () {
+    	      // deliver the last buffered NAL unit
+    	      if (buffer && buffer.byteLength > 3) {
+    	        this.trigger('data', buffer.subarray(syncPoint + 3));
+    	      }
+    	      // reset the stream state
+    	      buffer = null;
+    	      syncPoint = 0;
+    	      this.trigger('done');
+    	    };
+    	    this.endTimeline = function () {
+    	      this.flush();
+    	      this.trigger('endedtimeline');
+    	    };
+    	  };
+    	  _NalByteStream.prototype = new stream();
+
+    	  // values of profile_idc that indicate additional fields are included in the SPS
+    	  // see Recommendation ITU-T H.264 (4/2013),
+    	  // 7.3.2.1.1 Sequence parameter set data syntax
+    	  PROFILES_WITH_OPTIONAL_SPS_DATA = {
+    	    100: true,
+    	    110: true,
+    	    122: true,
+    	    244: true,
+    	    44: true,
+    	    83: true,
+    	    86: true,
+    	    118: true,
+    	    128: true,
+    	    // TODO: the three profiles below don't
+    	    // appear to have sps data in the specificiation anymore?
+    	    138: true,
+    	    139: true,
+    	    134: true
+    	  };
+
+    	  /**
+    	   * Accepts input from a ElementaryStream and produces H.264 NAL unit data
+    	   * events.
+    	   */
+    	  _H264Stream = function H264Stream() {
+    	    var nalByteStream = new _NalByteStream(),
+    	      self,
+    	      trackId,
+    	      currentPts,
+    	      currentDts,
+    	      discardEmulationPreventionBytes,
+    	      readSequenceParameterSet,
+    	      skipScalingList;
+    	    _H264Stream.prototype.init.call(this);
+    	    self = this;
+
+    	    /*
+    	     * Pushes a packet from a stream onto the NalByteStream
+    	     *
+    	     * @param {Object} packet - A packet received from a stream
+    	     * @param {Uint8Array} packet.data - The raw bytes of the packet
+    	     * @param {Number} packet.dts - Decode timestamp of the packet
+    	     * @param {Number} packet.pts - Presentation timestamp of the packet
+    	     * @param {Number} packet.trackId - The id of the h264 track this packet came from
+    	     * @param {('video'|'audio')} packet.type - The type of packet
+    	     *
+    	     */
+    	    this.push = function (packet) {
+    	      if (packet.type !== 'video') {
+    	        return;
+    	      }
+    	      trackId = packet.trackId;
+    	      currentPts = packet.pts;
+    	      currentDts = packet.dts;
+    	      nalByteStream.push(packet);
+    	    };
+
+    	    /*
+    	     * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps
+    	     * for the NALUs to the next stream component.
+    	     * Also, preprocess caption and sequence parameter NALUs.
+    	     *
+    	     * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`
+    	     * @see NalByteStream.push
+    	     */
+    	    nalByteStream.on('data', function (data) {
+    	      var event = {
+    	        trackId: trackId,
+    	        pts: currentPts,
+    	        dts: currentDts,
+    	        data: data,
+    	        nalUnitTypeCode: data[0] & 0x1f
+    	      };
+    	      switch (event.nalUnitTypeCode) {
+    	        case 0x05:
+    	          event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';
+    	          break;
+    	        case 0x06:
+    	          event.nalUnitType = 'sei_rbsp';
+    	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+    	          break;
+    	        case 0x07:
+    	          event.nalUnitType = 'seq_parameter_set_rbsp';
+    	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+    	          event.config = readSequenceParameterSet(event.escapedRBSP);
+    	          break;
+    	        case 0x08:
+    	          event.nalUnitType = 'pic_parameter_set_rbsp';
+    	          break;
+    	        case 0x09:
+    	          event.nalUnitType = 'access_unit_delimiter_rbsp';
+    	          break;
+    	      }
+    	      // This triggers data on the H264Stream
+    	      self.trigger('data', event);
+    	    });
+    	    nalByteStream.on('done', function () {
+    	      self.trigger('done');
+    	    });
+    	    nalByteStream.on('partialdone', function () {
+    	      self.trigger('partialdone');
+    	    });
+    	    nalByteStream.on('reset', function () {
+    	      self.trigger('reset');
+    	    });
+    	    nalByteStream.on('endedtimeline', function () {
+    	      self.trigger('endedtimeline');
+    	    });
+    	    this.flush = function () {
+    	      nalByteStream.flush();
+    	    };
+    	    this.partialFlush = function () {
+    	      nalByteStream.partialFlush();
+    	    };
+    	    this.reset = function () {
+    	      nalByteStream.reset();
+    	    };
+    	    this.endTimeline = function () {
+    	      nalByteStream.endTimeline();
+    	    };
+
+    	    /**
+    	     * Advance the ExpGolomb decoder past a scaling list. The scaling
+    	     * list is optionally transmitted as part of a sequence parameter
+    	     * set and is not relevant to transmuxing.
+    	     * @param count {number} the number of entries in this scaling list
+    	     * @param expGolombDecoder {object} an ExpGolomb pointed to the
+    	     * start of a scaling list
+    	     * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+    	     */
+    	    skipScalingList = function skipScalingList(count, expGolombDecoder) {
+    	      var lastScale = 8,
+    	        nextScale = 8,
+    	        j,
+    	        deltaScale;
+    	      for (j = 0; j < count; j++) {
+    	        if (nextScale !== 0) {
+    	          deltaScale = expGolombDecoder.readExpGolomb();
+    	          nextScale = (lastScale + deltaScale + 256) % 256;
+    	        }
+    	        lastScale = nextScale === 0 ? lastScale : nextScale;
+    	      }
+    	    };
+
+    	    /**
+    	     * Expunge any "Emulation Prevention" bytes from a "Raw Byte
+    	     * Sequence Payload"
+    	     * @param data {Uint8Array} the bytes of a RBSP from a NAL
+    	     * unit
+    	     * @return {Uint8Array} the RBSP without any Emulation
+    	     * Prevention Bytes
+    	     */
+    	    discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+    	      var length = data.byteLength,
+    	        emulationPreventionBytesPositions = [],
+    	        i = 1,
+    	        newLength,
+    	        newData;
+
+    	      // Find all `Emulation Prevention Bytes`
+    	      while (i < length - 2) {
+    	        if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+    	          emulationPreventionBytesPositions.push(i + 2);
+    	          i += 2;
+    	        } else {
+    	          i++;
+    	        }
+    	      }
+
+    	      // If no Emulation Prevention Bytes were found just return the original
+    	      // array
+    	      if (emulationPreventionBytesPositions.length === 0) {
+    	        return data;
+    	      }
+
+    	      // Create a new array to hold the NAL unit data
+    	      newLength = length - emulationPreventionBytesPositions.length;
+    	      newData = new Uint8Array(newLength);
+    	      var sourceIndex = 0;
+    	      for (i = 0; i < newLength; sourceIndex++, i++) {
+    	        if (sourceIndex === emulationPreventionBytesPositions[0]) {
+    	          // Skip this byte
+    	          sourceIndex++;
+    	          // Remove this position index
+    	          emulationPreventionBytesPositions.shift();
+    	        }
+    	        newData[i] = data[sourceIndex];
+    	      }
+    	      return newData;
+    	    };
+
+    	    /**
+    	     * Read a sequence parameter set and return some interesting video
+    	     * properties. A sequence parameter set is the H264 metadata that
+    	     * describes the properties of upcoming video frames.
+    	     * @param data {Uint8Array} the bytes of a sequence parameter set
+    	     * @return {object} an object with configuration parsed from the
+    	     * sequence parameter set, including the dimensions of the
+    	     * associated video frames.
+    	     */
+    	    readSequenceParameterSet = function readSequenceParameterSet(data) {
+    	      var frameCropLeftOffset = 0,
+    	        frameCropRightOffset = 0,
+    	        frameCropTopOffset = 0,
+    	        frameCropBottomOffset = 0,
+    	        expGolombDecoder,
+    	        profileIdc,
+    	        levelIdc,
+    	        profileCompatibility,
+    	        chromaFormatIdc,
+    	        picOrderCntType,
+    	        numRefFramesInPicOrderCntCycle,
+    	        picWidthInMbsMinus1,
+    	        picHeightInMapUnitsMinus1,
+    	        frameMbsOnlyFlag,
+    	        scalingListCount,
+    	        sarRatio = [1, 1],
+    	        aspectRatioIdc,
+    	        i;
+    	      expGolombDecoder = new expGolomb(data);
+    	      profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc
+    	      profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag
+    	      levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)
+    	      expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id
+
+    	      // some profiles have more optional data we don't need
+    	      if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {
+    	        chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
+    	        if (chromaFormatIdc === 3) {
+    	          expGolombDecoder.skipBits(1); // separate_colour_plane_flag
+    	        }
+
+    	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8
+    	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8
+    	        expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
+    	        if (expGolombDecoder.readBoolean()) {
+    	          // seq_scaling_matrix_present_flag
+    	          scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+    	          for (i = 0; i < scalingListCount; i++) {
+    	            if (expGolombDecoder.readBoolean()) {
+    	              // seq_scaling_list_present_flag[ i ]
+    	              if (i < 6) {
+    	                skipScalingList(16, expGolombDecoder);
+    	              } else {
+    	                skipScalingList(64, expGolombDecoder);
+    	              }
+    	            }
+    	          }
+    	        }
+    	      }
+    	      expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4
+    	      picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
+    	      if (picOrderCntType === 0) {
+    	        expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4
+    	      } else if (picOrderCntType === 1) {
+    	        expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag
+    	        expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic
+    	        expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field
+    	        numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();
+    	        for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+    	          expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]
+    	        }
+    	      }
+
+    	      expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames
+    	      expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
+
+    	      picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+    	      picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+    	      frameMbsOnlyFlag = expGolombDecoder.readBits(1);
+    	      if (frameMbsOnlyFlag === 0) {
+    	        expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag
+    	      }
+
+    	      expGolombDecoder.skipBits(1); // direct_8x8_inference_flag
+    	      if (expGolombDecoder.readBoolean()) {
+    	        // frame_cropping_flag
+    	        frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	        frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	        frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	        frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	      }
+    	      if (expGolombDecoder.readBoolean()) {
+    	        // vui_parameters_present_flag
+    	        if (expGolombDecoder.readBoolean()) {
+    	          // aspect_ratio_info_present_flag
+    	          aspectRatioIdc = expGolombDecoder.readUnsignedByte();
+    	          switch (aspectRatioIdc) {
+    	            case 1:
+    	              sarRatio = [1, 1];
+    	              break;
+    	            case 2:
+    	              sarRatio = [12, 11];
+    	              break;
+    	            case 3:
+    	              sarRatio = [10, 11];
+    	              break;
+    	            case 4:
+    	              sarRatio = [16, 11];
+    	              break;
+    	            case 5:
+    	              sarRatio = [40, 33];
+    	              break;
+    	            case 6:
+    	              sarRatio = [24, 11];
+    	              break;
+    	            case 7:
+    	              sarRatio = [20, 11];
+    	              break;
+    	            case 8:
+    	              sarRatio = [32, 11];
+    	              break;
+    	            case 9:
+    	              sarRatio = [80, 33];
+    	              break;
+    	            case 10:
+    	              sarRatio = [18, 11];
+    	              break;
+    	            case 11:
+    	              sarRatio = [15, 11];
+    	              break;
+    	            case 12:
+    	              sarRatio = [64, 33];
+    	              break;
+    	            case 13:
+    	              sarRatio = [160, 99];
+    	              break;
+    	            case 14:
+    	              sarRatio = [4, 3];
+    	              break;
+    	            case 15:
+    	              sarRatio = [3, 2];
+    	              break;
+    	            case 16:
+    	              sarRatio = [2, 1];
+    	              break;
+    	            case 255:
+    	              {
+    	                sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];
+    	                break;
+    	              }
+    	          }
+    	          if (sarRatio) {
+    	            sarRatio[0] / sarRatio[1];
+    	          }
+    	        }
+    	      }
+    	      return {
+    	        profileIdc: profileIdc,
+    	        levelIdc: levelIdc,
+    	        profileCompatibility: profileCompatibility,
+    	        width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,
+    	        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,
+    	        // sar is sample aspect ratio
+    	        sarRatio: sarRatio
+    	      };
+    	    };
+    	  };
+    	  _H264Stream.prototype = new stream();
+    	  var h264 = {
+    	    H264Stream: _H264Stream,
+    	    NalByteStream: _NalByteStream
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   *
+    	   * Utilities to detect basic properties and metadata about Aac data.
+    	   */
+
+    	  var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+    	  var parseId3TagSize = function parseId3TagSize(header, byteIndex) {
+    	    var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],
+    	      flags = header[byteIndex + 5],
+    	      footerPresent = (flags & 16) >> 4;
+
+    	    // if we get a negative returnSize clamp it to 0
+    	    returnSize = returnSize >= 0 ? returnSize : 0;
+    	    if (footerPresent) {
+    	      return returnSize + 20;
+    	    }
+    	    return returnSize + 10;
+    	  };
+    	  var getId3Offset = function getId3Offset(data, offset) {
+    	    if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {
+    	      return offset;
+    	    }
+    	    offset += parseId3TagSize(data, offset);
+    	    return getId3Offset(data, offset);
+    	  };
+
+    	  // TODO: use vhs-utils
+    	  var isLikelyAacData$1 = function isLikelyAacData(data) {
+    	    var offset = getId3Offset(data, 0);
+    	    return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 &&
+    	    // verify that the 2 layer bits are 0, aka this
+    	    // is not mp3 data but aac data.
+    	    (data[offset + 1] & 0x16) === 0x10;
+    	  };
+    	  var parseSyncSafeInteger = function parseSyncSafeInteger(data) {
+    	    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+    	  };
+
+    	  // return a percent-encoded representation of the specified byte range
+    	  // @see http://en.wikipedia.org/wiki/Percent-encoding
+    	  var percentEncode = function percentEncode(bytes, start, end) {
+    	    var i,
+    	      result = '';
+    	    for (i = start; i < end; i++) {
+    	      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+    	    }
+    	    return result;
+    	  };
+
+    	  // return the string representation of the specified byte range,
+    	  // interpreted as ISO-8859-1.
+    	  var parseIso88591 = function parseIso88591(bytes, start, end) {
+    	    return unescape(percentEncode(bytes, start, end)); // jshint ignore:line
+    	  };
+
+    	  var parseAdtsSize = function parseAdtsSize(header, byteIndex) {
+    	    var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,
+    	      middle = header[byteIndex + 4] << 3,
+    	      highTwo = header[byteIndex + 3] & 0x3 << 11;
+    	    return highTwo | middle | lowThree;
+    	  };
+    	  var parseType = function parseType(header, byteIndex) {
+    	    if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {
+    	      return 'timed-metadata';
+    	    } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {
+    	      return 'audio';
+    	    }
+    	    return null;
+    	  };
+    	  var parseSampleRate = function parseSampleRate(packet) {
+    	    var i = 0;
+    	    while (i + 5 < packet.length) {
+    	      if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {
+    	        // If a valid header was not found,  jump one forward and attempt to
+    	        // find a valid ADTS header starting at the next byte
+    	        i++;
+    	        continue;
+    	      }
+    	      return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];
+    	    }
+    	    return null;
+    	  };
+    	  var parseAacTimestamp = function parseAacTimestamp(packet) {
+    	    var frameStart, frameSize, frame, frameHeader;
+
+    	    // find the start of the first frame and the end of the tag
+    	    frameStart = 10;
+    	    if (packet[5] & 0x40) {
+    	      // advance the frame start past the extended header
+    	      frameStart += 4; // header size field
+    	      frameStart += parseSyncSafeInteger(packet.subarray(10, 14));
+    	    }
+
+    	    // parse one or more ID3 frames
+    	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    	    do {
+    	      // determine the number of bytes in this frame
+    	      frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));
+    	      if (frameSize < 1) {
+    	        return null;
+    	      }
+    	      frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);
+    	      if (frameHeader === 'PRIV') {
+    	        frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);
+    	        for (var i = 0; i < frame.byteLength; i++) {
+    	          if (frame[i] === 0) {
+    	            var owner = parseIso88591(frame, 0, i);
+    	            if (owner === 'com.apple.streaming.transportStreamTimestamp') {
+    	              var d = frame.subarray(i + 1);
+    	              var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+    	              size *= 4;
+    	              size += d[7] & 0x03;
+    	              return size;
+    	            }
+    	            break;
+    	          }
+    	        }
+    	      }
+    	      frameStart += 10; // advance past the frame header
+    	      frameStart += frameSize; // advance past the frame body
+    	    } while (frameStart < packet.byteLength);
+    	    return null;
+    	  };
+    	  var utils = {
+    	    isLikelyAacData: isLikelyAacData$1,
+    	    parseId3TagSize: parseId3TagSize,
+    	    parseAdtsSize: parseAdtsSize,
+    	    parseType: parseType,
+    	    parseSampleRate: parseSampleRate,
+    	    parseAacTimestamp: parseAacTimestamp
+    	  };
+
+    	  // Constants
+    	  var _AacStream;
+
+    	  /**
+    	   * Splits an incoming stream of binary data into ADTS and ID3 Frames.
+    	   */
+
+    	  _AacStream = function AacStream() {
+    	    var everything = new Uint8Array(),
+    	      timeStamp = 0;
+    	    _AacStream.prototype.init.call(this);
+    	    this.setTimestamp = function (timestamp) {
+    	      timeStamp = timestamp;
+    	    };
+    	    this.push = function (bytes) {
+    	      var frameSize = 0,
+    	        byteIndex = 0,
+    	        bytesLeft,
+    	        chunk,
+    	        packet,
+    	        tempLength;
+
+    	      // If there are bytes remaining from the last segment, prepend them to the
+    	      // bytes that were pushed in
+    	      if (everything.length) {
+    	        tempLength = everything.length;
+    	        everything = new Uint8Array(bytes.byteLength + tempLength);
+    	        everything.set(everything.subarray(0, tempLength));
+    	        everything.set(bytes, tempLength);
+    	      } else {
+    	        everything = bytes;
+    	      }
+    	      while (everything.length - byteIndex >= 3) {
+    	        if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {
+    	          // Exit early because we don't have enough to parse
+    	          // the ID3 tag header
+    	          if (everything.length - byteIndex < 10) {
+    	            break;
+    	          }
+
+    	          // check framesize
+    	          frameSize = utils.parseId3TagSize(everything, byteIndex);
+
+    	          // Exit early if we don't have enough in the buffer
+    	          // to emit a full packet
+    	          // Add to byteIndex to support multiple ID3 tags in sequence
+    	          if (byteIndex + frameSize > everything.length) {
+    	            break;
+    	          }
+    	          chunk = {
+    	            type: 'timed-metadata',
+    	            data: everything.subarray(byteIndex, byteIndex + frameSize)
+    	          };
+    	          this.trigger('data', chunk);
+    	          byteIndex += frameSize;
+    	          continue;
+    	        } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {
+    	          // Exit early because we don't have enough to parse
+    	          // the ADTS frame header
+    	          if (everything.length - byteIndex < 7) {
+    	            break;
+    	          }
+    	          frameSize = utils.parseAdtsSize(everything, byteIndex);
+
+    	          // Exit early if we don't have enough in the buffer
+    	          // to emit a full packet
+    	          if (byteIndex + frameSize > everything.length) {
+    	            break;
+    	          }
+    	          packet = {
+    	            type: 'audio',
+    	            data: everything.subarray(byteIndex, byteIndex + frameSize),
+    	            pts: timeStamp,
+    	            dts: timeStamp
+    	          };
+    	          this.trigger('data', packet);
+    	          byteIndex += frameSize;
+    	          continue;
+    	        }
+    	        byteIndex++;
+    	      }
+    	      bytesLeft = everything.length - byteIndex;
+    	      if (bytesLeft > 0) {
+    	        everything = everything.subarray(byteIndex);
+    	      } else {
+    	        everything = new Uint8Array();
+    	      }
+    	    };
+    	    this.reset = function () {
+    	      everything = new Uint8Array();
+    	      this.trigger('reset');
+    	    };
+    	    this.endTimeline = function () {
+    	      everything = new Uint8Array();
+    	      this.trigger('endedtimeline');
+    	    };
+    	  };
+    	  _AacStream.prototype = new stream();
+    	  var aac = _AacStream;
+
+    	  // constants
+    	  var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];
+    	  var audioProperties = AUDIO_PROPERTIES;
+
+    	  var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];
+    	  var videoProperties = VIDEO_PROPERTIES;
+
+    	  var H264Stream = h264.H264Stream;
+    	  var isLikelyAacData = utils.isLikelyAacData;
+    	  var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;
+
+    	  // object types
+    	  var _VideoSegmentStream, _AudioSegmentStream, _Transmuxer, _CoalesceStream;
+    	  var retriggerForStream = function retriggerForStream(key, event) {
+    	    event.stream = key;
+    	    this.trigger('log', event);
+    	  };
+    	  var addPipelineLogRetriggers = function addPipelineLogRetriggers(transmuxer, pipeline) {
+    	    var keys = Object.keys(pipeline);
+    	    for (var i = 0; i < keys.length; i++) {
+    	      var key = keys[i];
+
+    	      // skip non-stream keys and headOfPipeline
+    	      // which is just a duplicate
+    	      if (key === 'headOfPipeline' || !pipeline[key].on) {
+    	        continue;
+    	      }
+    	      pipeline[key].on('log', retriggerForStream.bind(transmuxer, key));
+    	    }
+    	  };
+
+    	  /**
+    	   * Compare two arrays (even typed) for same-ness
+    	   */
+    	  var arrayEquals = function arrayEquals(a, b) {
+    	    var i;
+    	    if (a.length !== b.length) {
+    	      return false;
+    	    }
+
+    	    // compare the value of each element in the array
+    	    for (i = 0; i < a.length; i++) {
+    	      if (a[i] !== b[i]) {
+    	        return false;
+    	      }
+    	    }
+    	    return true;
+    	  };
+    	  var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {
+    	    var ptsOffsetFromDts = startPts - startDts,
+    	      decodeDuration = endDts - startDts,
+    	      presentationDuration = endPts - startPts;
+
+    	    // The PTS and DTS values are based on the actual stream times from the segment,
+    	    // however, the player time values will reflect a start from the baseMediaDecodeTime.
+    	    // In order to provide relevant values for the player times, base timing info on the
+    	    // baseMediaDecodeTime and the DTS and PTS durations of the segment.
+    	    return {
+    	      start: {
+    	        dts: baseMediaDecodeTime,
+    	        pts: baseMediaDecodeTime + ptsOffsetFromDts
+    	      },
+    	      end: {
+    	        dts: baseMediaDecodeTime + decodeDuration,
+    	        pts: baseMediaDecodeTime + presentationDuration
+    	      },
+    	      prependedContentDuration: prependedContentDuration,
+    	      baseMediaDecodeTime: baseMediaDecodeTime
+    	    };
+    	  };
+
+    	  /**
+    	   * Constructs a single-track, ISO BMFF media segment from AAC data
+    	   * events. The output of this stream can be fed to a SourceBuffer
+    	   * configured with a suitable initialization segment.
+    	   * @param track {object} track metadata configuration
+    	   * @param options {object} transmuxer options object
+    	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at 0.
+    	   */
+    	  _AudioSegmentStream = function AudioSegmentStream(track, options) {
+    	    var adtsFrames = [],
+    	      sequenceNumber,
+    	      earliestAllowedDts = 0,
+    	      audioAppendStartTs = 0,
+    	      videoBaseMediaDecodeTime = Infinity;
+    	    options = options || {};
+    	    sequenceNumber = options.firstSequenceNumber || 0;
+    	    _AudioSegmentStream.prototype.init.call(this);
+    	    this.push = function (data) {
+    	      trackDecodeInfo.collectDtsInfo(track, data);
+    	      if (track) {
+    	        audioProperties.forEach(function (prop) {
+    	          track[prop] = data[prop];
+    	        });
+    	      }
+
+    	      // buffer audio data until end() is called
+    	      adtsFrames.push(data);
+    	    };
+    	    this.setEarliestDts = function (earliestDts) {
+    	      earliestAllowedDts = earliestDts;
+    	    };
+    	    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+    	      videoBaseMediaDecodeTime = baseMediaDecodeTime;
+    	    };
+    	    this.setAudioAppendStart = function (timestamp) {
+    	      audioAppendStartTs = timestamp;
+    	    };
+    	    this.flush = function () {
+    	      var frames, moof, mdat, boxes, frameDuration, segmentDuration, videoClockCyclesOfSilencePrefixed;
+
+    	      // return early if no audio data has been observed
+    	      if (adtsFrames.length === 0) {
+    	        this.trigger('done', 'AudioSegmentStream');
+    	        return;
+    	      }
+    	      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);
+    	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+
+    	      // amount of audio filled but the value is in video clock rather than audio clock
+    	      videoClockCyclesOfSilencePrefixed = audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime);
+
+    	      // we have to build the index from byte locations to
+    	      // samples (that is, adts frames) in the audio data
+    	      track.samples = audioFrameUtils.generateSampleTable(frames);
+
+    	      // concatenate the audio data to constuct the mdat
+    	      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));
+    	      adtsFrames = [];
+    	      moof = mp4Generator.moof(sequenceNumber, [track]);
+    	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+    	      // bump the sequence number for next time
+    	      sequenceNumber++;
+    	      boxes.set(moof);
+    	      boxes.set(mdat, moof.byteLength);
+    	      trackDecodeInfo.clearDtsInfo(track);
+    	      frameDuration = Math.ceil(ONE_SECOND_IN_TS * 1024 / track.samplerate);
+
+    	      // TODO this check was added to maintain backwards compatibility (particularly with
+    	      // tests) on adding the timingInfo event. However, it seems unlikely that there's a
+    	      // valid use-case where an init segment/data should be triggered without associated
+    	      // frames. Leaving for now, but should be looked into.
+    	      if (frames.length) {
+    	        segmentDuration = frames.length * frameDuration;
+    	        this.trigger('segmentTimingInfo', generateSegmentTimingInfo(
+    	        // The audio track's baseMediaDecodeTime is in audio clock cycles, but the
+    	        // frame info is in video clock cycles. Convert to match expectation of
+    	        // listeners (that all timestamps will be based on video clock cycles).
+    	        clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate),
+    	        // frame times are already in video clock, as is segment duration
+    	        frames[0].dts, frames[0].pts, frames[0].dts + segmentDuration, frames[0].pts + segmentDuration, videoClockCyclesOfSilencePrefixed || 0));
+    	        this.trigger('timingInfo', {
+    	          start: frames[0].pts,
+    	          end: frames[0].pts + segmentDuration
+    	        });
+    	      }
+    	      this.trigger('data', {
+    	        track: track,
+    	        boxes: boxes
+    	      });
+    	      this.trigger('done', 'AudioSegmentStream');
+    	    };
+    	    this.reset = function () {
+    	      trackDecodeInfo.clearDtsInfo(track);
+    	      adtsFrames = [];
+    	      this.trigger('reset');
+    	    };
+    	  };
+    	  _AudioSegmentStream.prototype = new stream();
+
+    	  /**
+    	   * Constructs a single-track, ISO BMFF media segment from H264 data
+    	   * events. The output of this stream can be fed to a SourceBuffer
+    	   * configured with a suitable initialization segment.
+    	   * @param track {object} track metadata configuration
+    	   * @param options {object} transmuxer options object
+    	   * @param options.alignGopsAtEnd {boolean} If true, start from the end of the
+    	   *        gopsToAlignWith list when attempting to align gop pts
+    	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at 0.
+    	   */
+    	  _VideoSegmentStream = function VideoSegmentStream(track, options) {
+    	    var sequenceNumber,
+    	      nalUnits = [],
+    	      gopsToAlignWith = [],
+    	      config,
+    	      pps;
+    	    options = options || {};
+    	    sequenceNumber = options.firstSequenceNumber || 0;
+    	    _VideoSegmentStream.prototype.init.call(this);
+    	    delete track.minPTS;
+    	    this.gopCache_ = [];
+
+    	    /**
+    	      * Constructs a ISO BMFF segment given H264 nalUnits
+    	      * @param {Object} nalUnit A data event representing a nalUnit
+    	      * @param {String} nalUnit.nalUnitType
+    	      * @param {Object} nalUnit.config Properties for a mp4 track
+    	      * @param {Uint8Array} nalUnit.data The nalUnit bytes
+    	      * @see lib/codecs/h264.js
+    	     **/
+    	    this.push = function (nalUnit) {
+    	      trackDecodeInfo.collectDtsInfo(track, nalUnit);
+
+    	      // record the track config
+    	      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {
+    	        config = nalUnit.config;
+    	        track.sps = [nalUnit.data];
+    	        videoProperties.forEach(function (prop) {
+    	          track[prop] = config[prop];
+    	        }, this);
+    	      }
+    	      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {
+    	        pps = nalUnit.data;
+    	        track.pps = [nalUnit.data];
+    	      }
+
+    	      // buffer video until flush() is called
+    	      nalUnits.push(nalUnit);
+    	    };
+
+    	    /**
+    	      * Pass constructed ISO BMFF track and boxes on to the
+    	      * next stream in the pipeline
+    	     **/
+    	    this.flush = function () {
+    	      var frames,
+    	        gopForFusion,
+    	        gops,
+    	        moof,
+    	        mdat,
+    	        boxes,
+    	        prependedContentDuration = 0,
+    	        firstGop,
+    	        lastGop;
+
+    	      // Throw away nalUnits at the start of the byte stream until
+    	      // we find the first AUD
+    	      while (nalUnits.length) {
+    	        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
+    	          break;
+    	        }
+    	        nalUnits.shift();
+    	      }
+
+    	      // Return early if no video data has been observed
+    	      if (nalUnits.length === 0) {
+    	        this.resetStream_();
+    	        this.trigger('done', 'VideoSegmentStream');
+    	        return;
+    	      }
+
+    	      // Organize the raw nal-units into arrays that represent
+    	      // higher-level constructs such as frames and gops
+    	      // (group-of-pictures)
+    	      frames = frameUtils.groupNalsIntoFrames(nalUnits);
+    	      gops = frameUtils.groupFramesIntoGops(frames);
+
+    	      // If the first frame of this fragment is not a keyframe we have
+    	      // a problem since MSE (on Chrome) requires a leading keyframe.
+    	      //
+    	      // We have two approaches to repairing this situation:
+    	      // 1) GOP-FUSION:
+    	      //    This is where we keep track of the GOPS (group-of-pictures)
+    	      //    from previous fragments and attempt to find one that we can
+    	      //    prepend to the current fragment in order to create a valid
+    	      //    fragment.
+    	      // 2) KEYFRAME-PULLING:
+    	      //    Here we search for the first keyframe in the fragment and
+    	      //    throw away all the frames between the start of the fragment
+    	      //    and that keyframe. We then extend the duration and pull the
+    	      //    PTS of the keyframe forward so that it covers the time range
+    	      //    of the frames that were disposed of.
+    	      //
+    	      // #1 is far prefereable over #2 which can cause "stuttering" but
+    	      // requires more things to be just right.
+    	      if (!gops[0][0].keyFrame) {
+    	        // Search for a gop for fusion from our gopCache
+    	        gopForFusion = this.getGopForFusion_(nalUnits[0], track);
+    	        if (gopForFusion) {
+    	          // in order to provide more accurate timing information about the segment, save
+    	          // the number of seconds prepended to the original segment due to GOP fusion
+    	          prependedContentDuration = gopForFusion.duration;
+    	          gops.unshift(gopForFusion);
+    	          // Adjust Gops' metadata to account for the inclusion of the
+    	          // new gop at the beginning
+    	          gops.byteLength += gopForFusion.byteLength;
+    	          gops.nalCount += gopForFusion.nalCount;
+    	          gops.pts = gopForFusion.pts;
+    	          gops.dts = gopForFusion.dts;
+    	          gops.duration += gopForFusion.duration;
+    	        } else {
+    	          // If we didn't find a candidate gop fall back to keyframe-pulling
+    	          gops = frameUtils.extendFirstKeyFrame(gops);
+    	        }
+    	      }
+
+    	      // Trim gops to align with gopsToAlignWith
+    	      if (gopsToAlignWith.length) {
+    	        var alignedGops;
+    	        if (options.alignGopsAtEnd) {
+    	          alignedGops = this.alignGopsAtEnd_(gops);
+    	        } else {
+    	          alignedGops = this.alignGopsAtStart_(gops);
+    	        }
+    	        if (!alignedGops) {
+    	          // save all the nals in the last GOP into the gop cache
+    	          this.gopCache_.unshift({
+    	            gop: gops.pop(),
+    	            pps: track.pps,
+    	            sps: track.sps
+    	          });
+
+    	          // Keep a maximum of 6 GOPs in the cache
+    	          this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+    	          // Clear nalUnits
+    	          nalUnits = [];
+
+    	          // return early no gops can be aligned with desired gopsToAlignWith
+    	          this.resetStream_();
+    	          this.trigger('done', 'VideoSegmentStream');
+    	          return;
+    	        }
+
+    	        // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct
+    	        // when recalculated before sending off to CoalesceStream
+    	        trackDecodeInfo.clearDtsInfo(track);
+    	        gops = alignedGops;
+    	      }
+    	      trackDecodeInfo.collectDtsInfo(track, gops);
+
+    	      // First, we have to build the index from byte locations to
+    	      // samples (that is, frames) in the video data
+    	      track.samples = frameUtils.generateSampleTable(gops);
+
+    	      // Concatenate the video data and construct the mdat
+    	      mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));
+    	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+    	      this.trigger('processedGopsInfo', gops.map(function (gop) {
+    	        return {
+    	          pts: gop.pts,
+    	          dts: gop.dts,
+    	          byteLength: gop.byteLength
+    	        };
+    	      }));
+    	      firstGop = gops[0];
+    	      lastGop = gops[gops.length - 1];
+    	      this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));
+    	      this.trigger('timingInfo', {
+    	        start: gops[0].pts,
+    	        end: gops[gops.length - 1].pts + gops[gops.length - 1].duration
+    	      });
+
+    	      // save all the nals in the last GOP into the gop cache
+    	      this.gopCache_.unshift({
+    	        gop: gops.pop(),
+    	        pps: track.pps,
+    	        sps: track.sps
+    	      });
+
+    	      // Keep a maximum of 6 GOPs in the cache
+    	      this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+    	      // Clear nalUnits
+    	      nalUnits = [];
+    	      this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);
+    	      this.trigger('timelineStartInfo', track.timelineStartInfo);
+    	      moof = mp4Generator.moof(sequenceNumber, [track]);
+
+    	      // it would be great to allocate this array up front instead of
+    	      // throwing away hundreds of media segment fragments
+    	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+    	      // Bump the sequence number for next time
+    	      sequenceNumber++;
+    	      boxes.set(moof);
+    	      boxes.set(mdat, moof.byteLength);
+    	      this.trigger('data', {
+    	        track: track,
+    	        boxes: boxes
+    	      });
+    	      this.resetStream_();
+
+    	      // Continue with the flush process now
+    	      this.trigger('done', 'VideoSegmentStream');
+    	    };
+    	    this.reset = function () {
+    	      this.resetStream_();
+    	      nalUnits = [];
+    	      this.gopCache_.length = 0;
+    	      gopsToAlignWith.length = 0;
+    	      this.trigger('reset');
+    	    };
+    	    this.resetStream_ = function () {
+    	      trackDecodeInfo.clearDtsInfo(track);
+
+    	      // reset config and pps because they may differ across segments
+    	      // for instance, when we are rendition switching
+    	      config = undefined;
+    	      pps = undefined;
+    	    };
+
+    	    // Search for a candidate Gop for gop-fusion from the gop cache and
+    	    // return it or return null if no good candidate was found
+    	    this.getGopForFusion_ = function (nalUnit) {
+    	      var halfSecond = 45000,
+    	        // Half-a-second in a 90khz clock
+    	        allowableOverlap = 10000,
+    	        // About 3 frames @ 30fps
+    	        nearestDistance = Infinity,
+    	        dtsDistance,
+    	        nearestGopObj,
+    	        currentGop,
+    	        currentGopObj,
+    	        i;
+
+    	      // Search for the GOP nearest to the beginning of this nal unit
+    	      for (i = 0; i < this.gopCache_.length; i++) {
+    	        currentGopObj = this.gopCache_[i];
+    	        currentGop = currentGopObj.gop;
+
+    	        // Reject Gops with different SPS or PPS
+    	        if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {
+    	          continue;
+    	        }
+
+    	        // Reject Gops that would require a negative baseMediaDecodeTime
+    	        if (currentGop.dts < track.timelineStartInfo.dts) {
+    	          continue;
+    	        }
+
+    	        // The distance between the end of the gop and the start of the nalUnit
+    	        dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration;
+
+    	        // Only consider GOPS that start before the nal unit and end within
+    	        // a half-second of the nal unit
+    	        if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {
+    	          // Always use the closest GOP we found if there is more than
+    	          // one candidate
+    	          if (!nearestGopObj || nearestDistance > dtsDistance) {
+    	            nearestGopObj = currentGopObj;
+    	            nearestDistance = dtsDistance;
+    	          }
+    	        }
+    	      }
+    	      if (nearestGopObj) {
+    	        return nearestGopObj.gop;
+    	      }
+    	      return null;
+    	    };
+
+    	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+    	    // of gopsToAlignWith starting from the START of the list
+    	    this.alignGopsAtStart_ = function (gops) {
+    	      var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;
+    	      byteLength = gops.byteLength;
+    	      nalCount = gops.nalCount;
+    	      duration = gops.duration;
+    	      alignIndex = gopIndex = 0;
+    	      while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {
+    	        align = gopsToAlignWith[alignIndex];
+    	        gop = gops[gopIndex];
+    	        if (align.pts === gop.pts) {
+    	          break;
+    	        }
+    	        if (gop.pts > align.pts) {
+    	          // this current gop starts after the current gop we want to align on, so increment
+    	          // align index
+    	          alignIndex++;
+    	          continue;
+    	        }
+
+    	        // current gop starts before the current gop we want to align on. so increment gop
+    	        // index
+    	        gopIndex++;
+    	        byteLength -= gop.byteLength;
+    	        nalCount -= gop.nalCount;
+    	        duration -= gop.duration;
+    	      }
+    	      if (gopIndex === 0) {
+    	        // no gops to trim
+    	        return gops;
+    	      }
+    	      if (gopIndex === gops.length) {
+    	        // all gops trimmed, skip appending all gops
+    	        return null;
+    	      }
+    	      alignedGops = gops.slice(gopIndex);
+    	      alignedGops.byteLength = byteLength;
+    	      alignedGops.duration = duration;
+    	      alignedGops.nalCount = nalCount;
+    	      alignedGops.pts = alignedGops[0].pts;
+    	      alignedGops.dts = alignedGops[0].dts;
+    	      return alignedGops;
+    	    };
+
+    	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+    	    // of gopsToAlignWith starting from the END of the list
+    	    this.alignGopsAtEnd_ = function (gops) {
+    	      var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;
+    	      alignIndex = gopsToAlignWith.length - 1;
+    	      gopIndex = gops.length - 1;
+    	      alignEndIndex = null;
+    	      matchFound = false;
+    	      while (alignIndex >= 0 && gopIndex >= 0) {
+    	        align = gopsToAlignWith[alignIndex];
+    	        gop = gops[gopIndex];
+    	        if (align.pts === gop.pts) {
+    	          matchFound = true;
+    	          break;
+    	        }
+    	        if (align.pts > gop.pts) {
+    	          alignIndex--;
+    	          continue;
+    	        }
+    	        if (alignIndex === gopsToAlignWith.length - 1) {
+    	          // gop.pts is greater than the last alignment candidate. If no match is found
+    	          // by the end of this loop, we still want to append gops that come after this
+    	          // point
+    	          alignEndIndex = gopIndex;
+    	        }
+    	        gopIndex--;
+    	      }
+    	      if (!matchFound && alignEndIndex === null) {
+    	        return null;
+    	      }
+    	      var trimIndex;
+    	      if (matchFound) {
+    	        trimIndex = gopIndex;
+    	      } else {
+    	        trimIndex = alignEndIndex;
+    	      }
+    	      if (trimIndex === 0) {
+    	        return gops;
+    	      }
+    	      var alignedGops = gops.slice(trimIndex);
+    	      var metadata = alignedGops.reduce(function (total, gop) {
+    	        total.byteLength += gop.byteLength;
+    	        total.duration += gop.duration;
+    	        total.nalCount += gop.nalCount;
+    	        return total;
+    	      }, {
+    	        byteLength: 0,
+    	        duration: 0,
+    	        nalCount: 0
+    	      });
+    	      alignedGops.byteLength = metadata.byteLength;
+    	      alignedGops.duration = metadata.duration;
+    	      alignedGops.nalCount = metadata.nalCount;
+    	      alignedGops.pts = alignedGops[0].pts;
+    	      alignedGops.dts = alignedGops[0].dts;
+    	      return alignedGops;
+    	    };
+    	    this.alignGopsWith = function (newGopsToAlignWith) {
+    	      gopsToAlignWith = newGopsToAlignWith;
+    	    };
+    	  };
+    	  _VideoSegmentStream.prototype = new stream();
+
+    	  /**
+    	   * A Stream that can combine multiple streams (ie. audio & video)
+    	   * into a single output segment for MSE. Also supports audio-only
+    	   * and video-only streams.
+    	   * @param options {object} transmuxer options object
+    	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at media timeline start.
+    	   */
+    	  _CoalesceStream = function CoalesceStream(options, metadataStream) {
+    	    // Number of Tracks per output segment
+    	    // If greater than 1, we combine multiple
+    	    // tracks into a single segment
+    	    this.numberOfTracks = 0;
+    	    this.metadataStream = metadataStream;
+    	    options = options || {};
+    	    if (typeof options.remux !== 'undefined') {
+    	      this.remuxTracks = !!options.remux;
+    	    } else {
+    	      this.remuxTracks = true;
+    	    }
+    	    if (typeof options.keepOriginalTimestamps === 'boolean') {
+    	      this.keepOriginalTimestamps = options.keepOriginalTimestamps;
+    	    } else {
+    	      this.keepOriginalTimestamps = false;
+    	    }
+    	    this.pendingTracks = [];
+    	    this.videoTrack = null;
+    	    this.pendingBoxes = [];
+    	    this.pendingCaptions = [];
+    	    this.pendingMetadata = [];
+    	    this.pendingBytes = 0;
+    	    this.emittedTracks = 0;
+    	    _CoalesceStream.prototype.init.call(this);
+
+    	    // Take output from multiple
+    	    this.push = function (output) {
+    	      // buffer incoming captions until the associated video segment
+    	      // finishes
+    	      if (output.text) {
+    	        return this.pendingCaptions.push(output);
+    	      }
+    	      // buffer incoming id3 tags until the final flush
+    	      if (output.frames) {
+    	        return this.pendingMetadata.push(output);
+    	      }
+
+    	      // Add this track to the list of pending tracks and store
+    	      // important information required for the construction of
+    	      // the final segment
+    	      this.pendingTracks.push(output.track);
+    	      this.pendingBytes += output.boxes.byteLength;
+
+    	      // TODO: is there an issue for this against chrome?
+    	      // We unshift audio and push video because
+    	      // as of Chrome 75 when switching from
+    	      // one init segment to another if the video
+    	      // mdat does not appear after the audio mdat
+    	      // only audio will play for the duration of our transmux.
+    	      if (output.track.type === 'video') {
+    	        this.videoTrack = output.track;
+    	        this.pendingBoxes.push(output.boxes);
+    	      }
+    	      if (output.track.type === 'audio') {
+    	        this.audioTrack = output.track;
+    	        this.pendingBoxes.unshift(output.boxes);
+    	      }
+    	    };
+    	  };
+    	  _CoalesceStream.prototype = new stream();
+    	  _CoalesceStream.prototype.flush = function (flushSource) {
+    	    var offset = 0,
+    	      event = {
+    	        captions: [],
+    	        captionStreams: {},
+    	        metadata: [],
+    	        info: {}
+    	      },
+    	      caption,
+    	      id3,
+    	      initSegment,
+    	      timelineStartPts = 0,
+    	      i;
+    	    if (this.pendingTracks.length < this.numberOfTracks) {
+    	      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {
+    	        // Return because we haven't received a flush from a data-generating
+    	        // portion of the segment (meaning that we have only recieved meta-data
+    	        // or captions.)
+    	        return;
+    	      } else if (this.remuxTracks) {
+    	        // Return until we have enough tracks from the pipeline to remux (if we
+    	        // are remuxing audio and video into a single MP4)
+    	        return;
+    	      } else if (this.pendingTracks.length === 0) {
+    	        // In the case where we receive a flush without any data having been
+    	        // received we consider it an emitted track for the purposes of coalescing
+    	        // `done` events.
+    	        // We do this for the case where there is an audio and video track in the
+    	        // segment but no audio data. (seen in several playlists with alternate
+    	        // audio tracks and no audio present in the main TS segments.)
+    	        this.emittedTracks++;
+    	        if (this.emittedTracks >= this.numberOfTracks) {
+    	          this.trigger('done');
+    	          this.emittedTracks = 0;
+    	        }
+    	        return;
+    	      }
+    	    }
+    	    if (this.videoTrack) {
+    	      timelineStartPts = this.videoTrack.timelineStartInfo.pts;
+    	      videoProperties.forEach(function (prop) {
+    	        event.info[prop] = this.videoTrack[prop];
+    	      }, this);
+    	    } else if (this.audioTrack) {
+    	      timelineStartPts = this.audioTrack.timelineStartInfo.pts;
+    	      audioProperties.forEach(function (prop) {
+    	        event.info[prop] = this.audioTrack[prop];
+    	      }, this);
+    	    }
+    	    if (this.videoTrack || this.audioTrack) {
+    	      if (this.pendingTracks.length === 1) {
+    	        event.type = this.pendingTracks[0].type;
+    	      } else {
+    	        event.type = 'combined';
+    	      }
+    	      this.emittedTracks += this.pendingTracks.length;
+    	      initSegment = mp4Generator.initSegment(this.pendingTracks);
+
+    	      // Create a new typed array to hold the init segment
+    	      event.initSegment = new Uint8Array(initSegment.byteLength);
+
+    	      // Create an init segment containing a moov
+    	      // and track definitions
+    	      event.initSegment.set(initSegment);
+
+    	      // Create a new typed array to hold the moof+mdats
+    	      event.data = new Uint8Array(this.pendingBytes);
+
+    	      // Append each moof+mdat (one per track) together
+    	      for (i = 0; i < this.pendingBoxes.length; i++) {
+    	        event.data.set(this.pendingBoxes[i], offset);
+    	        offset += this.pendingBoxes[i].byteLength;
+    	      }
+
+    	      // Translate caption PTS times into second offsets to match the
+    	      // video timeline for the segment, and add track info
+    	      for (i = 0; i < this.pendingCaptions.length; i++) {
+    	        caption = this.pendingCaptions[i];
+    	        caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);
+    	        caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);
+    	        event.captionStreams[caption.stream] = true;
+    	        event.captions.push(caption);
+    	      }
+
+    	      // Translate ID3 frame PTS times into second offsets to match the
+    	      // video timeline for the segment
+    	      for (i = 0; i < this.pendingMetadata.length; i++) {
+    	        id3 = this.pendingMetadata[i];
+    	        id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);
+    	        event.metadata.push(id3);
+    	      }
+
+    	      // We add this to every single emitted segment even though we only need
+    	      // it for the first
+    	      event.metadata.dispatchType = this.metadataStream.dispatchType;
+
+    	      // Reset stream state
+    	      this.pendingTracks.length = 0;
+    	      this.videoTrack = null;
+    	      this.pendingBoxes.length = 0;
+    	      this.pendingCaptions.length = 0;
+    	      this.pendingBytes = 0;
+    	      this.pendingMetadata.length = 0;
+
+    	      // Emit the built segment
+    	      // We include captions and ID3 tags for backwards compatibility,
+    	      // ideally we should send only video and audio in the data event
+    	      this.trigger('data', event);
+    	      // Emit each caption to the outside world
+    	      // Ideally, this would happen immediately on parsing captions,
+    	      // but we need to ensure that video data is sent back first
+    	      // so that caption timing can be adjusted to match video timing
+    	      for (i = 0; i < event.captions.length; i++) {
+    	        caption = event.captions[i];
+    	        this.trigger('caption', caption);
+    	      }
+    	      // Emit each id3 tag to the outside world
+    	      // Ideally, this would happen immediately on parsing the tag,
+    	      // but we need to ensure that video data is sent back first
+    	      // so that ID3 frame timing can be adjusted to match video timing
+    	      for (i = 0; i < event.metadata.length; i++) {
+    	        id3 = event.metadata[i];
+    	        this.trigger('id3Frame', id3);
+    	      }
+    	    }
+
+    	    // Only emit `done` if all tracks have been flushed and emitted
+    	    if (this.emittedTracks >= this.numberOfTracks) {
+    	      this.trigger('done');
+    	      this.emittedTracks = 0;
+    	    }
+    	  };
+    	  _CoalesceStream.prototype.setRemux = function (val) {
+    	    this.remuxTracks = val;
+    	  };
+    	  /**
+    	   * A Stream that expects MP2T binary data as input and produces
+    	   * corresponding media segments, suitable for use with Media Source
+    	   * Extension (MSE) implementations that support the ISO BMFF byte
+    	   * stream format, like Chrome.
+    	   */
+    	  _Transmuxer = function Transmuxer(options) {
+    	    var self = this,
+    	      hasFlushed = true,
+    	      videoTrack,
+    	      audioTrack;
+    	    _Transmuxer.prototype.init.call(this);
+    	    options = options || {};
+    	    var duration = this.duration = options.duration || 0xffffffff;
+    	    this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;
+    	    this.transmuxPipeline_ = {};
+    	    this.setupAacPipeline = function () {
+    	      var pipeline = {};
+    	      this.transmuxPipeline_ = pipeline;
+    	      pipeline.type = 'aac';
+    	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+    	      // set up the parsing pipeline
+    	      pipeline.aacStream = new aac();
+    	      pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');
+    	      pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');
+    	      pipeline.adtsStream = new adts();
+    	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+    	      pipeline.headOfPipeline = pipeline.aacStream;
+    	      pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);
+    	      pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+    	      pipeline.metadataStream.on('timestamp', function (frame) {
+    	        pipeline.aacStream.setTimestamp(frame.timeStamp);
+    	      });
+    	      pipeline.aacStream.on('data', function (data) {
+    	        if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {
+    	          return;
+    	        }
+    	        audioTrack = audioTrack || {
+    	          timelineStartInfo: {
+    	            baseMediaDecodeTime: self.baseMediaDecodeTime
+    	          },
+    	          codec: 'adts',
+    	          type: 'audio'
+    	        };
+    	        // hook up the audio segment stream to the first track with aac data
+    	        pipeline.coalesceStream.numberOfTracks++;
+    	        pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+    	        pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+    	        pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+
+    	        // Set up the final part of the audio pipeline
+    	        pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+
+    	        // emit pmt info
+    	        self.trigger('trackinfo', {
+    	          hasAudio: !!audioTrack,
+    	          hasVideo: !!videoTrack
+    	        });
+    	      });
+
+    	      // Re-emit any data coming from the coalesce stream to the outside world
+    	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+    	      // Let the consumer know we have finished flushing the entire pipeline
+    	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+    	      addPipelineLogRetriggers(this, pipeline);
+    	    };
+    	    this.setupTsPipeline = function () {
+    	      var pipeline = {};
+    	      this.transmuxPipeline_ = pipeline;
+    	      pipeline.type = 'ts';
+    	      pipeline.duration = duration * 9e4;
+    	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+    	      // set up the parsing pipeline
+    	      pipeline.packetStream = new m2ts_1.TransportPacketStream();
+    	      pipeline.parseStream = new m2ts_1.TransportParseStream();
+    	      pipeline.elementaryStream = new m2ts_1.ElementaryStream();
+    	      pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();
+    	      pipeline.adtsStream = new adts();
+    	      pipeline.h264Stream = new H264Stream();
+    	      pipeline.captionStream = new m2ts_1.CaptionStream(options);
+    	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+    	      pipeline.headOfPipeline = pipeline.packetStream;
+
+    	      // disassemble MPEG2-TS packets into elementary streams
+    	      pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream);
+
+    	      // !!THIS ORDER IS IMPORTANT!!
+    	      // demux the streams
+    	      pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);
+    	      pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);
+    	      pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+
+    	      // Hook up CEA-608/708 caption stream
+    	      pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);
+    	      pipeline.elementaryStream.on('data', function (data) {
+    	        var i;
+    	        if (data.type === 'metadata') {
+    	          i = data.tracks.length;
+
+    	          // scan the tracks listed in the metadata
+    	          while (i--) {
+    	            if (!videoTrack && data.tracks[i].type === 'video') {
+    	              videoTrack = data.tracks[i];
+    	              videoTrack.duration = pipeline.duration / 2;
+    	              videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+    	            } else if (!audioTrack && data.tracks[i].type === 'audio') {
+    	              audioTrack = data.tracks[i];
+    	              audioTrack.duration = pipeline.duration / 2;
+    	              audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+    	            }
+    	          }
+
+    	          // hook up the video segment stream to the first track with h264 data
+    	          if (videoTrack && !pipeline.videoSegmentStream) {
+    	            pipeline.coalesceStream.numberOfTracks++;
+    	            pipeline.videoSegmentStream = new _VideoSegmentStream(videoTrack, options);
+    	            pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));
+    	            pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {
+    	              // When video emits timelineStartInfo data after a flush, we forward that
+    	              // info to the AudioSegmentStream, if it exists, because video timeline
+    	              // data takes precedence.  Do not do this if keepOriginalTimestamps is set,
+    	              // because this is a particularly subtle form of timestamp alteration.
+    	              if (audioTrack && !options.keepOriginalTimestamps) {
+    	                audioTrack.timelineStartInfo = timelineStartInfo;
+    	                // On the first segment we trim AAC frames that exist before the
+    	                // very earliest DTS we have seen in video because Chrome will
+    	                // interpret any video track with a baseMediaDecodeTime that is
+    	                // non-zero as a gap.
+    	                pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);
+    	              }
+    	            });
+    	            pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));
+    	            pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));
+    	            pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {
+    	              if (audioTrack) {
+    	                pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);
+    	              }
+    	            });
+    	            pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo'));
+
+    	            // Set up the final part of the video pipeline
+    	            pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);
+    	          }
+    	          if (audioTrack && !pipeline.audioSegmentStream) {
+    	            // hook up the audio segment stream to the first track with aac data
+    	            pipeline.coalesceStream.numberOfTracks++;
+    	            pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+    	            pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+    	            pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+    	            pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo'));
+
+    	            // Set up the final part of the audio pipeline
+    	            pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+    	          }
+
+    	          // emit pmt info
+    	          self.trigger('trackinfo', {
+    	            hasAudio: !!audioTrack,
+    	            hasVideo: !!videoTrack
+    	          });
+    	        }
+    	      });
+
+    	      // Re-emit any data coming from the coalesce stream to the outside world
+    	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+    	      pipeline.coalesceStream.on('id3Frame', function (id3Frame) {
+    	        id3Frame.dispatchType = pipeline.metadataStream.dispatchType;
+    	        self.trigger('id3Frame', id3Frame);
+    	      });
+    	      pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption'));
+    	      // Let the consumer know we have finished flushing the entire pipeline
+    	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+    	      addPipelineLogRetriggers(this, pipeline);
+    	    };
+
+    	    // hook up the segment streams once track metadata is delivered
+    	    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+    	      var pipeline = this.transmuxPipeline_;
+    	      if (!options.keepOriginalTimestamps) {
+    	        this.baseMediaDecodeTime = baseMediaDecodeTime;
+    	      }
+    	      if (audioTrack) {
+    	        audioTrack.timelineStartInfo.dts = undefined;
+    	        audioTrack.timelineStartInfo.pts = undefined;
+    	        trackDecodeInfo.clearDtsInfo(audioTrack);
+    	        if (pipeline.audioTimestampRolloverStream) {
+    	          pipeline.audioTimestampRolloverStream.discontinuity();
+    	        }
+    	      }
+    	      if (videoTrack) {
+    	        if (pipeline.videoSegmentStream) {
+    	          pipeline.videoSegmentStream.gopCache_ = [];
+    	        }
+    	        videoTrack.timelineStartInfo.dts = undefined;
+    	        videoTrack.timelineStartInfo.pts = undefined;
+    	        trackDecodeInfo.clearDtsInfo(videoTrack);
+    	        pipeline.captionStream.reset();
+    	      }
+    	      if (pipeline.timestampRolloverStream) {
+    	        pipeline.timestampRolloverStream.discontinuity();
+    	      }
+    	    };
+    	    this.setAudioAppendStart = function (timestamp) {
+    	      if (audioTrack) {
+    	        this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);
+    	      }
+    	    };
+    	    this.setRemux = function (val) {
+    	      var pipeline = this.transmuxPipeline_;
+    	      options.remux = val;
+    	      if (pipeline && pipeline.coalesceStream) {
+    	        pipeline.coalesceStream.setRemux(val);
+    	      }
+    	    };
+    	    this.alignGopsWith = function (gopsToAlignWith) {
+    	      if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {
+    	        this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);
+    	      }
+    	    };
+    	    this.getLogTrigger_ = function (key) {
+    	      var self = this;
+    	      return function (event) {
+    	        event.stream = key;
+    	        self.trigger('log', event);
+    	      };
+    	    };
+    	    // feed incoming data to the front of the parsing pipeline
+    	    this.push = function (data) {
+    	      if (hasFlushed) {
+    	        var isAac = isLikelyAacData(data);
+    	        if (isAac && this.transmuxPipeline_.type !== 'aac') {
+    	          this.setupAacPipeline();
+    	        } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {
+    	          this.setupTsPipeline();
+    	        }
+    	        hasFlushed = false;
+    	      }
+    	      this.transmuxPipeline_.headOfPipeline.push(data);
+    	    };
+
+    	    // flush any buffered data
+    	    this.flush = function () {
+    	      hasFlushed = true;
+    	      // Start at the top of the pipeline and flush all pending work
+    	      this.transmuxPipeline_.headOfPipeline.flush();
+    	    };
+    	    this.endTimeline = function () {
+    	      this.transmuxPipeline_.headOfPipeline.endTimeline();
+    	    };
+    	    this.reset = function () {
+    	      if (this.transmuxPipeline_.headOfPipeline) {
+    	        this.transmuxPipeline_.headOfPipeline.reset();
+    	      }
+    	    };
+
+    	    // Caption data has to be reset when seeking outside buffered range
+    	    this.resetCaptions = function () {
+    	      if (this.transmuxPipeline_.captionStream) {
+    	        this.transmuxPipeline_.captionStream.reset();
+    	      }
+    	    };
+    	  };
+    	  _Transmuxer.prototype = new stream();
+    	  var transmuxer = _Transmuxer;
+
+    	  return transmuxer;
+
+    	})); 
+    } (mp4Transmuxer));
+
+    var mp4TransmuxerExports = mp4Transmuxer.exports;
+    var Transmuxer = /*@__PURE__*/getDefaultExportFromCjs(mp4TransmuxerExports);
+
     var aesJs = {exports: {}};
 
     /*! MIT License. Copyright 2015-2018 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */
@@ -883,7 +7325,23 @@ var Hls2Mp4 = (function (FFmpeg) {
     var aesJsExports = aesJs.exports;
     var aesjs = /*@__PURE__*/getDefaultExportFromCjs(aesJsExports);
 
-    var createFFmpeg = FFmpeg.createFFmpeg, fetchFile = FFmpeg.fetchFile;
+    function fetchFile(url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, arrayBuffer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch(url)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.arrayBuffer()];
+                    case 2:
+                        arrayBuffer = _a.sent();
+                        return [2 /*return*/, new Uint8Array(arrayBuffer)];
+                }
+            });
+        });
+    }
+
     var TaskType;
     (function (TaskType) {
         TaskType[TaskType["loadFFmeg"] = 0] = "loadFFmeg";
@@ -902,11 +7360,11 @@ var Hls2Mp4 = (function (FFmpeg) {
     }
     var Hls2Mp4 = /** @class */ (function () {
         function Hls2Mp4(_a, onProgress) {
-            var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c, options = __rest(_a, ["maxRetry", "tsDownloadConcurrency"]);
+            var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c;
             this.loadRetryTime = 0;
             this.totalSegments = 0;
-            this.savedSegments = 0;
-            this.instance = createFFmpeg(options);
+            this.duration = 0;
+            this.savedSegments = new Map();
             this.maxRetry = maxRetry;
             this.onProgress = onProgress;
             this.tsDownloadConcurrency = tsDownloadConcurrency;
@@ -1012,7 +7470,7 @@ var Hls2Mp4 = (function (FFmpeg) {
                 var _this = this;
                 return __generator(this, function (_a) {
                     return [2 /*return*/, Promise.all(segs.map(function (_a) {
-                            var name = _a.name, url = _a.url, source = _a.source;
+                            var index = _a.index, url = _a.url;
                             return __awaiter(_this, void 0, void 0, function () {
                                 var tsData, buffer;
                                 var _b;
@@ -1022,14 +7480,9 @@ var Hls2Mp4 = (function (FFmpeg) {
                                         case 1:
                                             tsData = _c.sent();
                                             buffer = key ? this.aesDecrypt(tsData, key, iv) : this.transformBuffer(tsData);
-                                            this.instance.FS('writeFile', name, buffer);
-                                            this.savedSegments += 1;
-                                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments / this.totalSegments);
-                                            return [2 /*return*/, {
-                                                    source: source,
-                                                    url: url,
-                                                    name: name
-                                                }];
+                                            this.savedSegments.set(index, buffer);
+                                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments.size / this.totalSegments);
+                                            return [2 /*return*/];
                                     }
                                 });
                             });
@@ -1037,9 +7490,20 @@ var Hls2Mp4 = (function (FFmpeg) {
                 });
             });
         };
+        Hls2Mp4.prototype.computeTotalDuration = function (content) {
+            var duration = 0;
+            var tags = content.match(/#EXTINF:\d+(.\d+)?/gi);
+            tags === null || tags === void 0 ? void 0 : tags.forEach(function (tag) {
+                var dur = tag.match(/\d+(.\d+)?/);
+                if (dur) {
+                    duration += Number(dur[0]);
+                }
+            });
+            return duration;
+        };
         Hls2Mp4.prototype.downloadM3u8 = function (url) {
             return __awaiter(this, void 0, void 0, function () {
-                var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1, m3u8;
+                var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1;
                 var e_1, _b;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
@@ -1054,31 +7518,29 @@ var Hls2Mp4 = (function (FFmpeg) {
                             if (!matches) {
                                 throw new Error('Invalid m3u8 file, no ts file found');
                             }
+                            this.duration = this.computeTotalDuration(content);
                             segments = [];
-                            if (matches) {
-                                for (i = 0; i < matches.length; i++) {
-                                    matched = matches[i];
-                                    if (matched.match(/#EXT-X-KEY/)) {
-                                        matchedKey = matched.match(keyMatchRegExp);
-                                        matchedIV = matched.match(/(?<=IV=)\w+$/);
-                                        segments.push({
-                                            key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
-                                            iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
-                                            segments: []
-                                        });
-                                    }
-                                    else if (i === 0) {
-                                        segments.push({
-                                            segments: [matched]
-                                        });
-                                    }
-                                    else {
-                                        segments[segments.length - 1].segments.push(matched);
-                                    }
+                            for (i = 0; i < matches.length; i++) {
+                                matched = matches[i];
+                                if (matched.match(/#EXT-X-KEY/)) {
+                                    matchedKey = matched.match(keyMatchRegExp);
+                                    matchedIV = matched.match(/(?<=IV=)\w+$/);
+                                    segments.push({
+                                        key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
+                                        iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
+                                        segments: []
+                                    });
+                                }
+                                else if (i === 0) {
+                                    segments.push({
+                                        segments: [matched]
+                                    });
+                                }
+                                else {
+                                    segments[segments.length - 1].segments.push(matched);
                                 }
                             }
                             this.totalSegments = segments.reduce(function (prev, current) { return prev + current.segments.length; }, 0);
-                            this.savedSegments = 0;
                             batch = this.tsDownloadConcurrency;
                             treatedSegments = 0;
                             _c.label = 2;
@@ -1099,34 +7561,17 @@ var Hls2Mp4 = (function (FFmpeg) {
                             _c.label = 5;
                         case 5:
                             _loop_1 = function (i) {
-                                var downloadSegs, downloadSegs_1, downloadSegs_1_1, _d, source, name_1;
-                                var e_2, _e;
-                                return __generator(this, function (_f) {
-                                    switch (_f.label) {
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
                                         case 0: return [4 /*yield*/, this_1.downloadSegments(group.segments.slice(i * batch, Math.min(total, (i + 1) * batch)).map(function (seg, j) {
                                                 var url = parseUrl(parsedUrl, seg);
-                                                var name = "seg-".concat(treatedSegments + i * batch + j, ".ts");
                                                 return {
-                                                    source: seg,
-                                                    url: url,
-                                                    name: name
+                                                    index: treatedSegments + i * batch + j,
+                                                    url: url
                                                 };
                                             }), keyBuffer, group.iv)];
                                         case 1:
-                                            downloadSegs = _f.sent();
-                                            try {
-                                                for (downloadSegs_1 = (e_2 = void 0, __values(downloadSegs)), downloadSegs_1_1 = downloadSegs_1.next(); !downloadSegs_1_1.done; downloadSegs_1_1 = downloadSegs_1.next()) {
-                                                    _d = downloadSegs_1_1.value, source = _d.source, name_1 = _d.name;
-                                                    content = content.replace(source, name_1);
-                                                }
-                                            }
-                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                                            finally {
-                                                try {
-                                                    if (downloadSegs_1_1 && !downloadSegs_1_1.done && (_e = downloadSegs_1.return)) _e.call(downloadSegs_1);
-                                                }
-                                                finally { if (e_2) throw e_2.error; }
-                                            }
+                                            _d.sent();
                                             return [2 /*return*/];
                                     }
                                 });
@@ -1160,11 +7605,7 @@ var Hls2Mp4 = (function (FFmpeg) {
                             }
                             finally { if (e_1) throw e_1.error; }
                             return [7 /*endfinally*/];
-                        case 14:
-                            content = content.replace(keyTagMatchRegExp, '');
-                            m3u8 = 'temp.m3u8';
-                            this.instance.FS('writeFile', m3u8, content);
-                            return [2 /*return*/, m3u8];
+                        case 14: return [2 /*return*/];
                     }
                 });
             });
@@ -1199,49 +7640,100 @@ var Hls2Mp4 = (function (FFmpeg) {
                 });
             });
         };
-        Hls2Mp4.prototype.loadFFmpeg = function () {
+        Hls2Mp4.prototype.mergeDataArray = function (data) {
+            var e_2, _a;
+            var totalByteLength = data.reduce(function (prev, current) { return prev + current.byteLength; }, 0);
+            var dataArray = new Uint8Array(totalByteLength);
+            var byteOffset = 0;
+            try {
+                for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                    var part = data_1_1.value;
+                    dataArray.set(part, byteOffset);
+                    byteOffset += part.byteLength;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return dataArray;
+        };
+        Hls2Mp4.prototype.transmuxerSegments = function () {
             var _a, _b;
             return __awaiter(this, void 0, void 0, function () {
-                var done;
-                var _this = this;
+                var transmuxer, transmuxerFirstSegment, transmuxerSegment, chunks, i, segment, chunk, data;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
-                            (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.loadFFmeg, 0);
-                            return [4 /*yield*/, this.loopLoadFile(function () { return _this.instance.load(); })];
+                            (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
+                            transmuxer = new Transmuxer({
+                                duration: this.duration
+                            });
+                            transmuxerFirstSegment = function (data) {
+                                return new Promise(function (resolve) {
+                                    transmuxer.on('data', function (segment) {
+                                        var data = new Uint8Array(segment.initSegment.byteLength + segment.data.byteLength);
+                                        data.set(segment.initSegment, 0);
+                                        data.set(segment.data, segment.initSegment.byteLength);
+                                        resolve(data);
+                                    });
+                                    transmuxer.push(data);
+                                    transmuxer.flush();
+                                });
+                            };
+                            transmuxerSegment = function (buffer) {
+                                return new Promise(function (resolve) {
+                                    transmuxer.off('data');
+                                    transmuxer.on('data', function (segment) { return resolve(segment.data); });
+                                    transmuxer.push(buffer);
+                                    transmuxer.flush();
+                                });
+                            };
+                            chunks = [];
+                            i = 0;
+                            _c.label = 1;
                         case 1:
-                            done = (_c.sent()).done;
-                            if (done) {
-                                (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.loadFFmeg, done ? 1 : -1);
-                            }
-                            else {
-                                throw new Error('FFmpeg load failed');
-                            }
-                            return [2 /*return*/];
+                            if (!(i < this.savedSegments.size)) return [3 /*break*/, 7];
+                            segment = this.savedSegments.get(i);
+                            chunk = void 0;
+                            if (!(i === 0)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, transmuxerFirstSegment(segment)];
+                        case 2:
+                            chunk = _c.sent();
+                            return [3 /*break*/, 5];
+                        case 3: return [4 /*yield*/, transmuxerSegment(segment)];
+                        case 4:
+                            chunk = _c.sent();
+                            _c.label = 5;
+                        case 5:
+                            chunks.push(chunk);
+                            _c.label = 6;
+                        case 6:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 7:
+                            data = this.mergeDataArray(chunks);
+                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
+                            return [2 /*return*/, data];
                     }
                 });
             });
         };
         Hls2Mp4.prototype.download = function (url) {
-            var _a, _b;
             return __awaiter(this, void 0, void 0, function () {
-                var m3u8, data;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0: return [4 /*yield*/, this.loadFFmpeg()];
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.downloadM3u8(url)];
                         case 1:
-                            _c.sent();
-                            return [4 /*yield*/, this.downloadM3u8(url)];
+                            _a.sent();
+                            return [4 /*yield*/, this.transmuxerSegments()];
                         case 2:
-                            m3u8 = _c.sent();
-                            (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
-                            return [4 /*yield*/, this.instance.run('-i', m3u8, '-c', 'copy', 'temp.mp4', '-loglevel', 'debug')];
-                        case 3:
-                            _c.sent();
-                            data = this.instance.FS('readFile', 'temp.mp4');
-                            this.instance.exit();
-                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
-                            return [2 /*return*/, data.buffer];
+                            data = _a.sent();
+                            return [2 /*return*/, data];
                     }
                 });
             });
@@ -1254,11 +7746,11 @@ var Hls2Mp4 = (function (FFmpeg) {
             anchor.click();
             setTimeout(function () { return URL.revokeObjectURL(objectUrl); }, 100);
         };
-        Hls2Mp4.version = '1.1.8';
+        Hls2Mp4.version = '2.0';
         Hls2Mp4.TaskType = TaskType;
         return Hls2Mp4;
     }());
 
     return Hls2Mp4;
 
-})(FFmpeg);
+})();
diff --git a/dist/hls2mp4.umd.js b/dist/hls2mp4.umd.js
index cd07464..d6c6ae7 100644
--- a/dist/hls2mp4.umd.js
+++ b/dist/hls2mp4.umd.js
@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@ffmpeg/ffmpeg')) :
-    typeof define === 'function' && define.amd ? define(['@ffmpeg/ffmpeg'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Hls2Mp4 = factory(global.FFmpeg));
-})(this, (function (FFmpeg) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Hls2Mp4 = factory());
+})(this, (function () { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -21,18 +21,6 @@
     /* global Reflect, Promise */
 
 
-    function __rest(s, e) {
-        var t = {};
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-            t[p] = s[p];
-        if (s != null && typeof Object.getOwnPropertySymbols === "function")
-            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                    t[p[i]] = s[p[i]];
-            }
-        return t;
-    }
-
     function __awaiter(thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
         return new (P || (P = Promise))(function (resolve, reject) {
@@ -83,10 +71,6464 @@
         throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
     }
 
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
     function getDefaultExportFromCjs (x) {
     	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
     }
 
+    var mp4Transmuxer = {exports: {}};
+
+    /*! @name mux.js @version 6.3.0 @license Apache-2.0 */
+
+    (function (module, exports) {
+    	(function (global, factory) {
+    	  module.exports = factory() ;
+    	})(commonjsGlobal, (function () {
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   *
+    	   * A lightweight readable stream implemention that handles event dispatching.
+    	   * Objects that inherit from streams should call init in their constructors.
+    	   */
+
+    	  var Stream = function Stream() {
+    	    this.init = function () {
+    	      var listeners = {};
+    	      /**
+    	       * Add a listener for a specified event type.
+    	       * @param type {string} the event name
+    	       * @param listener {function} the callback to be invoked when an event of
+    	       * the specified type occurs
+    	       */
+    	      this.on = function (type, listener) {
+    	        if (!listeners[type]) {
+    	          listeners[type] = [];
+    	        }
+    	        listeners[type] = listeners[type].concat(listener);
+    	      };
+    	      /**
+    	       * Remove a listener for a specified event type.
+    	       * @param type {string} the event name
+    	       * @param listener {function} a function previously registered for this
+    	       * type of event through `on`
+    	       */
+    	      this.off = function (type, listener) {
+    	        var index;
+    	        if (!listeners[type]) {
+    	          return false;
+    	        }
+    	        index = listeners[type].indexOf(listener);
+    	        listeners[type] = listeners[type].slice();
+    	        listeners[type].splice(index, 1);
+    	        return index > -1;
+    	      };
+    	      /**
+    	       * Trigger an event of the specified type on this stream. Any additional
+    	       * arguments to this function are passed as parameters to event listeners.
+    	       * @param type {string} the event name
+    	       */
+    	      this.trigger = function (type) {
+    	        var callbacks, i, length, args;
+    	        callbacks = listeners[type];
+    	        if (!callbacks) {
+    	          return;
+    	        }
+    	        // Slicing the arguments on every invocation of this method
+    	        // can add a significant amount of overhead. Avoid the
+    	        // intermediate object creation for the common case of a
+    	        // single callback argument
+    	        if (arguments.length === 2) {
+    	          length = callbacks.length;
+    	          for (i = 0; i < length; ++i) {
+    	            callbacks[i].call(this, arguments[1]);
+    	          }
+    	        } else {
+    	          args = [];
+    	          i = arguments.length;
+    	          for (i = 1; i < arguments.length; ++i) {
+    	            args.push(arguments[i]);
+    	          }
+    	          length = callbacks.length;
+    	          for (i = 0; i < length; ++i) {
+    	            callbacks[i].apply(this, args);
+    	          }
+    	        }
+    	      };
+    	      /**
+    	       * Destroys the stream and cleans up.
+    	       */
+    	      this.dispose = function () {
+    	        listeners = {};
+    	      };
+    	    };
+    	  };
+
+    	  /**
+    	   * Forwards all `data` events on this stream to the destination stream. The
+    	   * destination stream should provide a method `push` to receive the data
+    	   * events as they arrive.
+    	   * @param destination {stream} the stream that will receive all `data` events
+    	   * @param autoFlush {boolean} if false, we will not call `flush` on the destination
+    	   *                            when the current stream emits a 'done' event
+    	   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
+    	   */
+    	  Stream.prototype.pipe = function (destination) {
+    	    this.on('data', function (data) {
+    	      destination.push(data);
+    	    });
+    	    this.on('done', function (flushSource) {
+    	      destination.flush(flushSource);
+    	    });
+    	    this.on('partialdone', function (flushSource) {
+    	      destination.partialFlush(flushSource);
+    	    });
+    	    this.on('endedtimeline', function (flushSource) {
+    	      destination.endTimeline(flushSource);
+    	    });
+    	    this.on('reset', function (flushSource) {
+    	      destination.reset(flushSource);
+    	    });
+    	    return destination;
+    	  };
+
+    	  // Default stream functions that are expected to be overridden to perform
+    	  // actual work. These are provided by the prototype as a sort of no-op
+    	  // implementation so that we don't have to check for their existence in the
+    	  // `pipe` function above.
+    	  Stream.prototype.push = function (data) {
+    	    this.trigger('data', data);
+    	  };
+    	  Stream.prototype.flush = function (flushSource) {
+    	    this.trigger('done', flushSource);
+    	  };
+    	  Stream.prototype.partialFlush = function (flushSource) {
+    	    this.trigger('partialdone', flushSource);
+    	  };
+    	  Stream.prototype.endTimeline = function (flushSource) {
+    	    this.trigger('endedtimeline', flushSource);
+    	  };
+    	  Stream.prototype.reset = function (flushSource) {
+    	    this.trigger('reset', flushSource);
+    	  };
+    	  var stream = Stream;
+
+    	  var MAX_UINT32$1 = Math.pow(2, 32);
+    	  var getUint64 = function getUint64(uint8) {
+    	    var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+    	    var value;
+    	    if (dv.getBigUint64) {
+    	      value = dv.getBigUint64(0);
+    	      if (value < Number.MAX_SAFE_INTEGER) {
+    	        return Number(value);
+    	      }
+    	      return value;
+    	    }
+    	    return dv.getUint32(0) * MAX_UINT32$1 + dv.getUint32(4);
+    	  };
+    	  var numbers = {
+    	    getUint64: getUint64,
+    	    MAX_UINT32: MAX_UINT32$1
+    	  };
+
+    	  var MAX_UINT32 = numbers.MAX_UINT32;
+    	  var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS;
+
+    	  // pre-calculate constants
+    	  (function () {
+    	    var i;
+    	    types = {
+    	      avc1: [],
+    	      // codingname
+    	      avcC: [],
+    	      btrt: [],
+    	      dinf: [],
+    	      dref: [],
+    	      esds: [],
+    	      ftyp: [],
+    	      hdlr: [],
+    	      mdat: [],
+    	      mdhd: [],
+    	      mdia: [],
+    	      mfhd: [],
+    	      minf: [],
+    	      moof: [],
+    	      moov: [],
+    	      mp4a: [],
+    	      // codingname
+    	      mvex: [],
+    	      mvhd: [],
+    	      pasp: [],
+    	      sdtp: [],
+    	      smhd: [],
+    	      stbl: [],
+    	      stco: [],
+    	      stsc: [],
+    	      stsd: [],
+    	      stsz: [],
+    	      stts: [],
+    	      styp: [],
+    	      tfdt: [],
+    	      tfhd: [],
+    	      traf: [],
+    	      trak: [],
+    	      trun: [],
+    	      trex: [],
+    	      tkhd: [],
+    	      vmhd: []
+    	    };
+
+    	    // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we
+    	    // don't throw an error
+    	    if (typeof Uint8Array === 'undefined') {
+    	      return;
+    	    }
+    	    for (i in types) {
+    	      if (types.hasOwnProperty(i)) {
+    	        types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
+    	      }
+    	    }
+    	    MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);
+    	    AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);
+    	    MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);
+    	    VIDEO_HDLR = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // pre_defined
+    	    0x76, 0x69, 0x64, 0x65,
+    	    // handler_type: 'vide'
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
+    	    ]);
+
+    	    AUDIO_HDLR = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // pre_defined
+    	    0x73, 0x6f, 0x75, 0x6e,
+    	    // handler_type: 'soun'
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
+    	    ]);
+
+    	    HDLR_TYPES = {
+    	      video: VIDEO_HDLR,
+    	      audio: AUDIO_HDLR
+    	    };
+    	    DREF = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // entry_count
+    	    0x00, 0x00, 0x00, 0x0c,
+    	    // entry_size
+    	    0x75, 0x72, 0x6c, 0x20,
+    	    // 'url' type
+    	    0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x01 // entry_flags
+    	    ]);
+
+    	    SMHD = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00,
+    	    // balance, 0 means centered
+    	    0x00, 0x00 // reserved
+    	    ]);
+
+    	    STCO = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00 // entry_count
+    	    ]);
+
+    	    STSC = STCO;
+    	    STSZ = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // sample_size
+    	    0x00, 0x00, 0x00, 0x00 // sample_count
+    	    ]);
+
+    	    STTS = STCO;
+    	    VMHD = new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x01,
+    	    // flags
+    	    0x00, 0x00,
+    	    // graphicsmode
+    	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
+    	    ]);
+    	  })();
+
+    	  box = function box(type) {
+    	    var payload = [],
+    	      size = 0,
+    	      i,
+    	      result,
+    	      view;
+    	    for (i = 1; i < arguments.length; i++) {
+    	      payload.push(arguments[i]);
+    	    }
+    	    i = payload.length;
+
+    	    // calculate the total size we need to allocate
+    	    while (i--) {
+    	      size += payload[i].byteLength;
+    	    }
+    	    result = new Uint8Array(size + 8);
+    	    view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+    	    view.setUint32(0, result.byteLength);
+    	    result.set(type, 4);
+
+    	    // copy the payload into the result
+    	    for (i = 0, size = 8; i < payload.length; i++) {
+    	      result.set(payload[i], size);
+    	      size += payload[i].byteLength;
+    	    }
+    	    return result;
+    	  };
+    	  dinf = function dinf() {
+    	    return box(types.dinf, box(types.dref, DREF));
+    	  };
+    	  esds = function esds(track) {
+    	    return box(types.esds, new Uint8Array([0x00,
+    	    // version
+    	    0x00, 0x00, 0x00,
+    	    // flags
+
+    	    // ES_Descriptor
+    	    0x03,
+    	    // tag, ES_DescrTag
+    	    0x19,
+    	    // length
+    	    0x00, 0x00,
+    	    // ES_ID
+    	    0x00,
+    	    // streamDependenceFlag, URL_flag, reserved, streamPriority
+
+    	    // DecoderConfigDescriptor
+    	    0x04,
+    	    // tag, DecoderConfigDescrTag
+    	    0x11,
+    	    // length
+    	    0x40,
+    	    // object type
+    	    0x15,
+    	    // streamType
+    	    0x00, 0x06, 0x00,
+    	    // bufferSizeDB
+    	    0x00, 0x00, 0xda, 0xc0,
+    	    // maxBitrate
+    	    0x00, 0x00, 0xda, 0xc0,
+    	    // avgBitrate
+
+    	    // DecoderSpecificInfo
+    	    0x05,
+    	    // tag, DecoderSpecificInfoTag
+    	    0x02,
+    	    // length
+    	    // ISO/IEC 14496-3, AudioSpecificConfig
+    	    // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
+    	    track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig
+    	    ]));
+    	  };
+
+    	  ftyp = function ftyp() {
+    	    return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);
+    	  };
+    	  hdlr = function hdlr(type) {
+    	    return box(types.hdlr, HDLR_TYPES[type]);
+    	  };
+    	  mdat = function mdat(data) {
+    	    return box(types.mdat, data);
+    	  };
+    	  mdhd = function mdhd(track) {
+    	    var result = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x02,
+    	    // creation_time
+    	    0x00, 0x00, 0x00, 0x03,
+    	    // modification_time
+    	    0x00, 0x01, 0x5f, 0x90,
+    	    // timescale, 90,000 "ticks" per second
+
+    	    track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF,
+    	    // duration
+    	    0x55, 0xc4,
+    	    // 'und' language (undetermined)
+    	    0x00, 0x00]);
+
+    	    // Use the sample rate from the track metadata, when it is
+    	    // defined. The sample rate can be parsed out of an ADTS header, for
+    	    // instance.
+    	    if (track.samplerate) {
+    	      result[12] = track.samplerate >>> 24 & 0xFF;
+    	      result[13] = track.samplerate >>> 16 & 0xFF;
+    	      result[14] = track.samplerate >>> 8 & 0xFF;
+    	      result[15] = track.samplerate & 0xFF;
+    	    }
+    	    return box(types.mdhd, result);
+    	  };
+    	  mdia = function mdia(track) {
+    	    return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));
+    	  };
+    	  mfhd = function mfhd(sequenceNumber) {
+    	    return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
+    	    // flags
+    	    (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number
+    	    ]));
+    	  };
+
+    	  minf = function minf(track) {
+    	    return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));
+    	  };
+    	  moof = function moof(sequenceNumber, tracks) {
+    	    var trackFragments = [],
+    	      i = tracks.length;
+    	    // build traf boxes for each track fragment
+    	    while (i--) {
+    	      trackFragments[i] = traf(tracks[i]);
+    	    }
+    	    return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));
+    	  };
+    	  /**
+    	   * Returns a movie box.
+    	   * @param tracks {array} the tracks associated with this movie
+    	   * @see ISO/IEC 14496-12:2012(E), section 8.2.1
+    	   */
+    	  moov = function moov(tracks, duration) {
+    	    var i = tracks.length,
+    	      boxes = [];
+    	    while (i--) {
+    	      boxes[i] = trak(tracks[i]);
+    	    }
+    	    return box.apply(null, [types.moov, mvhd(duration || 0xffffffff)].concat(boxes).concat(mvex(tracks)));
+    	  };
+    	  mvex = function mvex(tracks) {
+    	    var i = tracks.length,
+    	      boxes = [];
+    	    while (i--) {
+    	      boxes[i] = trex(tracks[i]);
+    	    }
+    	    return box.apply(null, [types.mvex].concat(boxes));
+    	  };
+    	  mvhd = function mvhd(duration) {
+    	    var bytes = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // creation_time
+    	    0x00, 0x00, 0x00, 0x02,
+    	    // modification_time
+    	    0x00, 0x01, 0x5f, 0x90,
+    	    // timescale, 90,000 "ticks" per second
+    	    (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF,
+    	    // duration
+    	    0x00, 0x01, 0x00, 0x00,
+    	    // 1.0 rate
+    	    0x01, 0x00,
+    	    // 1.0 volume
+    	    0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    	    // transformation: unity matrix
+    	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	    // pre_defined
+    	    0xff, 0xff, 0xff, 0xff // next_track_ID
+    	    ]);
+
+    	    return box(types.mvhd, bytes);
+    	  };
+    	  sdtp = function sdtp(track) {
+    	    var samples = track.samples || [],
+    	      bytes = new Uint8Array(4 + samples.length),
+    	      flags,
+    	      i;
+
+    	    // leave the full box header (4 bytes) all zero
+
+    	    // write the sample table
+    	    for (i = 0; i < samples.length; i++) {
+    	      flags = samples[i].flags;
+    	      bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
+    	    }
+    	    return box(types.sdtp, bytes);
+    	  };
+    	  stbl = function stbl(track) {
+    	    return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));
+    	  };
+    	  (function () {
+    	    var videoSample, audioSample;
+    	    stsd = function stsd(track) {
+    	      return box(types.stsd, new Uint8Array([0x00,
+    	      // version 0
+    	      0x00, 0x00, 0x00,
+    	      // flags
+    	      0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));
+    	    };
+    	    videoSample = function videoSample(track) {
+    	      var sps = track.sps || [],
+    	        pps = track.pps || [],
+    	        sequenceParameterSets = [],
+    	        pictureParameterSets = [],
+    	        i,
+    	        avc1Box;
+
+    	      // assemble the SPSs
+    	      for (i = 0; i < sps.length; i++) {
+    	        sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);
+    	        sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength
+    	        sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS
+    	      }
+
+    	      // assemble the PPSs
+    	      for (i = 0; i < pps.length; i++) {
+    	        pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);
+    	        pictureParameterSets.push(pps[i].byteLength & 0xFF);
+    	        pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));
+    	      }
+    	      avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x01,
+    	      // data_reference_index
+    	      0x00, 0x00,
+    	      // pre_defined
+    	      0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // pre_defined
+    	      (track.width & 0xff00) >> 8, track.width & 0xff,
+    	      // width
+    	      (track.height & 0xff00) >> 8, track.height & 0xff,
+    	      // height
+    	      0x00, 0x48, 0x00, 0x00,
+    	      // horizresolution
+    	      0x00, 0x48, 0x00, 0x00,
+    	      // vertresolution
+    	      0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x01,
+    	      // frame_count
+    	      0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // compressorname
+    	      0x00, 0x18,
+    	      // depth = 24
+    	      0x11, 0x11 // pre_defined = -1
+    	      ]), box(types.avcC, new Uint8Array([0x01,
+    	      // configurationVersion
+    	      track.profileIdc,
+    	      // AVCProfileIndication
+    	      track.profileCompatibility,
+    	      // profile_compatibility
+    	      track.levelIdc,
+    	      // AVCLevelIndication
+    	      0xff // lengthSizeMinusOne, hard-coded to 4 bytes
+    	      ].concat([sps.length],
+    	      // numOfSequenceParameterSets
+    	      sequenceParameterSets,
+    	      // "SPS"
+    	      [pps.length],
+    	      // numOfPictureParameterSets
+    	      pictureParameterSets // "PPS"
+    	      ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
+    	      // bufferSizeDB
+    	      0x00, 0x2d, 0xc6, 0xc0,
+    	      // maxBitrate
+    	      0x00, 0x2d, 0xc6, 0xc0 // avgBitrate
+    	      ]))];
+
+    	      if (track.sarRatio) {
+    	        var hSpacing = track.sarRatio[0],
+    	          vSpacing = track.sarRatio[1];
+    	        avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));
+    	      }
+    	      return box.apply(null, avc1Box);
+    	    };
+    	    audioSample = function audioSample(track) {
+    	      return box(types.mp4a, new Uint8Array([
+    	      // SampleEntry, ISO/IEC 14496-12
+    	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x01,
+    	      // data_reference_index
+
+    	      // AudioSampleEntry, ISO/IEC 14496-12
+    	      0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      0x00, 0x00, 0x00, 0x00,
+    	      // reserved
+    	      (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff,
+    	      // channelcount
+
+    	      (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff,
+    	      // samplesize
+    	      0x00, 0x00,
+    	      // pre_defined
+    	      0x00, 0x00,
+    	      // reserved
+
+    	      (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16
+
+    	      // MP4AudioSampleEntry, ISO/IEC 14496-14
+    	      ]), esds(track));
+    	    };
+    	  })();
+    	  tkhd = function tkhd(track) {
+    	    var result = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x07,
+    	    // flags
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // creation_time
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // modification_time
+    	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    	    // track_ID
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF,
+    	    // duration
+    	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x00,
+    	    // layer
+    	    0x00, 0x00,
+    	    // alternate_group
+    	    0x01, 0x00,
+    	    // non-audio track volume
+    	    0x00, 0x00,
+    	    // reserved
+    	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    	    // transformation: unity matrix
+    	    (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00,
+    	    // width
+    	    (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height
+    	    ]);
+
+    	    return box(types.tkhd, result);
+    	  };
+
+    	  /**
+    	   * Generate a track fragment (traf) box. A traf box collects metadata
+    	   * about tracks in a movie fragment (moof) box.
+    	   */
+    	  traf = function traf(track) {
+    	    var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;
+    	    trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x3a,
+    	    // flags
+    	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    	    // track_ID
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // sample_description_index
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_duration
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_size
+    	    0x00, 0x00, 0x00, 0x00 // default_sample_flags
+    	    ]));
+
+    	    upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / MAX_UINT32);
+    	    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % MAX_UINT32);
+    	    trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01,
+    	    // version 1
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    // baseMediaDecodeTime
+    	    upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF]));
+
+    	    // the data offset specifies the number of bytes from the start of
+    	    // the containing moof to the first payload byte of the associated
+    	    // mdat
+    	    dataOffset = 32 +
+    	    // tfhd
+    	    20 +
+    	    // tfdt
+    	    8 +
+    	    // traf header
+    	    16 +
+    	    // mfhd
+    	    8 +
+    	    // moof header
+    	    8; // mdat header
+
+    	    // audio tracks require less metadata
+    	    if (track.type === 'audio') {
+    	      trackFragmentRun = trun(track, dataOffset);
+    	      return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);
+    	    }
+
+    	    // video tracks should contain an independent and disposable samples
+    	    // box (sdtp)
+    	    // generate one and adjust offsets to match
+    	    sampleDependencyTable = sdtp(track);
+    	    trackFragmentRun = trun(track, sampleDependencyTable.length + dataOffset);
+    	    return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);
+    	  };
+
+    	  /**
+    	   * Generate a track box.
+    	   * @param track {object} a track definition
+    	   * @return {Uint8Array} the track box
+    	   */
+    	  trak = function trak(track) {
+    	    track.duration = track.duration || 0xffffffff;
+    	    return box(types.trak, tkhd(track), mdia(track));
+    	  };
+    	  trex = function trex(track) {
+    	    var result = new Uint8Array([0x00,
+    	    // version 0
+    	    0x00, 0x00, 0x00,
+    	    // flags
+    	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    	    // track_ID
+    	    0x00, 0x00, 0x00, 0x01,
+    	    // default_sample_description_index
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_duration
+    	    0x00, 0x00, 0x00, 0x00,
+    	    // default_sample_size
+    	    0x00, 0x01, 0x00, 0x01 // default_sample_flags
+    	    ]);
+    	    // the last two bytes of default_sample_flags is the sample
+    	    // degradation priority, a hint about the importance of this sample
+    	    // relative to others. Lower the degradation priority for all sample
+    	    // types other than video.
+    	    if (track.type !== 'video') {
+    	      result[result.length - 1] = 0x00;
+    	    }
+    	    return box(types.trex, result);
+    	  };
+    	  (function () {
+    	    var audioTrun, videoTrun, trunHeader;
+
+    	    // This method assumes all samples are uniform. That is, if a
+    	    // duration is present for the first sample, it will be present for
+    	    // all subsequent samples.
+    	    // see ISO/IEC 14496-12:2012, Section 8.8.8.1
+    	    trunHeader = function trunHeader(samples, offset) {
+    	      var durationPresent = 0,
+    	        sizePresent = 0,
+    	        flagsPresent = 0,
+    	        compositionTimeOffset = 0;
+
+    	      // trun flag constants
+    	      if (samples.length) {
+    	        if (samples[0].duration !== undefined) {
+    	          durationPresent = 0x1;
+    	        }
+    	        if (samples[0].size !== undefined) {
+    	          sizePresent = 0x2;
+    	        }
+    	        if (samples[0].flags !== undefined) {
+    	          flagsPresent = 0x4;
+    	        }
+    	        if (samples[0].compositionTimeOffset !== undefined) {
+    	          compositionTimeOffset = 0x8;
+    	        }
+    	      }
+    	      return [0x00,
+    	      // version 0
+    	      0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01,
+    	      // flags
+    	      (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF,
+    	      // sample_count
+    	      (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset
+    	      ];
+    	    };
+
+    	    videoTrun = function videoTrun(track, offset) {
+    	      var bytesOffest, bytes, header, samples, sample, i;
+    	      samples = track.samples || [];
+    	      offset += 8 + 12 + 16 * samples.length;
+    	      header = trunHeader(samples, offset);
+    	      bytes = new Uint8Array(header.length + samples.length * 16);
+    	      bytes.set(header);
+    	      bytesOffest = header.length;
+    	      for (i = 0; i < samples.length; i++) {
+    	        sample = samples[i];
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+    	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+    	        bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;
+    	        bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;
+    	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;
+    	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags
+    	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset
+    	      }
+
+    	      return box(types.trun, bytes);
+    	    };
+    	    audioTrun = function audioTrun(track, offset) {
+    	      var bytes, bytesOffest, header, samples, sample, i;
+    	      samples = track.samples || [];
+    	      offset += 8 + 12 + 8 * samples.length;
+    	      header = trunHeader(samples, offset);
+    	      bytes = new Uint8Array(header.length + samples.length * 8);
+    	      bytes.set(header);
+    	      bytesOffest = header.length;
+    	      for (i = 0; i < samples.length; i++) {
+    	        sample = samples[i];
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+    	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+    	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+    	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+    	      }
+
+    	      return box(types.trun, bytes);
+    	    };
+    	    trun = function trun(track, offset) {
+    	      if (track.type === 'audio') {
+    	        return audioTrun(track, offset);
+    	      }
+    	      return videoTrun(track, offset);
+    	    };
+    	  })();
+    	  var mp4Generator = {
+    	    ftyp: ftyp,
+    	    mdat: mdat,
+    	    moof: moof,
+    	    moov: moov,
+    	    initSegment: function initSegment(tracks) {
+    	      var duration = tracks.reduce(function (p, n) {
+    	        return p + n.duration;
+    	      }, 0);
+    	      var fileType = ftyp(),
+    	        movie = moov(tracks, duration),
+    	        result;
+    	      result = new Uint8Array(fileType.byteLength + movie.byteLength);
+    	      result.set(fileType);
+    	      result.set(movie, fileType.byteLength);
+    	      return result;
+    	    }
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  // Convert an array of nal units into an array of frames with each frame being
+    	  // composed of the nal units that make up that frame
+    	  // Also keep track of cummulative data about the frame from the nal units such
+    	  // as the frame duration, starting pts, etc.
+    	  var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {
+    	    var i,
+    	      currentNal,
+    	      currentFrame = [],
+    	      frames = [];
+
+    	    // TODO added for LHLS, make sure this is OK
+    	    frames.byteLength = 0;
+    	    frames.nalCount = 0;
+    	    frames.duration = 0;
+    	    currentFrame.byteLength = 0;
+    	    for (i = 0; i < nalUnits.length; i++) {
+    	      currentNal = nalUnits[i];
+
+    	      // Split on 'aud'-type nal units
+    	      if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
+    	        // Since the very first nal unit is expected to be an AUD
+    	        // only push to the frames array when currentFrame is not empty
+    	        if (currentFrame.length) {
+    	          currentFrame.duration = currentNal.dts - currentFrame.dts;
+    	          // TODO added for LHLS, make sure this is OK
+    	          frames.byteLength += currentFrame.byteLength;
+    	          frames.nalCount += currentFrame.length;
+    	          frames.duration += currentFrame.duration;
+    	          frames.push(currentFrame);
+    	        }
+    	        currentFrame = [currentNal];
+    	        currentFrame.byteLength = currentNal.data.byteLength;
+    	        currentFrame.pts = currentNal.pts;
+    	        currentFrame.dts = currentNal.dts;
+    	      } else {
+    	        // Specifically flag key frames for ease of use later
+    	        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
+    	          currentFrame.keyFrame = true;
+    	        }
+    	        currentFrame.duration = currentNal.dts - currentFrame.dts;
+    	        currentFrame.byteLength += currentNal.data.byteLength;
+    	        currentFrame.push(currentNal);
+    	      }
+    	    }
+
+    	    // For the last frame, use the duration of the previous frame if we
+    	    // have nothing better to go on
+    	    if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {
+    	      currentFrame.duration = frames[frames.length - 1].duration;
+    	    }
+
+    	    // Push the final frame
+    	    // TODO added for LHLS, make sure this is OK
+    	    frames.byteLength += currentFrame.byteLength;
+    	    frames.nalCount += currentFrame.length;
+    	    frames.duration += currentFrame.duration;
+    	    frames.push(currentFrame);
+    	    return frames;
+    	  };
+
+    	  // Convert an array of frames into an array of Gop with each Gop being composed
+    	  // of the frames that make up that Gop
+    	  // Also keep track of cummulative data about the Gop from the frames such as the
+    	  // Gop duration, starting pts, etc.
+    	  var groupFramesIntoGops = function groupFramesIntoGops(frames) {
+    	    var i,
+    	      currentFrame,
+    	      currentGop = [],
+    	      gops = [];
+
+    	    // We must pre-set some of the values on the Gop since we
+    	    // keep running totals of these values
+    	    currentGop.byteLength = 0;
+    	    currentGop.nalCount = 0;
+    	    currentGop.duration = 0;
+    	    currentGop.pts = frames[0].pts;
+    	    currentGop.dts = frames[0].dts;
+
+    	    // store some metadata about all the Gops
+    	    gops.byteLength = 0;
+    	    gops.nalCount = 0;
+    	    gops.duration = 0;
+    	    gops.pts = frames[0].pts;
+    	    gops.dts = frames[0].dts;
+    	    for (i = 0; i < frames.length; i++) {
+    	      currentFrame = frames[i];
+    	      if (currentFrame.keyFrame) {
+    	        // Since the very first frame is expected to be an keyframe
+    	        // only push to the gops array when currentGop is not empty
+    	        if (currentGop.length) {
+    	          gops.push(currentGop);
+    	          gops.byteLength += currentGop.byteLength;
+    	          gops.nalCount += currentGop.nalCount;
+    	          gops.duration += currentGop.duration;
+    	        }
+    	        currentGop = [currentFrame];
+    	        currentGop.nalCount = currentFrame.length;
+    	        currentGop.byteLength = currentFrame.byteLength;
+    	        currentGop.pts = currentFrame.pts;
+    	        currentGop.dts = currentFrame.dts;
+    	        currentGop.duration = currentFrame.duration;
+    	      } else {
+    	        currentGop.duration += currentFrame.duration;
+    	        currentGop.nalCount += currentFrame.length;
+    	        currentGop.byteLength += currentFrame.byteLength;
+    	        currentGop.push(currentFrame);
+    	      }
+    	    }
+    	    if (gops.length && currentGop.duration <= 0) {
+    	      currentGop.duration = gops[gops.length - 1].duration;
+    	    }
+    	    gops.byteLength += currentGop.byteLength;
+    	    gops.nalCount += currentGop.nalCount;
+    	    gops.duration += currentGop.duration;
+
+    	    // push the final Gop
+    	    gops.push(currentGop);
+    	    return gops;
+    	  };
+
+    	  /*
+    	   * Search for the first keyframe in the GOPs and throw away all frames
+    	   * until that keyframe. Then extend the duration of the pulled keyframe
+    	   * and pull the PTS and DTS of the keyframe so that it covers the time
+    	   * range of the frames that were disposed.
+    	   *
+    	   * @param {Array} gops video GOPs
+    	   * @returns {Array} modified video GOPs
+    	   */
+    	  var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {
+    	    var currentGop;
+    	    if (!gops[0][0].keyFrame && gops.length > 1) {
+    	      // Remove the first GOP
+    	      currentGop = gops.shift();
+    	      gops.byteLength -= currentGop.byteLength;
+    	      gops.nalCount -= currentGop.nalCount;
+
+    	      // Extend the first frame of what is now the
+    	      // first gop to cover the time period of the
+    	      // frames we just removed
+    	      gops[0][0].dts = currentGop.dts;
+    	      gops[0][0].pts = currentGop.pts;
+    	      gops[0][0].duration += currentGop.duration;
+    	    }
+    	    return gops;
+    	  };
+
+    	  /**
+    	   * Default sample object
+    	   * see ISO/IEC 14496-12:2012, section 8.6.4.3
+    	   */
+    	  var createDefaultSample = function createDefaultSample() {
+    	    return {
+    	      size: 0,
+    	      flags: {
+    	        isLeading: 0,
+    	        dependsOn: 1,
+    	        isDependedOn: 0,
+    	        hasRedundancy: 0,
+    	        degradationPriority: 0,
+    	        isNonSyncSample: 1
+    	      }
+    	    };
+    	  };
+
+    	  /*
+    	   * Collates information from a video frame into an object for eventual
+    	   * entry into an MP4 sample table.
+    	   *
+    	   * @param {Object} frame the video frame
+    	   * @param {Number} dataOffset the byte offset to position the sample
+    	   * @return {Object} object containing sample table info for a frame
+    	   */
+    	  var sampleForFrame = function sampleForFrame(frame, dataOffset) {
+    	    var sample = createDefaultSample();
+    	    sample.dataOffset = dataOffset;
+    	    sample.compositionTimeOffset = frame.pts - frame.dts;
+    	    sample.duration = frame.duration;
+    	    sample.size = 4 * frame.length; // Space for nal unit size
+    	    sample.size += frame.byteLength;
+    	    if (frame.keyFrame) {
+    	      sample.flags.dependsOn = 2;
+    	      sample.flags.isNonSyncSample = 0;
+    	    }
+    	    return sample;
+    	  };
+
+    	  // generate the track's sample table from an array of gops
+    	  var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {
+    	    var h,
+    	      i,
+    	      sample,
+    	      currentGop,
+    	      currentFrame,
+    	      dataOffset = baseDataOffset || 0,
+    	      samples = [];
+    	    for (h = 0; h < gops.length; h++) {
+    	      currentGop = gops[h];
+    	      for (i = 0; i < currentGop.length; i++) {
+    	        currentFrame = currentGop[i];
+    	        sample = sampleForFrame(currentFrame, dataOffset);
+    	        dataOffset += sample.size;
+    	        samples.push(sample);
+    	      }
+    	    }
+    	    return samples;
+    	  };
+
+    	  // generate the track's raw mdat data from an array of gops
+    	  var concatenateNalData = function concatenateNalData(gops) {
+    	    var h,
+    	      i,
+    	      j,
+    	      currentGop,
+    	      currentFrame,
+    	      currentNal,
+    	      dataOffset = 0,
+    	      nalsByteLength = gops.byteLength,
+    	      numberOfNals = gops.nalCount,
+    	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+    	      data = new Uint8Array(totalByteLength),
+    	      view = new DataView(data.buffer);
+
+    	    // For each Gop..
+    	    for (h = 0; h < gops.length; h++) {
+    	      currentGop = gops[h];
+
+    	      // For each Frame..
+    	      for (i = 0; i < currentGop.length; i++) {
+    	        currentFrame = currentGop[i];
+
+    	        // For each NAL..
+    	        for (j = 0; j < currentFrame.length; j++) {
+    	          currentNal = currentFrame[j];
+    	          view.setUint32(dataOffset, currentNal.data.byteLength);
+    	          dataOffset += 4;
+    	          data.set(currentNal.data, dataOffset);
+    	          dataOffset += currentNal.data.byteLength;
+    	        }
+    	      }
+    	    }
+    	    return data;
+    	  };
+
+    	  // generate the track's sample table from a frame
+    	  var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {
+    	    var sample,
+    	      dataOffset = baseDataOffset || 0,
+    	      samples = [];
+    	    sample = sampleForFrame(frame, dataOffset);
+    	    samples.push(sample);
+    	    return samples;
+    	  };
+
+    	  // generate the track's raw mdat data from a frame
+    	  var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {
+    	    var i,
+    	      currentNal,
+    	      dataOffset = 0,
+    	      nalsByteLength = frame.byteLength,
+    	      numberOfNals = frame.length,
+    	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+    	      data = new Uint8Array(totalByteLength),
+    	      view = new DataView(data.buffer);
+
+    	    // For each NAL..
+    	    for (i = 0; i < frame.length; i++) {
+    	      currentNal = frame[i];
+    	      view.setUint32(dataOffset, currentNal.data.byteLength);
+    	      dataOffset += 4;
+    	      data.set(currentNal.data, dataOffset);
+    	      dataOffset += currentNal.data.byteLength;
+    	    }
+    	    return data;
+    	  };
+    	  var frameUtils = {
+    	    groupNalsIntoFrames: groupNalsIntoFrames,
+    	    groupFramesIntoGops: groupFramesIntoGops,
+    	    extendFirstKeyFrame: extendFirstKeyFrame,
+    	    generateSampleTable: generateSampleTable$1,
+    	    concatenateNalData: concatenateNalData,
+    	    generateSampleTableForFrame: generateSampleTableForFrame,
+    	    concatenateNalDataForFrame: concatenateNalDataForFrame
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  var highPrefix = [33, 16, 5, 32, 164, 27];
+    	  var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];
+    	  var zeroFill = function zeroFill(count) {
+    	    var a = [];
+    	    while (count--) {
+    	      a.push(0);
+    	    }
+    	    return a;
+    	  };
+    	  var makeTable = function makeTable(metaTable) {
+    	    return Object.keys(metaTable).reduce(function (obj, key) {
+    	      obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {
+    	        return arr.concat(part);
+    	      }, []));
+    	      return obj;
+    	    }, {});
+    	  };
+    	  var silence;
+    	  var silence_1 = function silence_1() {
+    	    if (!silence) {
+    	      // Frames-of-silence to use for filling in missing AAC frames
+    	      var coneOfSilence = {
+    	        96000: [highPrefix, [227, 64], zeroFill(154), [56]],
+    	        88200: [highPrefix, [231], zeroFill(170), [56]],
+    	        64000: [highPrefix, [248, 192], zeroFill(240), [56]],
+    	        48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],
+    	        44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],
+    	        32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],
+    	        24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],
+    	        16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],
+    	        12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],
+    	        11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],
+    	        8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]
+    	      };
+    	      silence = makeTable(coneOfSilence);
+    	    }
+    	    return silence;
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  var ONE_SECOND_IN_TS$3 = 90000,
+    	    // 90kHz clock
+    	    secondsToVideoTs,
+    	    secondsToAudioTs,
+    	    videoTsToSeconds,
+    	    audioTsToSeconds,
+    	    audioTsToVideoTs,
+    	    videoTsToAudioTs,
+    	    metadataTsToSeconds;
+    	  secondsToVideoTs = function secondsToVideoTs(seconds) {
+    	    return seconds * ONE_SECOND_IN_TS$3;
+    	  };
+    	  secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {
+    	    return seconds * sampleRate;
+    	  };
+    	  videoTsToSeconds = function videoTsToSeconds(timestamp) {
+    	    return timestamp / ONE_SECOND_IN_TS$3;
+    	  };
+    	  audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {
+    	    return timestamp / sampleRate;
+    	  };
+    	  audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {
+    	    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
+    	  };
+    	  videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {
+    	    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
+    	  };
+
+    	  /**
+    	   * Adjust ID3 tag or caption timing information by the timeline pts values
+    	   * (if keepOriginalTimestamps is false) and convert to seconds
+    	   */
+    	  metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {
+    	    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
+    	  };
+    	  var clock = {
+    	    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$3,
+    	    secondsToVideoTs: secondsToVideoTs,
+    	    secondsToAudioTs: secondsToAudioTs,
+    	    videoTsToSeconds: videoTsToSeconds,
+    	    audioTsToSeconds: audioTsToSeconds,
+    	    audioTsToVideoTs: audioTsToVideoTs,
+    	    videoTsToAudioTs: videoTsToAudioTs,
+    	    metadataTsToSeconds: metadataTsToSeconds
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+
+    	  /**
+    	   * Sum the `byteLength` properties of the data in each AAC frame
+    	   */
+    	  var sumFrameByteLengths = function sumFrameByteLengths(array) {
+    	    var i,
+    	      currentObj,
+    	      sum = 0;
+
+    	    // sum the byteLength's all each nal unit in the frame
+    	    for (i = 0; i < array.length; i++) {
+    	      currentObj = array[i];
+    	      sum += currentObj.data.byteLength;
+    	    }
+    	    return sum;
+    	  };
+
+    	  // Possibly pad (prefix) the audio track with silence if appending this track
+    	  // would lead to the introduction of a gap in the audio buffer
+    	  var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {
+    	    var baseMediaDecodeTimeTs,
+    	      frameDuration = 0,
+    	      audioGapDuration = 0,
+    	      audioFillFrameCount = 0,
+    	      audioFillDuration = 0,
+    	      silentFrame,
+    	      i,
+    	      firstFrame;
+    	    if (!frames.length) {
+    	      return;
+    	    }
+    	    baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate);
+    	    // determine frame clock duration based on sample rate, round up to avoid overfills
+    	    frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));
+    	    if (audioAppendStartTs && videoBaseMediaDecodeTime) {
+    	      // insert the shortest possible amount (audio gap or audio to video gap)
+    	      audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime);
+    	      // number of full frames in the audio gap
+    	      audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);
+    	      audioFillDuration = audioFillFrameCount * frameDuration;
+    	    }
+
+    	    // don't attempt to fill gaps smaller than a single frame or larger
+    	    // than a half second
+    	    if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {
+    	      return;
+    	    }
+    	    silentFrame = silence_1()[track.samplerate];
+    	    if (!silentFrame) {
+    	      // we don't have a silent frame pregenerated for the sample rate, so use a frame
+    	      // from the content instead
+    	      silentFrame = frames[0].data;
+    	    }
+    	    for (i = 0; i < audioFillFrameCount; i++) {
+    	      firstFrame = frames[0];
+    	      frames.splice(0, 0, {
+    	        data: silentFrame,
+    	        dts: firstFrame.dts - frameDuration,
+    	        pts: firstFrame.pts - frameDuration
+    	      });
+    	    }
+    	    track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));
+    	    return audioFillDuration;
+    	  };
+
+    	  // If the audio segment extends before the earliest allowed dts
+    	  // value, remove AAC frames until starts at or after the earliest
+    	  // allowed DTS so that we don't end up with a negative baseMedia-
+    	  // DecodeTime for the audio track
+    	  var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {
+    	    if (track.minSegmentDts >= earliestAllowedDts) {
+    	      return adtsFrames;
+    	    }
+
+    	    // We will need to recalculate the earliest segment Dts
+    	    track.minSegmentDts = Infinity;
+    	    return adtsFrames.filter(function (currentFrame) {
+    	      // If this is an allowed frame, keep it and record it's Dts
+    	      if (currentFrame.dts >= earliestAllowedDts) {
+    	        track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);
+    	        track.minSegmentPts = track.minSegmentDts;
+    	        return true;
+    	      }
+    	      // Otherwise, discard it
+    	      return false;
+    	    });
+    	  };
+
+    	  // generate the track's raw mdat data from an array of frames
+    	  var generateSampleTable = function generateSampleTable(frames) {
+    	    var i,
+    	      currentFrame,
+    	      samples = [];
+    	    for (i = 0; i < frames.length; i++) {
+    	      currentFrame = frames[i];
+    	      samples.push({
+    	        size: currentFrame.data.byteLength,
+    	        duration: 1024 // For AAC audio, all samples contain 1024 samples
+    	      });
+    	    }
+
+    	    return samples;
+    	  };
+
+    	  // generate the track's sample table from an array of frames
+    	  var concatenateFrameData = function concatenateFrameData(frames) {
+    	    var i,
+    	      currentFrame,
+    	      dataOffset = 0,
+    	      data = new Uint8Array(sumFrameByteLengths(frames));
+    	    for (i = 0; i < frames.length; i++) {
+    	      currentFrame = frames[i];
+    	      data.set(currentFrame.data, dataOffset);
+    	      dataOffset += currentFrame.data.byteLength;
+    	    }
+    	    return data;
+    	  };
+    	  var audioFrameUtils = {
+    	    prefixWithSilence: prefixWithSilence,
+    	    trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,
+    	    generateSampleTable: generateSampleTable,
+    	    concatenateFrameData: concatenateFrameData
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+    	  var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS;
+
+    	  /**
+    	   * Store information about the start and end of the track and the
+    	   * duration for each frame/sample we process in order to calculate
+    	   * the baseMediaDecodeTime
+    	   */
+    	  var collectDtsInfo = function collectDtsInfo(track, data) {
+    	    if (typeof data.pts === 'number') {
+    	      if (track.timelineStartInfo.pts === undefined) {
+    	        track.timelineStartInfo.pts = data.pts;
+    	      }
+    	      if (track.minSegmentPts === undefined) {
+    	        track.minSegmentPts = data.pts;
+    	      } else {
+    	        track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);
+    	      }
+    	      if (track.maxSegmentPts === undefined) {
+    	        track.maxSegmentPts = data.pts;
+    	      } else {
+    	        track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);
+    	      }
+    	    }
+    	    if (typeof data.dts === 'number') {
+    	      if (track.timelineStartInfo.dts === undefined) {
+    	        track.timelineStartInfo.dts = data.dts;
+    	      }
+    	      if (track.minSegmentDts === undefined) {
+    	        track.minSegmentDts = data.dts;
+    	      } else {
+    	        track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);
+    	      }
+    	      if (track.maxSegmentDts === undefined) {
+    	        track.maxSegmentDts = data.dts;
+    	      } else {
+    	        track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);
+    	      }
+    	    }
+    	  };
+
+    	  /**
+    	   * Clear values used to calculate the baseMediaDecodeTime between
+    	   * tracks
+    	   */
+    	  var clearDtsInfo = function clearDtsInfo(track) {
+    	    delete track.minSegmentDts;
+    	    delete track.maxSegmentDts;
+    	    delete track.minSegmentPts;
+    	    delete track.maxSegmentPts;
+    	  };
+
+    	  /**
+    	   * Calculate the track's baseMediaDecodeTime based on the earliest
+    	   * DTS the transmuxer has ever seen and the minimum DTS for the
+    	   * current track
+    	   * @param track {object} track metadata configuration
+    	   * @param keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at 0.
+    	   */
+    	  var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {
+    	    var baseMediaDecodeTime,
+    	      scale,
+    	      minSegmentDts = track.minSegmentDts;
+
+    	    // Optionally adjust the time so the first segment starts at zero.
+    	    if (!keepOriginalTimestamps) {
+    	      minSegmentDts -= track.timelineStartInfo.dts;
+    	    }
+
+    	    // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where
+    	    // we want the start of the first segment to be placed
+    	    baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime;
+
+    	    // Add to that the distance this segment is from the very first
+    	    baseMediaDecodeTime += minSegmentDts;
+
+    	    // baseMediaDecodeTime must not become negative
+    	    baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);
+    	    if (track.type === 'audio') {
+    	      // Audio has a different clock equal to the sampling_rate so we need to
+    	      // scale the PTS values into the clock rate of the track
+    	      scale = track.samplerate / ONE_SECOND_IN_TS$2;
+    	      baseMediaDecodeTime *= scale;
+    	      baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);
+    	    }
+    	    return baseMediaDecodeTime;
+    	  };
+    	  var trackDecodeInfo = {
+    	    clearDtsInfo: clearDtsInfo,
+    	    calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,
+    	    collectDtsInfo: collectDtsInfo
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   *
+    	   * Reads in-band caption information from a video elementary
+    	   * stream. Captions must follow the CEA-708 standard for injection
+    	   * into an MPEG-2 transport streams.
+    	   * @see https://en.wikipedia.org/wiki/CEA-708
+    	   * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf
+    	   */
+
+    	  // Supplemental enhancement information (SEI) NAL units have a
+    	  // payload type field to indicate how they are to be
+    	  // interpreted. CEAS-708 caption content is always transmitted with
+    	  // payload type 0x04.
+    	  var USER_DATA_REGISTERED_ITU_T_T35 = 4,
+    	    RBSP_TRAILING_BITS = 128;
+
+    	  /**
+    	    * Parse a supplemental enhancement information (SEI) NAL unit.
+    	    * Stops parsing once a message of type ITU T T35 has been found.
+    	    *
+    	    * @param bytes {Uint8Array} the bytes of a SEI NAL unit
+    	    * @return {object} the parsed SEI payload
+    	    * @see Rec. ITU-T H.264, 7.3.2.3.1
+    	    */
+    	  var parseSei = function parseSei(bytes) {
+    	    var i = 0,
+    	      result = {
+    	        payloadType: -1,
+    	        payloadSize: 0
+    	      },
+    	      payloadType = 0,
+    	      payloadSize = 0;
+
+    	    // go through the sei_rbsp parsing each each individual sei_message
+    	    while (i < bytes.byteLength) {
+    	      // stop once we have hit the end of the sei_rbsp
+    	      if (bytes[i] === RBSP_TRAILING_BITS) {
+    	        break;
+    	      }
+
+    	      // Parse payload type
+    	      while (bytes[i] === 0xFF) {
+    	        payloadType += 255;
+    	        i++;
+    	      }
+    	      payloadType += bytes[i++];
+
+    	      // Parse payload size
+    	      while (bytes[i] === 0xFF) {
+    	        payloadSize += 255;
+    	        i++;
+    	      }
+    	      payloadSize += bytes[i++];
+
+    	      // this sei_message is a 608/708 caption so save it and break
+    	      // there can only ever be one caption message in a frame's sei
+    	      if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {
+    	        var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);
+    	        if (userIdentifier === 'GA94') {
+    	          result.payloadType = payloadType;
+    	          result.payloadSize = payloadSize;
+    	          result.payload = bytes.subarray(i, i + payloadSize);
+    	          break;
+    	        } else {
+    	          result.payload = void 0;
+    	        }
+    	      }
+
+    	      // skip the payload and parse the next message
+    	      i += payloadSize;
+    	      payloadType = 0;
+    	      payloadSize = 0;
+    	    }
+    	    return result;
+    	  };
+
+    	  // see ANSI/SCTE 128-1 (2013), section 8.1
+    	  var parseUserData = function parseUserData(sei) {
+    	    // itu_t_t35_contry_code must be 181 (United States) for
+    	    // captions
+    	    if (sei.payload[0] !== 181) {
+    	      return null;
+    	    }
+
+    	    // itu_t_t35_provider_code should be 49 (ATSC) for captions
+    	    if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {
+    	      return null;
+    	    }
+
+    	    // the user_identifier should be "GA94" to indicate ATSC1 data
+    	    if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {
+    	      return null;
+    	    }
+
+    	    // finally, user_data_type_code should be 0x03 for caption data
+    	    if (sei.payload[7] !== 0x03) {
+    	      return null;
+    	    }
+
+    	    // return the user_data_type_structure and strip the trailing
+    	    // marker bits
+    	    return sei.payload.subarray(8, sei.payload.length - 1);
+    	  };
+
+    	  // see CEA-708-D, section 4.4
+    	  var parseCaptionPackets = function parseCaptionPackets(pts, userData) {
+    	    var results = [],
+    	      i,
+    	      count,
+    	      offset,
+    	      data;
+
+    	    // if this is just filler, return immediately
+    	    if (!(userData[0] & 0x40)) {
+    	      return results;
+    	    }
+
+    	    // parse out the cc_data_1 and cc_data_2 fields
+    	    count = userData[0] & 0x1f;
+    	    for (i = 0; i < count; i++) {
+    	      offset = i * 3;
+    	      data = {
+    	        type: userData[offset + 2] & 0x03,
+    	        pts: pts
+    	      };
+
+    	      // capture cc data when cc_valid is 1
+    	      if (userData[offset + 2] & 0x04) {
+    	        data.ccData = userData[offset + 3] << 8 | userData[offset + 4];
+    	        results.push(data);
+    	      }
+    	    }
+    	    return results;
+    	  };
+    	  var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+    	    var length = data.byteLength,
+    	      emulationPreventionBytesPositions = [],
+    	      i = 1,
+    	      newLength,
+    	      newData;
+
+    	    // Find all `Emulation Prevention Bytes`
+    	    while (i < length - 2) {
+    	      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+    	        emulationPreventionBytesPositions.push(i + 2);
+    	        i += 2;
+    	      } else {
+    	        i++;
+    	      }
+    	    }
+
+    	    // If no Emulation Prevention Bytes were found just return the original
+    	    // array
+    	    if (emulationPreventionBytesPositions.length === 0) {
+    	      return data;
+    	    }
+
+    	    // Create a new array to hold the NAL unit data
+    	    newLength = length - emulationPreventionBytesPositions.length;
+    	    newData = new Uint8Array(newLength);
+    	    var sourceIndex = 0;
+    	    for (i = 0; i < newLength; sourceIndex++, i++) {
+    	      if (sourceIndex === emulationPreventionBytesPositions[0]) {
+    	        // Skip this byte
+    	        sourceIndex++;
+    	        // Remove this position index
+    	        emulationPreventionBytesPositions.shift();
+    	      }
+    	      newData[i] = data[sourceIndex];
+    	    }
+    	    return newData;
+    	  };
+
+    	  // exports
+    	  var captionPacketParser = {
+    	    parseSei: parseSei,
+    	    parseUserData: parseUserData,
+    	    parseCaptionPackets: parseCaptionPackets,
+    	    discardEmulationPreventionBytes: discardEmulationPreventionBytes,
+    	    USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35
+    	  };
+
+    	  // -----------------
+    	  // Link To Transport
+    	  // -----------------
+
+    	  var CaptionStream = function CaptionStream(options) {
+    	    options = options || {};
+    	    CaptionStream.prototype.init.call(this);
+
+    	    // parse708captions flag, default to true
+    	    this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;
+    	    this.captionPackets_ = [];
+    	    this.ccStreams_ = [new Cea608Stream(0, 0),
+    	    // eslint-disable-line no-use-before-define
+    	    new Cea608Stream(0, 1),
+    	    // eslint-disable-line no-use-before-define
+    	    new Cea608Stream(1, 0),
+    	    // eslint-disable-line no-use-before-define
+    	    new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define
+    	    ];
+
+    	    if (this.parse708captions_) {
+    	      this.cc708Stream_ = new Cea708Stream({
+    	        captionServices: options.captionServices
+    	      }); // eslint-disable-line no-use-before-define
+    	    }
+
+    	    this.reset();
+
+    	    // forward data and done events from CCs to this CaptionStream
+    	    this.ccStreams_.forEach(function (cc) {
+    	      cc.on('data', this.trigger.bind(this, 'data'));
+    	      cc.on('partialdone', this.trigger.bind(this, 'partialdone'));
+    	      cc.on('done', this.trigger.bind(this, 'done'));
+    	    }, this);
+    	    if (this.parse708captions_) {
+    	      this.cc708Stream_.on('data', this.trigger.bind(this, 'data'));
+    	      this.cc708Stream_.on('partialdone', this.trigger.bind(this, 'partialdone'));
+    	      this.cc708Stream_.on('done', this.trigger.bind(this, 'done'));
+    	    }
+    	  };
+    	  CaptionStream.prototype = new stream();
+    	  CaptionStream.prototype.push = function (event) {
+    	    var sei, userData, newCaptionPackets;
+
+    	    // only examine SEI NALs
+    	    if (event.nalUnitType !== 'sei_rbsp') {
+    	      return;
+    	    }
+
+    	    // parse the sei
+    	    sei = captionPacketParser.parseSei(event.escapedRBSP);
+
+    	    // no payload data, skip
+    	    if (!sei.payload) {
+    	      return;
+    	    }
+
+    	    // ignore everything but user_data_registered_itu_t_t35
+    	    if (sei.payloadType !== captionPacketParser.USER_DATA_REGISTERED_ITU_T_T35) {
+    	      return;
+    	    }
+
+    	    // parse out the user data payload
+    	    userData = captionPacketParser.parseUserData(sei);
+
+    	    // ignore unrecognized userData
+    	    if (!userData) {
+    	      return;
+    	    }
+
+    	    // Sometimes, the same segment # will be downloaded twice. To stop the
+    	    // caption data from being processed twice, we track the latest dts we've
+    	    // received and ignore everything with a dts before that. However, since
+    	    // data for a specific dts can be split across packets on either side of
+    	    // a segment boundary, we need to make sure we *don't* ignore the packets
+    	    // from the *next* segment that have dts === this.latestDts_. By constantly
+    	    // tracking the number of packets received with dts === this.latestDts_, we
+    	    // know how many should be ignored once we start receiving duplicates.
+    	    if (event.dts < this.latestDts_) {
+    	      // We've started getting older data, so set the flag.
+    	      this.ignoreNextEqualDts_ = true;
+    	      return;
+    	    } else if (event.dts === this.latestDts_ && this.ignoreNextEqualDts_) {
+    	      this.numSameDts_--;
+    	      if (!this.numSameDts_) {
+    	        // We've received the last duplicate packet, time to start processing again
+    	        this.ignoreNextEqualDts_ = false;
+    	      }
+    	      return;
+    	    }
+
+    	    // parse out CC data packets and save them for later
+    	    newCaptionPackets = captionPacketParser.parseCaptionPackets(event.pts, userData);
+    	    this.captionPackets_ = this.captionPackets_.concat(newCaptionPackets);
+    	    if (this.latestDts_ !== event.dts) {
+    	      this.numSameDts_ = 0;
+    	    }
+    	    this.numSameDts_++;
+    	    this.latestDts_ = event.dts;
+    	  };
+    	  CaptionStream.prototype.flushCCStreams = function (flushType) {
+    	    this.ccStreams_.forEach(function (cc) {
+    	      return flushType === 'flush' ? cc.flush() : cc.partialFlush();
+    	    }, this);
+    	  };
+    	  CaptionStream.prototype.flushStream = function (flushType) {
+    	    // make sure we actually parsed captions before proceeding
+    	    if (!this.captionPackets_.length) {
+    	      this.flushCCStreams(flushType);
+    	      return;
+    	    }
+
+    	    // In Chrome, the Array#sort function is not stable so add a
+    	    // presortIndex that we can use to ensure we get a stable-sort
+    	    this.captionPackets_.forEach(function (elem, idx) {
+    	      elem.presortIndex = idx;
+    	    });
+
+    	    // sort caption byte-pairs based on their PTS values
+    	    this.captionPackets_.sort(function (a, b) {
+    	      if (a.pts === b.pts) {
+    	        return a.presortIndex - b.presortIndex;
+    	      }
+    	      return a.pts - b.pts;
+    	    });
+    	    this.captionPackets_.forEach(function (packet) {
+    	      if (packet.type < 2) {
+    	        // Dispatch packet to the right Cea608Stream
+    	        this.dispatchCea608Packet(packet);
+    	      } else {
+    	        // Dispatch packet to the Cea708Stream
+    	        this.dispatchCea708Packet(packet);
+    	      }
+    	    }, this);
+    	    this.captionPackets_.length = 0;
+    	    this.flushCCStreams(flushType);
+    	  };
+    	  CaptionStream.prototype.flush = function () {
+    	    return this.flushStream('flush');
+    	  };
+
+    	  // Only called if handling partial data
+    	  CaptionStream.prototype.partialFlush = function () {
+    	    return this.flushStream('partialFlush');
+    	  };
+    	  CaptionStream.prototype.reset = function () {
+    	    this.latestDts_ = null;
+    	    this.ignoreNextEqualDts_ = false;
+    	    this.numSameDts_ = 0;
+    	    this.activeCea608Channel_ = [null, null];
+    	    this.ccStreams_.forEach(function (ccStream) {
+    	      ccStream.reset();
+    	    });
+    	  };
+
+    	  // From the CEA-608 spec:
+    	  /*
+    	   * When XDS sub-packets are interleaved with other services, the end of each sub-packet shall be followed
+    	   * by a control pair to change to a different service. When any of the control codes from 0x10 to 0x1F is
+    	   * used to begin a control code pair, it indicates the return to captioning or Text data. The control code pair
+    	   * and subsequent data should then be processed according to the FCC rules. It may be necessary for the
+    	   * line 21 data encoder to automatically insert a control code pair (i.e. RCL, RU2, RU3, RU4, RDC, or RTD)
+    	   * to switch to captioning or Text.
+    	  */
+    	  // With that in mind, we ignore any data between an XDS control code and a
+    	  // subsequent closed-captioning control code.
+    	  CaptionStream.prototype.dispatchCea608Packet = function (packet) {
+    	    // NOTE: packet.type is the CEA608 field
+    	    if (this.setsTextOrXDSActive(packet)) {
+    	      this.activeCea608Channel_[packet.type] = null;
+    	    } else if (this.setsChannel1Active(packet)) {
+    	      this.activeCea608Channel_[packet.type] = 0;
+    	    } else if (this.setsChannel2Active(packet)) {
+    	      this.activeCea608Channel_[packet.type] = 1;
+    	    }
+    	    if (this.activeCea608Channel_[packet.type] === null) {
+    	      // If we haven't received anything to set the active channel, or the
+    	      // packets are Text/XDS data, discard the data; we don't want jumbled
+    	      // captions
+    	      return;
+    	    }
+    	    this.ccStreams_[(packet.type << 1) + this.activeCea608Channel_[packet.type]].push(packet);
+    	  };
+    	  CaptionStream.prototype.setsChannel1Active = function (packet) {
+    	    return (packet.ccData & 0x7800) === 0x1000;
+    	  };
+    	  CaptionStream.prototype.setsChannel2Active = function (packet) {
+    	    return (packet.ccData & 0x7800) === 0x1800;
+    	  };
+    	  CaptionStream.prototype.setsTextOrXDSActive = function (packet) {
+    	    return (packet.ccData & 0x7100) === 0x0100 || (packet.ccData & 0x78fe) === 0x102a || (packet.ccData & 0x78fe) === 0x182a;
+    	  };
+    	  CaptionStream.prototype.dispatchCea708Packet = function (packet) {
+    	    if (this.parse708captions_) {
+    	      this.cc708Stream_.push(packet);
+    	    }
+    	  };
+
+    	  // ----------------------
+    	  // Session to Application
+    	  // ----------------------
+
+    	  // This hash maps special and extended character codes to their
+    	  // proper Unicode equivalent. The first one-byte key is just a
+    	  // non-standard character code. The two-byte keys that follow are
+    	  // the extended CEA708 character codes, along with the preceding
+    	  // 0x10 extended character byte to distinguish these codes from
+    	  // non-extended character codes. Every CEA708 character code that
+    	  // is not in this object maps directly to a standard unicode
+    	  // character code.
+    	  // The transparent space and non-breaking transparent space are
+    	  // technically not fully supported since there is no code to
+    	  // make them transparent, so they have normal non-transparent
+    	  // stand-ins.
+    	  // The special closed caption (CC) character isn't a standard
+    	  // unicode character, so a fairly similar unicode character was
+    	  // chosen in it's place.
+    	  var CHARACTER_TRANSLATION_708 = {
+    	    0x7f: 0x266a,
+    	    // ♪
+    	    0x1020: 0x20,
+    	    // Transparent Space
+    	    0x1021: 0xa0,
+    	    // Nob-breaking Transparent Space
+    	    0x1025: 0x2026,
+    	    // …
+    	    0x102a: 0x0160,
+    	    // Š
+    	    0x102c: 0x0152,
+    	    // Œ
+    	    0x1030: 0x2588,
+    	    // █
+    	    0x1031: 0x2018,
+    	    // ‘
+    	    0x1032: 0x2019,
+    	    // ’
+    	    0x1033: 0x201c,
+    	    // “
+    	    0x1034: 0x201d,
+    	    // ”
+    	    0x1035: 0x2022,
+    	    // •
+    	    0x1039: 0x2122,
+    	    // ™
+    	    0x103a: 0x0161,
+    	    // š
+    	    0x103c: 0x0153,
+    	    // œ
+    	    0x103d: 0x2120,
+    	    // ℠
+    	    0x103f: 0x0178,
+    	    // Ÿ
+    	    0x1076: 0x215b,
+    	    // ⅛
+    	    0x1077: 0x215c,
+    	    // ⅜
+    	    0x1078: 0x215d,
+    	    // ⅝
+    	    0x1079: 0x215e,
+    	    // ⅞
+    	    0x107a: 0x23d0,
+    	    // ⏐
+    	    0x107b: 0x23a4,
+    	    // ⎤
+    	    0x107c: 0x23a3,
+    	    // ⎣
+    	    0x107d: 0x23af,
+    	    // ⎯
+    	    0x107e: 0x23a6,
+    	    // ⎦
+    	    0x107f: 0x23a1,
+    	    // ⎡
+    	    0x10a0: 0x3138 // ㄸ (CC char)
+    	  };
+
+    	  var get708CharFromCode = function get708CharFromCode(code) {
+    	    var newCode = CHARACTER_TRANSLATION_708[code] || code;
+    	    if (code & 0x1000 && code === newCode) {
+    	      // Invalid extended code
+    	      return '';
+    	    }
+    	    return String.fromCharCode(newCode);
+    	  };
+    	  var within708TextBlock = function within708TextBlock(b) {
+    	    return 0x20 <= b && b <= 0x7f || 0xa0 <= b && b <= 0xff;
+    	  };
+    	  var Cea708Window = function Cea708Window(windowNum) {
+    	    this.windowNum = windowNum;
+    	    this.reset();
+    	  };
+    	  Cea708Window.prototype.reset = function () {
+    	    this.clearText();
+    	    this.pendingNewLine = false;
+    	    this.winAttr = {};
+    	    this.penAttr = {};
+    	    this.penLoc = {};
+    	    this.penColor = {};
+
+    	    // These default values are arbitrary,
+    	    // defineWindow will usually override them
+    	    this.visible = 0;
+    	    this.rowLock = 0;
+    	    this.columnLock = 0;
+    	    this.priority = 0;
+    	    this.relativePositioning = 0;
+    	    this.anchorVertical = 0;
+    	    this.anchorHorizontal = 0;
+    	    this.anchorPoint = 0;
+    	    this.rowCount = 1;
+    	    this.virtualRowCount = this.rowCount + 1;
+    	    this.columnCount = 41;
+    	    this.windowStyle = 0;
+    	    this.penStyle = 0;
+    	  };
+    	  Cea708Window.prototype.getText = function () {
+    	    return this.rows.join('\n');
+    	  };
+    	  Cea708Window.prototype.clearText = function () {
+    	    this.rows = [''];
+    	    this.rowIdx = 0;
+    	  };
+    	  Cea708Window.prototype.newLine = function (pts) {
+    	    if (this.rows.length >= this.virtualRowCount && typeof this.beforeRowOverflow === 'function') {
+    	      this.beforeRowOverflow(pts);
+    	    }
+    	    if (this.rows.length > 0) {
+    	      this.rows.push('');
+    	      this.rowIdx++;
+    	    }
+
+    	    // Show all virtual rows since there's no visible scrolling
+    	    while (this.rows.length > this.virtualRowCount) {
+    	      this.rows.shift();
+    	      this.rowIdx--;
+    	    }
+    	  };
+    	  Cea708Window.prototype.isEmpty = function () {
+    	    if (this.rows.length === 0) {
+    	      return true;
+    	    } else if (this.rows.length === 1) {
+    	      return this.rows[0] === '';
+    	    }
+    	    return false;
+    	  };
+    	  Cea708Window.prototype.addText = function (text) {
+    	    this.rows[this.rowIdx] += text;
+    	  };
+    	  Cea708Window.prototype.backspace = function () {
+    	    if (!this.isEmpty()) {
+    	      var row = this.rows[this.rowIdx];
+    	      this.rows[this.rowIdx] = row.substr(0, row.length - 1);
+    	    }
+    	  };
+    	  var Cea708Service = function Cea708Service(serviceNum, encoding, stream) {
+    	    this.serviceNum = serviceNum;
+    	    this.text = '';
+    	    this.currentWindow = new Cea708Window(-1);
+    	    this.windows = [];
+    	    this.stream = stream;
+
+    	    // Try to setup a TextDecoder if an `encoding` value was provided
+    	    if (typeof encoding === 'string') {
+    	      this.createTextDecoder(encoding);
+    	    }
+    	  };
+
+    	  /**
+    	   * Initialize service windows
+    	   * Must be run before service use
+    	   *
+    	   * @param  {Integer}  pts               PTS value
+    	   * @param  {Function} beforeRowOverflow Function to execute before row overflow of a window
+    	   */
+    	  Cea708Service.prototype.init = function (pts, beforeRowOverflow) {
+    	    this.startPts = pts;
+    	    for (var win = 0; win < 8; win++) {
+    	      this.windows[win] = new Cea708Window(win);
+    	      if (typeof beforeRowOverflow === 'function') {
+    	        this.windows[win].beforeRowOverflow = beforeRowOverflow;
+    	      }
+    	    }
+    	  };
+
+    	  /**
+    	   * Set current window of service to be affected by commands
+    	   *
+    	   * @param  {Integer} windowNum Window number
+    	   */
+    	  Cea708Service.prototype.setCurrentWindow = function (windowNum) {
+    	    this.currentWindow = this.windows[windowNum];
+    	  };
+
+    	  /**
+    	   * Try to create a TextDecoder if it is natively supported
+    	   */
+    	  Cea708Service.prototype.createTextDecoder = function (encoding) {
+    	    if (typeof TextDecoder === 'undefined') {
+    	      this.stream.trigger('log', {
+    	        level: 'warn',
+    	        message: 'The `encoding` option is unsupported without TextDecoder support'
+    	      });
+    	    } else {
+    	      try {
+    	        this.textDecoder_ = new TextDecoder(encoding);
+    	      } catch (error) {
+    	        this.stream.trigger('log', {
+    	          level: 'warn',
+    	          message: 'TextDecoder could not be created with ' + encoding + ' encoding. ' + error
+    	        });
+    	      }
+    	    }
+    	  };
+    	  var Cea708Stream = function Cea708Stream(options) {
+    	    options = options || {};
+    	    Cea708Stream.prototype.init.call(this);
+    	    var self = this;
+    	    var captionServices = options.captionServices || {};
+    	    var captionServiceEncodings = {};
+    	    var serviceProps;
+
+    	    // Get service encodings from captionServices option block
+    	    Object.keys(captionServices).forEach(function (serviceName) {
+    	      serviceProps = captionServices[serviceName];
+    	      if (/^SERVICE/.test(serviceName)) {
+    	        captionServiceEncodings[serviceName] = serviceProps.encoding;
+    	      }
+    	    });
+    	    this.serviceEncodings = captionServiceEncodings;
+    	    this.current708Packet = null;
+    	    this.services = {};
+    	    this.push = function (packet) {
+    	      if (packet.type === 3) {
+    	        // 708 packet start
+    	        self.new708Packet();
+    	        self.add708Bytes(packet);
+    	      } else {
+    	        if (self.current708Packet === null) {
+    	          // This should only happen at the start of a file if there's no packet start.
+    	          self.new708Packet();
+    	        }
+    	        self.add708Bytes(packet);
+    	      }
+    	    };
+    	  };
+    	  Cea708Stream.prototype = new stream();
+
+    	  /**
+    	   * Push current 708 packet, create new 708 packet.
+    	   */
+    	  Cea708Stream.prototype.new708Packet = function () {
+    	    if (this.current708Packet !== null) {
+    	      this.push708Packet();
+    	    }
+    	    this.current708Packet = {
+    	      data: [],
+    	      ptsVals: []
+    	    };
+    	  };
+
+    	  /**
+    	   * Add pts and both bytes from packet into current 708 packet.
+    	   */
+    	  Cea708Stream.prototype.add708Bytes = function (packet) {
+    	    var data = packet.ccData;
+    	    var byte0 = data >>> 8;
+    	    var byte1 = data & 0xff;
+
+    	    // I would just keep a list of packets instead of bytes, but it isn't clear in the spec
+    	    // that service blocks will always line up with byte pairs.
+    	    this.current708Packet.ptsVals.push(packet.pts);
+    	    this.current708Packet.data.push(byte0);
+    	    this.current708Packet.data.push(byte1);
+    	  };
+
+    	  /**
+    	   * Parse completed 708 packet into service blocks and push each service block.
+    	   */
+    	  Cea708Stream.prototype.push708Packet = function () {
+    	    var packet708 = this.current708Packet;
+    	    var packetData = packet708.data;
+    	    var serviceNum = null;
+    	    var blockSize = null;
+    	    var i = 0;
+    	    var b = packetData[i++];
+    	    packet708.seq = b >> 6;
+    	    packet708.sizeCode = b & 0x3f; // 0b00111111;
+
+    	    for (; i < packetData.length; i++) {
+    	      b = packetData[i++];
+    	      serviceNum = b >> 5;
+    	      blockSize = b & 0x1f; // 0b00011111
+
+    	      if (serviceNum === 7 && blockSize > 0) {
+    	        // Extended service num
+    	        b = packetData[i++];
+    	        serviceNum = b;
+    	      }
+    	      this.pushServiceBlock(serviceNum, i, blockSize);
+    	      if (blockSize > 0) {
+    	        i += blockSize - 1;
+    	      }
+    	    }
+    	  };
+
+    	  /**
+    	   * Parse service block, execute commands, read text.
+    	   *
+    	   * Note: While many of these commands serve important purposes,
+    	   * many others just parse out the parameters or attributes, but
+    	   * nothing is done with them because this is not a full and complete
+    	   * implementation of the entire 708 spec.
+    	   *
+    	   * @param  {Integer} serviceNum Service number
+    	   * @param  {Integer} start      Start index of the 708 packet data
+    	   * @param  {Integer} size       Block size
+    	   */
+    	  Cea708Stream.prototype.pushServiceBlock = function (serviceNum, start, size) {
+    	    var b;
+    	    var i = start;
+    	    var packetData = this.current708Packet.data;
+    	    var service = this.services[serviceNum];
+    	    if (!service) {
+    	      service = this.initService(serviceNum, i);
+    	    }
+    	    for (; i < start + size && i < packetData.length; i++) {
+    	      b = packetData[i];
+    	      if (within708TextBlock(b)) {
+    	        i = this.handleText(i, service);
+    	      } else if (b === 0x18) {
+    	        i = this.multiByteCharacter(i, service);
+    	      } else if (b === 0x10) {
+    	        i = this.extendedCommands(i, service);
+    	      } else if (0x80 <= b && b <= 0x87) {
+    	        i = this.setCurrentWindow(i, service);
+    	      } else if (0x98 <= b && b <= 0x9f) {
+    	        i = this.defineWindow(i, service);
+    	      } else if (b === 0x88) {
+    	        i = this.clearWindows(i, service);
+    	      } else if (b === 0x8c) {
+    	        i = this.deleteWindows(i, service);
+    	      } else if (b === 0x89) {
+    	        i = this.displayWindows(i, service);
+    	      } else if (b === 0x8a) {
+    	        i = this.hideWindows(i, service);
+    	      } else if (b === 0x8b) {
+    	        i = this.toggleWindows(i, service);
+    	      } else if (b === 0x97) {
+    	        i = this.setWindowAttributes(i, service);
+    	      } else if (b === 0x90) {
+    	        i = this.setPenAttributes(i, service);
+    	      } else if (b === 0x91) {
+    	        i = this.setPenColor(i, service);
+    	      } else if (b === 0x92) {
+    	        i = this.setPenLocation(i, service);
+    	      } else if (b === 0x8f) {
+    	        service = this.reset(i, service);
+    	      } else if (b === 0x08) {
+    	        // BS: Backspace
+    	        service.currentWindow.backspace();
+    	      } else if (b === 0x0c) {
+    	        // FF: Form feed
+    	        service.currentWindow.clearText();
+    	      } else if (b === 0x0d) {
+    	        // CR: Carriage return
+    	        service.currentWindow.pendingNewLine = true;
+    	      } else if (b === 0x0e) {
+    	        // HCR: Horizontal carriage return
+    	        service.currentWindow.clearText();
+    	      } else if (b === 0x8d) {
+    	        // DLY: Delay, nothing to do
+    	        i++;
+    	      } else ;
+    	    }
+    	  };
+
+    	  /**
+    	   * Execute an extended command
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.extendedCommands = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    if (within708TextBlock(b)) {
+    	      i = this.handleText(i, service, {
+    	        isExtended: true
+    	      });
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Get PTS value of a given byte index
+    	   *
+    	   * @param  {Integer} byteIndex  Index of the byte
+    	   * @return {Integer}            PTS
+    	   */
+    	  Cea708Stream.prototype.getPts = function (byteIndex) {
+    	    // There's 1 pts value per 2 bytes
+    	    return this.current708Packet.ptsVals[Math.floor(byteIndex / 2)];
+    	  };
+
+    	  /**
+    	   * Initializes a service
+    	   *
+    	   * @param  {Integer} serviceNum Service number
+    	   * @return {Service}            Initialized service object
+    	   */
+    	  Cea708Stream.prototype.initService = function (serviceNum, i) {
+    	    var serviceName = 'SERVICE' + serviceNum;
+    	    var self = this;
+    	    var serviceName;
+    	    var encoding;
+    	    if (serviceName in this.serviceEncodings) {
+    	      encoding = this.serviceEncodings[serviceName];
+    	    }
+    	    this.services[serviceNum] = new Cea708Service(serviceNum, encoding, self);
+    	    this.services[serviceNum].init(this.getPts(i), function (pts) {
+    	      self.flushDisplayed(pts, self.services[serviceNum]);
+    	    });
+    	    return this.services[serviceNum];
+    	  };
+
+    	  /**
+    	   * Execute text writing to current window
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.handleText = function (i, service, options) {
+    	    var isExtended = options && options.isExtended;
+    	    var isMultiByte = options && options.isMultiByte;
+    	    var packetData = this.current708Packet.data;
+    	    var extended = isExtended ? 0x1000 : 0x0000;
+    	    var currentByte = packetData[i];
+    	    var nextByte = packetData[i + 1];
+    	    var win = service.currentWindow;
+    	    var char;
+    	    var charCodeArray;
+
+    	    // Use the TextDecoder if one was created for this service
+    	    if (service.textDecoder_ && !isExtended) {
+    	      if (isMultiByte) {
+    	        charCodeArray = [currentByte, nextByte];
+    	        i++;
+    	      } else {
+    	        charCodeArray = [currentByte];
+    	      }
+    	      char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
+    	    } else {
+    	      char = get708CharFromCode(extended | currentByte);
+    	    }
+    	    if (win.pendingNewLine && !win.isEmpty()) {
+    	      win.newLine(this.getPts(i));
+    	    }
+    	    win.pendingNewLine = false;
+    	    win.addText(char);
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Handle decoding of multibyte character
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.multiByteCharacter = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var firstByte = packetData[i + 1];
+    	    var secondByte = packetData[i + 2];
+    	    if (within708TextBlock(firstByte) && within708TextBlock(secondByte)) {
+    	      i = this.handleText(++i, service, {
+    	        isMultiByte: true
+    	      });
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the CW# command.
+    	   *
+    	   * Set the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setCurrentWindow = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var windowNum = b & 0x07;
+    	    service.setCurrentWindow(windowNum);
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the DF# command.
+    	   *
+    	   * Define a window and set it as the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.defineWindow = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var windowNum = b & 0x07;
+    	    service.setCurrentWindow(windowNum);
+    	    var win = service.currentWindow;
+    	    b = packetData[++i];
+    	    win.visible = (b & 0x20) >> 5; // v
+    	    win.rowLock = (b & 0x10) >> 4; // rl
+    	    win.columnLock = (b & 0x08) >> 3; // cl
+    	    win.priority = b & 0x07; // p
+
+    	    b = packetData[++i];
+    	    win.relativePositioning = (b & 0x80) >> 7; // rp
+    	    win.anchorVertical = b & 0x7f; // av
+
+    	    b = packetData[++i];
+    	    win.anchorHorizontal = b; // ah
+
+    	    b = packetData[++i];
+    	    win.anchorPoint = (b & 0xf0) >> 4; // ap
+    	    win.rowCount = b & 0x0f; // rc
+
+    	    b = packetData[++i];
+    	    win.columnCount = b & 0x3f; // cc
+
+    	    b = packetData[++i];
+    	    win.windowStyle = (b & 0x38) >> 3; // ws
+    	    win.penStyle = b & 0x07; // ps
+
+    	    // The spec says there are (rowCount+1) "virtual rows"
+    	    win.virtualRowCount = win.rowCount + 1;
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SWA command.
+    	   *
+    	   * Set attributes of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setWindowAttributes = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var winAttr = service.currentWindow.winAttr;
+    	    b = packetData[++i];
+    	    winAttr.fillOpacity = (b & 0xc0) >> 6; // fo
+    	    winAttr.fillRed = (b & 0x30) >> 4; // fr
+    	    winAttr.fillGreen = (b & 0x0c) >> 2; // fg
+    	    winAttr.fillBlue = b & 0x03; // fb
+
+    	    b = packetData[++i];
+    	    winAttr.borderType = (b & 0xc0) >> 6; // bt
+    	    winAttr.borderRed = (b & 0x30) >> 4; // br
+    	    winAttr.borderGreen = (b & 0x0c) >> 2; // bg
+    	    winAttr.borderBlue = b & 0x03; // bb
+
+    	    b = packetData[++i];
+    	    winAttr.borderType += (b & 0x80) >> 5; // bt
+    	    winAttr.wordWrap = (b & 0x40) >> 6; // ww
+    	    winAttr.printDirection = (b & 0x30) >> 4; // pd
+    	    winAttr.scrollDirection = (b & 0x0c) >> 2; // sd
+    	    winAttr.justify = b & 0x03; // j
+
+    	    b = packetData[++i];
+    	    winAttr.effectSpeed = (b & 0xf0) >> 4; // es
+    	    winAttr.effectDirection = (b & 0x0c) >> 2; // ed
+    	    winAttr.displayEffect = b & 0x03; // de
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Gather text from all displayed windows and push a caption to output.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   */
+    	  Cea708Stream.prototype.flushDisplayed = function (pts, service) {
+    	    var displayedText = [];
+
+    	    // TODO: Positioning not supported, displaying multiple windows will not necessarily
+    	    // display text in the correct order, but sample files so far have not shown any issue.
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (service.windows[winId].visible && !service.windows[winId].isEmpty()) {
+    	        displayedText.push(service.windows[winId].getText());
+    	      }
+    	    }
+    	    service.endPts = pts;
+    	    service.text = displayedText.join('\n\n');
+    	    this.pushCaption(service);
+    	    service.startPts = pts;
+    	  };
+
+    	  /**
+    	   * Push a caption to output if the caption contains text.
+    	   *
+    	   * @param  {Service} service  The service object to be affected
+    	   */
+    	  Cea708Stream.prototype.pushCaption = function (service) {
+    	    if (service.text !== '') {
+    	      this.trigger('data', {
+    	        startPts: service.startPts,
+    	        endPts: service.endPts,
+    	        text: service.text,
+    	        stream: 'cc708_' + service.serviceNum
+    	      });
+    	      service.text = '';
+    	      service.startPts = service.endPts;
+    	    }
+    	  };
+
+    	  /**
+    	   * Parse and execute the DSW command.
+    	   *
+    	   * Set visible property of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.displayWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].visible = 1;
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the HDW command.
+    	   *
+    	   * Set visible property of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.hideWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].visible = 0;
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the TGW command.
+    	   *
+    	   * Set visible property of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.toggleWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].visible ^= 1;
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the CLW command.
+    	   *
+    	   * Clear text of windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.clearWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].clearText();
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the DLW command.
+    	   *
+    	   * Re-initialize windows based on the parsed bitmask.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.deleteWindows = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[++i];
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    for (var winId = 0; winId < 8; winId++) {
+    	      if (b & 0x01 << winId) {
+    	        service.windows[winId].reset();
+    	      }
+    	    }
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SPA command.
+    	   *
+    	   * Set pen attributes of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setPenAttributes = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var penAttr = service.currentWindow.penAttr;
+    	    b = packetData[++i];
+    	    penAttr.textTag = (b & 0xf0) >> 4; // tt
+    	    penAttr.offset = (b & 0x0c) >> 2; // o
+    	    penAttr.penSize = b & 0x03; // s
+
+    	    b = packetData[++i];
+    	    penAttr.italics = (b & 0x80) >> 7; // i
+    	    penAttr.underline = (b & 0x40) >> 6; // u
+    	    penAttr.edgeType = (b & 0x38) >> 3; // et
+    	    penAttr.fontStyle = b & 0x07; // fs
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SPC command.
+    	   *
+    	   * Set pen color of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setPenColor = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var penColor = service.currentWindow.penColor;
+    	    b = packetData[++i];
+    	    penColor.fgOpacity = (b & 0xc0) >> 6; // fo
+    	    penColor.fgRed = (b & 0x30) >> 4; // fr
+    	    penColor.fgGreen = (b & 0x0c) >> 2; // fg
+    	    penColor.fgBlue = b & 0x03; // fb
+
+    	    b = packetData[++i];
+    	    penColor.bgOpacity = (b & 0xc0) >> 6; // bo
+    	    penColor.bgRed = (b & 0x30) >> 4; // br
+    	    penColor.bgGreen = (b & 0x0c) >> 2; // bg
+    	    penColor.bgBlue = b & 0x03; // bb
+
+    	    b = packetData[++i];
+    	    penColor.edgeRed = (b & 0x30) >> 4; // er
+    	    penColor.edgeGreen = (b & 0x0c) >> 2; // eg
+    	    penColor.edgeBlue = b & 0x03; // eb
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Parse and execute the SPL command.
+    	   *
+    	   * Set pen location of the current window.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Integer}          New index after parsing
+    	   */
+    	  Cea708Stream.prototype.setPenLocation = function (i, service) {
+    	    var packetData = this.current708Packet.data;
+    	    var b = packetData[i];
+    	    var penLoc = service.currentWindow.penLoc;
+
+    	    // Positioning isn't really supported at the moment, so this essentially just inserts a linebreak
+    	    service.currentWindow.pendingNewLine = true;
+    	    b = packetData[++i];
+    	    penLoc.row = b & 0x0f; // r
+
+    	    b = packetData[++i];
+    	    penLoc.column = b & 0x3f; // c
+
+    	    return i;
+    	  };
+
+    	  /**
+    	   * Execute the RST command.
+    	   *
+    	   * Reset service to a clean slate. Re-initialize.
+    	   *
+    	   * @param  {Integer} i        Current index in the 708 packet
+    	   * @param  {Service} service  The service object to be affected
+    	   * @return {Service}          Re-initialized service
+    	   */
+    	  Cea708Stream.prototype.reset = function (i, service) {
+    	    var pts = this.getPts(i);
+    	    this.flushDisplayed(pts, service);
+    	    return this.initService(service.serviceNum, i);
+    	  };
+
+    	  // This hash maps non-ASCII, special, and extended character codes to their
+    	  // proper Unicode equivalent. The first keys that are only a single byte
+    	  // are the non-standard ASCII characters, which simply map the CEA608 byte
+    	  // to the standard ASCII/Unicode. The two-byte keys that follow are the CEA608
+    	  // character codes, but have their MSB bitmasked with 0x03 so that a lookup
+    	  // can be performed regardless of the field and data channel on which the
+    	  // character code was received.
+    	  var CHARACTER_TRANSLATION = {
+    	    0x2a: 0xe1,
+    	    // á
+    	    0x5c: 0xe9,
+    	    // é
+    	    0x5e: 0xed,
+    	    // í
+    	    0x5f: 0xf3,
+    	    // ó
+    	    0x60: 0xfa,
+    	    // ú
+    	    0x7b: 0xe7,
+    	    // ç
+    	    0x7c: 0xf7,
+    	    // ÷
+    	    0x7d: 0xd1,
+    	    // Ñ
+    	    0x7e: 0xf1,
+    	    // ñ
+    	    0x7f: 0x2588,
+    	    // █
+    	    0x0130: 0xae,
+    	    // ®
+    	    0x0131: 0xb0,
+    	    // °
+    	    0x0132: 0xbd,
+    	    // ½
+    	    0x0133: 0xbf,
+    	    // ¿
+    	    0x0134: 0x2122,
+    	    // ™
+    	    0x0135: 0xa2,
+    	    // ¢
+    	    0x0136: 0xa3,
+    	    // £
+    	    0x0137: 0x266a,
+    	    // ♪
+    	    0x0138: 0xe0,
+    	    // à
+    	    0x0139: 0xa0,
+    	    //
+    	    0x013a: 0xe8,
+    	    // è
+    	    0x013b: 0xe2,
+    	    // â
+    	    0x013c: 0xea,
+    	    // ê
+    	    0x013d: 0xee,
+    	    // î
+    	    0x013e: 0xf4,
+    	    // ô
+    	    0x013f: 0xfb,
+    	    // û
+    	    0x0220: 0xc1,
+    	    // Á
+    	    0x0221: 0xc9,
+    	    // É
+    	    0x0222: 0xd3,
+    	    // Ó
+    	    0x0223: 0xda,
+    	    // Ú
+    	    0x0224: 0xdc,
+    	    // Ü
+    	    0x0225: 0xfc,
+    	    // ü
+    	    0x0226: 0x2018,
+    	    // ‘
+    	    0x0227: 0xa1,
+    	    // ¡
+    	    0x0228: 0x2a,
+    	    // *
+    	    0x0229: 0x27,
+    	    // '
+    	    0x022a: 0x2014,
+    	    // —
+    	    0x022b: 0xa9,
+    	    // ©
+    	    0x022c: 0x2120,
+    	    // ℠
+    	    0x022d: 0x2022,
+    	    // •
+    	    0x022e: 0x201c,
+    	    // “
+    	    0x022f: 0x201d,
+    	    // ”
+    	    0x0230: 0xc0,
+    	    // À
+    	    0x0231: 0xc2,
+    	    // Â
+    	    0x0232: 0xc7,
+    	    // Ç
+    	    0x0233: 0xc8,
+    	    // È
+    	    0x0234: 0xca,
+    	    // Ê
+    	    0x0235: 0xcb,
+    	    // Ë
+    	    0x0236: 0xeb,
+    	    // ë
+    	    0x0237: 0xce,
+    	    // Î
+    	    0x0238: 0xcf,
+    	    // Ï
+    	    0x0239: 0xef,
+    	    // ï
+    	    0x023a: 0xd4,
+    	    // Ô
+    	    0x023b: 0xd9,
+    	    // Ù
+    	    0x023c: 0xf9,
+    	    // ù
+    	    0x023d: 0xdb,
+    	    // Û
+    	    0x023e: 0xab,
+    	    // «
+    	    0x023f: 0xbb,
+    	    // »
+    	    0x0320: 0xc3,
+    	    // Ã
+    	    0x0321: 0xe3,
+    	    // ã
+    	    0x0322: 0xcd,
+    	    // Í
+    	    0x0323: 0xcc,
+    	    // Ì
+    	    0x0324: 0xec,
+    	    // ì
+    	    0x0325: 0xd2,
+    	    // Ò
+    	    0x0326: 0xf2,
+    	    // ò
+    	    0x0327: 0xd5,
+    	    // Õ
+    	    0x0328: 0xf5,
+    	    // õ
+    	    0x0329: 0x7b,
+    	    // {
+    	    0x032a: 0x7d,
+    	    // }
+    	    0x032b: 0x5c,
+    	    // \
+    	    0x032c: 0x5e,
+    	    // ^
+    	    0x032d: 0x5f,
+    	    // _
+    	    0x032e: 0x7c,
+    	    // |
+    	    0x032f: 0x7e,
+    	    // ~
+    	    0x0330: 0xc4,
+    	    // Ä
+    	    0x0331: 0xe4,
+    	    // ä
+    	    0x0332: 0xd6,
+    	    // Ö
+    	    0x0333: 0xf6,
+    	    // ö
+    	    0x0334: 0xdf,
+    	    // ß
+    	    0x0335: 0xa5,
+    	    // ¥
+    	    0x0336: 0xa4,
+    	    // ¤
+    	    0x0337: 0x2502,
+    	    // │
+    	    0x0338: 0xc5,
+    	    // Å
+    	    0x0339: 0xe5,
+    	    // å
+    	    0x033a: 0xd8,
+    	    // Ø
+    	    0x033b: 0xf8,
+    	    // ø
+    	    0x033c: 0x250c,
+    	    // ┌
+    	    0x033d: 0x2510,
+    	    // ┐
+    	    0x033e: 0x2514,
+    	    // └
+    	    0x033f: 0x2518 // ┘
+    	  };
+
+    	  var getCharFromCode = function getCharFromCode(code) {
+    	    if (code === null) {
+    	      return '';
+    	    }
+    	    code = CHARACTER_TRANSLATION[code] || code;
+    	    return String.fromCharCode(code);
+    	  };
+
+    	  // the index of the last row in a CEA-608 display buffer
+    	  var BOTTOM_ROW = 14;
+
+    	  // This array is used for mapping PACs -> row #, since there's no way of
+    	  // getting it through bit logic.
+    	  var ROWS = [0x1100, 0x1120, 0x1200, 0x1220, 0x1500, 0x1520, 0x1600, 0x1620, 0x1700, 0x1720, 0x1000, 0x1300, 0x1320, 0x1400, 0x1420];
+
+    	  // CEA-608 captions are rendered onto a 34x15 matrix of character
+    	  // cells. The "bottom" row is the last element in the outer array.
+    	  var createDisplayBuffer = function createDisplayBuffer() {
+    	    var result = [],
+    	      i = BOTTOM_ROW + 1;
+    	    while (i--) {
+    	      result.push('');
+    	    }
+    	    return result;
+    	  };
+    	  var Cea608Stream = function Cea608Stream(field, dataChannel) {
+    	    Cea608Stream.prototype.init.call(this);
+    	    this.field_ = field || 0;
+    	    this.dataChannel_ = dataChannel || 0;
+    	    this.name_ = 'CC' + ((this.field_ << 1 | this.dataChannel_) + 1);
+    	    this.setConstants();
+    	    this.reset();
+    	    this.push = function (packet) {
+    	      var data, swap, char0, char1, text;
+    	      // remove the parity bits
+    	      data = packet.ccData & 0x7f7f;
+
+    	      // ignore duplicate control codes; the spec demands they're sent twice
+    	      if (data === this.lastControlCode_) {
+    	        this.lastControlCode_ = null;
+    	        return;
+    	      }
+
+    	      // Store control codes
+    	      if ((data & 0xf000) === 0x1000) {
+    	        this.lastControlCode_ = data;
+    	      } else if (data !== this.PADDING_) {
+    	        this.lastControlCode_ = null;
+    	      }
+    	      char0 = data >>> 8;
+    	      char1 = data & 0xff;
+    	      if (data === this.PADDING_) {
+    	        return;
+    	      } else if (data === this.RESUME_CAPTION_LOADING_) {
+    	        this.mode_ = 'popOn';
+    	      } else if (data === this.END_OF_CAPTION_) {
+    	        // If an EOC is received while in paint-on mode, the displayed caption
+    	        // text should be swapped to non-displayed memory as if it was a pop-on
+    	        // caption. Because of that, we should explicitly switch back to pop-on
+    	        // mode
+    	        this.mode_ = 'popOn';
+    	        this.clearFormatting(packet.pts);
+    	        // if a caption was being displayed, it's gone now
+    	        this.flushDisplayed(packet.pts);
+
+    	        // flip memory
+    	        swap = this.displayed_;
+    	        this.displayed_ = this.nonDisplayed_;
+    	        this.nonDisplayed_ = swap;
+
+    	        // start measuring the time to display the caption
+    	        this.startPts_ = packet.pts;
+    	      } else if (data === this.ROLL_UP_2_ROWS_) {
+    	        this.rollUpRows_ = 2;
+    	        this.setRollUp(packet.pts);
+    	      } else if (data === this.ROLL_UP_3_ROWS_) {
+    	        this.rollUpRows_ = 3;
+    	        this.setRollUp(packet.pts);
+    	      } else if (data === this.ROLL_UP_4_ROWS_) {
+    	        this.rollUpRows_ = 4;
+    	        this.setRollUp(packet.pts);
+    	      } else if (data === this.CARRIAGE_RETURN_) {
+    	        this.clearFormatting(packet.pts);
+    	        this.flushDisplayed(packet.pts);
+    	        this.shiftRowsUp_();
+    	        this.startPts_ = packet.pts;
+    	      } else if (data === this.BACKSPACE_) {
+    	        if (this.mode_ === 'popOn') {
+    	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+    	        } else {
+    	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+    	        }
+    	      } else if (data === this.ERASE_DISPLAYED_MEMORY_) {
+    	        this.flushDisplayed(packet.pts);
+    	        this.displayed_ = createDisplayBuffer();
+    	      } else if (data === this.ERASE_NON_DISPLAYED_MEMORY_) {
+    	        this.nonDisplayed_ = createDisplayBuffer();
+    	      } else if (data === this.RESUME_DIRECT_CAPTIONING_) {
+    	        if (this.mode_ !== 'paintOn') {
+    	          // NOTE: This should be removed when proper caption positioning is
+    	          // implemented
+    	          this.flushDisplayed(packet.pts);
+    	          this.displayed_ = createDisplayBuffer();
+    	        }
+    	        this.mode_ = 'paintOn';
+    	        this.startPts_ = packet.pts;
+
+    	        // Append special characters to caption text
+    	      } else if (this.isSpecialCharacter(char0, char1)) {
+    	        // Bitmask char0 so that we can apply character transformations
+    	        // regardless of field and data channel.
+    	        // Then byte-shift to the left and OR with char1 so we can pass the
+    	        // entire character code to `getCharFromCode`.
+    	        char0 = (char0 & 0x03) << 8;
+    	        text = getCharFromCode(char0 | char1);
+    	        this[this.mode_](packet.pts, text);
+    	        this.column_++;
+
+    	        // Append extended characters to caption text
+    	      } else if (this.isExtCharacter(char0, char1)) {
+    	        // Extended characters always follow their "non-extended" equivalents.
+    	        // IE if a "è" is desired, you'll always receive "eè"; non-compliant
+    	        // decoders are supposed to drop the "è", while compliant decoders
+    	        // backspace the "e" and insert "è".
+
+    	        // Delete the previous character
+    	        if (this.mode_ === 'popOn') {
+    	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+    	        } else {
+    	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+    	        }
+
+    	        // Bitmask char0 so that we can apply character transformations
+    	        // regardless of field and data channel.
+    	        // Then byte-shift to the left and OR with char1 so we can pass the
+    	        // entire character code to `getCharFromCode`.
+    	        char0 = (char0 & 0x03) << 8;
+    	        text = getCharFromCode(char0 | char1);
+    	        this[this.mode_](packet.pts, text);
+    	        this.column_++;
+
+    	        // Process mid-row codes
+    	      } else if (this.isMidRowCode(char0, char1)) {
+    	        // Attributes are not additive, so clear all formatting
+    	        this.clearFormatting(packet.pts);
+
+    	        // According to the standard, mid-row codes
+    	        // should be replaced with spaces, so add one now
+    	        this[this.mode_](packet.pts, ' ');
+    	        this.column_++;
+    	        if ((char1 & 0xe) === 0xe) {
+    	          this.addFormatting(packet.pts, ['i']);
+    	        }
+    	        if ((char1 & 0x1) === 0x1) {
+    	          this.addFormatting(packet.pts, ['u']);
+    	        }
+
+    	        // Detect offset control codes and adjust cursor
+    	      } else if (this.isOffsetControlCode(char0, char1)) {
+    	        // Cursor position is set by indent PAC (see below) in 4-column
+    	        // increments, with an additional offset code of 1-3 to reach any
+    	        // of the 32 columns specified by CEA-608. So all we need to do
+    	        // here is increment the column cursor by the given offset.
+    	        this.column_ += char1 & 0x03;
+
+    	        // Detect PACs (Preamble Address Codes)
+    	      } else if (this.isPAC(char0, char1)) {
+    	        // There's no logic for PAC -> row mapping, so we have to just
+    	        // find the row code in an array and use its index :(
+    	        var row = ROWS.indexOf(data & 0x1f20);
+
+    	        // Configure the caption window if we're in roll-up mode
+    	        if (this.mode_ === 'rollUp') {
+    	          // This implies that the base row is incorrectly set.
+    	          // As per the recommendation in CEA-608(Base Row Implementation), defer to the number
+    	          // of roll-up rows set.
+    	          if (row - this.rollUpRows_ + 1 < 0) {
+    	            row = this.rollUpRows_ - 1;
+    	          }
+    	          this.setRollUp(packet.pts, row);
+    	        }
+    	        if (row !== this.row_) {
+    	          // formatting is only persistent for current row
+    	          this.clearFormatting(packet.pts);
+    	          this.row_ = row;
+    	        }
+    	        // All PACs can apply underline, so detect and apply
+    	        // (All odd-numbered second bytes set underline)
+    	        if (char1 & 0x1 && this.formatting_.indexOf('u') === -1) {
+    	          this.addFormatting(packet.pts, ['u']);
+    	        }
+    	        if ((data & 0x10) === 0x10) {
+    	          // We've got an indent level code. Each successive even number
+    	          // increments the column cursor by 4, so we can get the desired
+    	          // column position by bit-shifting to the right (to get n/2)
+    	          // and multiplying by 4.
+    	          this.column_ = ((data & 0xe) >> 1) * 4;
+    	        }
+    	        if (this.isColorPAC(char1)) {
+    	          // it's a color code, though we only support white, which
+    	          // can be either normal or italicized. white italics can be
+    	          // either 0x4e or 0x6e depending on the row, so we just
+    	          // bitwise-and with 0xe to see if italics should be turned on
+    	          if ((char1 & 0xe) === 0xe) {
+    	            this.addFormatting(packet.pts, ['i']);
+    	          }
+    	        }
+
+    	        // We have a normal character in char0, and possibly one in char1
+    	      } else if (this.isNormalChar(char0)) {
+    	        if (char1 === 0x00) {
+    	          char1 = null;
+    	        }
+    	        text = getCharFromCode(char0);
+    	        text += getCharFromCode(char1);
+    	        this[this.mode_](packet.pts, text);
+    	        this.column_ += text.length;
+    	      } // finish data processing
+    	    };
+    	  };
+
+    	  Cea608Stream.prototype = new stream();
+    	  // Trigger a cue point that captures the current state of the
+    	  // display buffer
+    	  Cea608Stream.prototype.flushDisplayed = function (pts) {
+    	    var content = this.displayed_
+    	    // remove spaces from the start and end of the string
+    	    .map(function (row, index) {
+    	      try {
+    	        return row.trim();
+    	      } catch (e) {
+    	        // Ordinarily, this shouldn't happen. However, caption
+    	        // parsing errors should not throw exceptions and
+    	        // break playback.
+    	        this.trigger('log', {
+    	          level: 'warn',
+    	          message: 'Skipping a malformed 608 caption at index ' + index + '.'
+    	        });
+    	        return '';
+    	      }
+    	    }, this)
+    	    // combine all text rows to display in one cue
+    	    .join('\n')
+    	    // and remove blank rows from the start and end, but not the middle
+    	    .replace(/^\n+|\n+$/g, '');
+    	    if (content.length) {
+    	      this.trigger('data', {
+    	        startPts: this.startPts_,
+    	        endPts: pts,
+    	        text: content,
+    	        stream: this.name_
+    	      });
+    	    }
+    	  };
+
+    	  /**
+    	   * Zero out the data, used for startup and on seek
+    	   */
+    	  Cea608Stream.prototype.reset = function () {
+    	    this.mode_ = 'popOn';
+    	    // When in roll-up mode, the index of the last row that will
+    	    // actually display captions. If a caption is shifted to a row
+    	    // with a lower index than this, it is cleared from the display
+    	    // buffer
+    	    this.topRow_ = 0;
+    	    this.startPts_ = 0;
+    	    this.displayed_ = createDisplayBuffer();
+    	    this.nonDisplayed_ = createDisplayBuffer();
+    	    this.lastControlCode_ = null;
+
+    	    // Track row and column for proper line-breaking and spacing
+    	    this.column_ = 0;
+    	    this.row_ = BOTTOM_ROW;
+    	    this.rollUpRows_ = 2;
+
+    	    // This variable holds currently-applied formatting
+    	    this.formatting_ = [];
+    	  };
+
+    	  /**
+    	   * Sets up control code and related constants for this instance
+    	   */
+    	  Cea608Stream.prototype.setConstants = function () {
+    	    // The following attributes have these uses:
+    	    // ext_ :    char0 for mid-row codes, and the base for extended
+    	    //           chars (ext_+0, ext_+1, and ext_+2 are char0s for
+    	    //           extended codes)
+    	    // control_: char0 for control codes, except byte-shifted to the
+    	    //           left so that we can do this.control_ | CONTROL_CODE
+    	    // offset_:  char0 for tab offset codes
+    	    //
+    	    // It's also worth noting that control codes, and _only_ control codes,
+    	    // differ between field 1 and field2. Field 2 control codes are always
+    	    // their field 1 value plus 1. That's why there's the "| field" on the
+    	    // control value.
+    	    if (this.dataChannel_ === 0) {
+    	      this.BASE_ = 0x10;
+    	      this.EXT_ = 0x11;
+    	      this.CONTROL_ = (0x14 | this.field_) << 8;
+    	      this.OFFSET_ = 0x17;
+    	    } else if (this.dataChannel_ === 1) {
+    	      this.BASE_ = 0x18;
+    	      this.EXT_ = 0x19;
+    	      this.CONTROL_ = (0x1c | this.field_) << 8;
+    	      this.OFFSET_ = 0x1f;
+    	    }
+
+    	    // Constants for the LSByte command codes recognized by Cea608Stream. This
+    	    // list is not exhaustive. For a more comprehensive listing and semantics see
+    	    // http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf
+    	    // Padding
+    	    this.PADDING_ = 0x0000;
+    	    // Pop-on Mode
+    	    this.RESUME_CAPTION_LOADING_ = this.CONTROL_ | 0x20;
+    	    this.END_OF_CAPTION_ = this.CONTROL_ | 0x2f;
+    	    // Roll-up Mode
+    	    this.ROLL_UP_2_ROWS_ = this.CONTROL_ | 0x25;
+    	    this.ROLL_UP_3_ROWS_ = this.CONTROL_ | 0x26;
+    	    this.ROLL_UP_4_ROWS_ = this.CONTROL_ | 0x27;
+    	    this.CARRIAGE_RETURN_ = this.CONTROL_ | 0x2d;
+    	    // paint-on mode
+    	    this.RESUME_DIRECT_CAPTIONING_ = this.CONTROL_ | 0x29;
+    	    // Erasure
+    	    this.BACKSPACE_ = this.CONTROL_ | 0x21;
+    	    this.ERASE_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2c;
+    	    this.ERASE_NON_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2e;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet data is a special character
+    	   *
+    	   * Special characters have a second byte in the range 0x30 to 0x3f,
+    	   * with the first byte being 0x11 (for data channel 1) or 0x19 (for
+    	   * data channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are an special character
+    	   */
+    	  Cea608Stream.prototype.isSpecialCharacter = function (char0, char1) {
+    	    return char0 === this.EXT_ && char1 >= 0x30 && char1 <= 0x3f;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet data is an extended character
+    	   *
+    	   * Extended characters have a second byte in the range 0x20 to 0x3f,
+    	   * with the first byte being 0x12 or 0x13 (for data channel 1) or
+    	   * 0x1a or 0x1b (for data channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are an extended character
+    	   */
+    	  Cea608Stream.prototype.isExtCharacter = function (char0, char1) {
+    	    return (char0 === this.EXT_ + 1 || char0 === this.EXT_ + 2) && char1 >= 0x20 && char1 <= 0x3f;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet is a mid-row code
+    	   *
+    	   * Mid-row codes have a second byte in the range 0x20 to 0x2f, with
+    	   * the first byte being 0x11 (for data channel 1) or 0x19 (for data
+    	   * channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are a mid-row code
+    	   */
+    	  Cea608Stream.prototype.isMidRowCode = function (char0, char1) {
+    	    return char0 === this.EXT_ && char1 >= 0x20 && char1 <= 0x2f;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet is an offset control code
+    	   *
+    	   * Offset control codes have a second byte in the range 0x21 to 0x23,
+    	   * with the first byte being 0x17 (for data channel 1) or 0x1f (for
+    	   * data channel 2).
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are an offset control code
+    	   */
+    	  Cea608Stream.prototype.isOffsetControlCode = function (char0, char1) {
+    	    return char0 === this.OFFSET_ && char1 >= 0x21 && char1 <= 0x23;
+    	  };
+
+    	  /**
+    	   * Detects if the 2-byte packet is a Preamble Address Code
+    	   *
+    	   * PACs have a first byte in the range 0x10 to 0x17 (for data channel 1)
+    	   * or 0x18 to 0x1f (for data channel 2), with the second byte in the
+    	   * range 0x40 to 0x7f.
+    	   *
+    	   * @param  {Integer} char0 The first byte
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the 2 bytes are a PAC
+    	   */
+    	  Cea608Stream.prototype.isPAC = function (char0, char1) {
+    	    return char0 >= this.BASE_ && char0 < this.BASE_ + 8 && char1 >= 0x40 && char1 <= 0x7f;
+    	  };
+
+    	  /**
+    	   * Detects if a packet's second byte is in the range of a PAC color code
+    	   *
+    	   * PAC color codes have the second byte be in the range 0x40 to 0x4f, or
+    	   * 0x60 to 0x6f.
+    	   *
+    	   * @param  {Integer} char1 The second byte
+    	   * @return {Boolean}       Whether the byte is a color PAC
+    	   */
+    	  Cea608Stream.prototype.isColorPAC = function (char1) {
+    	    return char1 >= 0x40 && char1 <= 0x4f || char1 >= 0x60 && char1 <= 0x7f;
+    	  };
+
+    	  /**
+    	   * Detects if a single byte is in the range of a normal character
+    	   *
+    	   * Normal text bytes are in the range 0x20 to 0x7f.
+    	   *
+    	   * @param  {Integer} char  The byte
+    	   * @return {Boolean}       Whether the byte is a normal character
+    	   */
+    	  Cea608Stream.prototype.isNormalChar = function (char) {
+    	    return char >= 0x20 && char <= 0x7f;
+    	  };
+
+    	  /**
+    	   * Configures roll-up
+    	   *
+    	   * @param  {Integer} pts         Current PTS
+    	   * @param  {Integer} newBaseRow  Used by PACs to slide the current window to
+    	   *                               a new position
+    	   */
+    	  Cea608Stream.prototype.setRollUp = function (pts, newBaseRow) {
+    	    // Reset the base row to the bottom row when switching modes
+    	    if (this.mode_ !== 'rollUp') {
+    	      this.row_ = BOTTOM_ROW;
+    	      this.mode_ = 'rollUp';
+    	      // Spec says to wipe memories when switching to roll-up
+    	      this.flushDisplayed(pts);
+    	      this.nonDisplayed_ = createDisplayBuffer();
+    	      this.displayed_ = createDisplayBuffer();
+    	    }
+    	    if (newBaseRow !== undefined && newBaseRow !== this.row_) {
+    	      // move currently displayed captions (up or down) to the new base row
+    	      for (var i = 0; i < this.rollUpRows_; i++) {
+    	        this.displayed_[newBaseRow - i] = this.displayed_[this.row_ - i];
+    	        this.displayed_[this.row_ - i] = '';
+    	      }
+    	    }
+    	    if (newBaseRow === undefined) {
+    	      newBaseRow = this.row_;
+    	    }
+    	    this.topRow_ = newBaseRow - this.rollUpRows_ + 1;
+    	  };
+
+    	  // Adds the opening HTML tag for the passed character to the caption text,
+    	  // and keeps track of it for later closing
+    	  Cea608Stream.prototype.addFormatting = function (pts, format) {
+    	    this.formatting_ = this.formatting_.concat(format);
+    	    var text = format.reduce(function (text, format) {
+    	      return text + '<' + format + '>';
+    	    }, '');
+    	    this[this.mode_](pts, text);
+    	  };
+
+    	  // Adds HTML closing tags for current formatting to caption text and
+    	  // clears remembered formatting
+    	  Cea608Stream.prototype.clearFormatting = function (pts) {
+    	    if (!this.formatting_.length) {
+    	      return;
+    	    }
+    	    var text = this.formatting_.reverse().reduce(function (text, format) {
+    	      return text + '</' + format + '>';
+    	    }, '');
+    	    this.formatting_ = [];
+    	    this[this.mode_](pts, text);
+    	  };
+
+    	  // Mode Implementations
+    	  Cea608Stream.prototype.popOn = function (pts, text) {
+    	    var baseRow = this.nonDisplayed_[this.row_];
+
+    	    // buffer characters
+    	    baseRow += text;
+    	    this.nonDisplayed_[this.row_] = baseRow;
+    	  };
+    	  Cea608Stream.prototype.rollUp = function (pts, text) {
+    	    var baseRow = this.displayed_[this.row_];
+    	    baseRow += text;
+    	    this.displayed_[this.row_] = baseRow;
+    	  };
+    	  Cea608Stream.prototype.shiftRowsUp_ = function () {
+    	    var i;
+    	    // clear out inactive rows
+    	    for (i = 0; i < this.topRow_; i++) {
+    	      this.displayed_[i] = '';
+    	    }
+    	    for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {
+    	      this.displayed_[i] = '';
+    	    }
+    	    // shift displayed rows up
+    	    for (i = this.topRow_; i < this.row_; i++) {
+    	      this.displayed_[i] = this.displayed_[i + 1];
+    	    }
+    	    // clear out the bottom row
+    	    this.displayed_[this.row_] = '';
+    	  };
+    	  Cea608Stream.prototype.paintOn = function (pts, text) {
+    	    var baseRow = this.displayed_[this.row_];
+    	    baseRow += text;
+    	    this.displayed_[this.row_] = baseRow;
+    	  };
+
+    	  // exports
+    	  var captionStream = {
+    	    CaptionStream: CaptionStream,
+    	    Cea608Stream: Cea608Stream,
+    	    Cea708Stream: Cea708Stream
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+
+    	  var streamTypes = {
+    	    H264_STREAM_TYPE: 0x1B,
+    	    ADTS_STREAM_TYPE: 0x0F,
+    	    METADATA_STREAM_TYPE: 0x15
+    	  };
+
+    	  var MAX_TS = 8589934592;
+    	  var RO_THRESH = 4294967296;
+    	  var TYPE_SHARED = 'shared';
+    	  var handleRollover = function handleRollover(value, reference) {
+    	    var direction = 1;
+    	    if (value > reference) {
+    	      // If the current timestamp value is greater than our reference timestamp and we detect a
+    	      // timestamp rollover, this means the roll over is happening in the opposite direction.
+    	      // Example scenario: Enter a long stream/video just after a rollover occurred. The reference
+    	      // point will be set to a small number, e.g. 1. The user then seeks backwards over the
+    	      // rollover point. In loading this segment, the timestamp values will be very large,
+    	      // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust
+    	      // the time stamp to be `value - 2^33`.
+    	      direction = -1;
+    	    }
+
+    	    // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will
+    	    // cause an incorrect adjustment.
+    	    while (Math.abs(reference - value) > RO_THRESH) {
+    	      value += direction * MAX_TS;
+    	    }
+    	    return value;
+    	  };
+    	  var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {
+    	    var lastDTS, referenceDTS;
+    	    TimestampRolloverStream.prototype.init.call(this);
+
+    	    // The "shared" type is used in cases where a stream will contain muxed
+    	    // video and audio. We could use `undefined` here, but having a string
+    	    // makes debugging a little clearer.
+    	    this.type_ = type || TYPE_SHARED;
+    	    this.push = function (data) {
+    	      // Any "shared" rollover streams will accept _all_ data. Otherwise,
+    	      // streams will only accept data that matches their type.
+    	      if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {
+    	        return;
+    	      }
+    	      if (referenceDTS === undefined) {
+    	        referenceDTS = data.dts;
+    	      }
+    	      data.dts = handleRollover(data.dts, referenceDTS);
+    	      data.pts = handleRollover(data.pts, referenceDTS);
+    	      lastDTS = data.dts;
+    	      this.trigger('data', data);
+    	    };
+    	    this.flush = function () {
+    	      referenceDTS = lastDTS;
+    	      this.trigger('done');
+    	    };
+    	    this.endTimeline = function () {
+    	      this.flush();
+    	      this.trigger('endedtimeline');
+    	    };
+    	    this.discontinuity = function () {
+    	      referenceDTS = void 0;
+    	      lastDTS = void 0;
+    	    };
+    	    this.reset = function () {
+    	      this.discontinuity();
+    	      this.trigger('reset');
+    	    };
+    	  };
+    	  TimestampRolloverStream$1.prototype = new stream();
+    	  var timestampRolloverStream = {
+    	    TimestampRolloverStream: TimestampRolloverStream$1,
+    	    handleRollover: handleRollover
+    	  };
+
+    	  // IE11 doesn't support indexOf for TypedArrays.
+    	  // Once IE11 support is dropped, this function should be removed.
+    	  var typedArrayIndexOf$1 = function typedArrayIndexOf(typedArray, element, fromIndex) {
+    	    if (!typedArray) {
+    	      return -1;
+    	    }
+    	    var currentIndex = fromIndex;
+    	    for (; currentIndex < typedArray.length; currentIndex++) {
+    	      if (typedArray[currentIndex] === element) {
+    	        return currentIndex;
+    	      }
+    	    }
+    	    return -1;
+    	  };
+    	  var typedArray = {
+    	    typedArrayIndexOf: typedArrayIndexOf$1
+    	  };
+
+    	  var typedArrayIndexOf = typedArray.typedArrayIndexOf,
+    	    // Frames that allow different types of text encoding contain a text
+    	    // encoding description byte [ID3v2.4.0 section 4.]
+    	    textEncodingDescriptionByte = {
+    	      Iso88591: 0x00,
+    	      // ISO-8859-1, terminated with \0.
+    	      Utf16: 0x01,
+    	      // UTF-16 encoded Unicode BOM, terminated with \0\0
+    	      Utf16be: 0x02,
+    	      // UTF-16BE encoded Unicode, without BOM, terminated with \0\0
+    	      Utf8: 0x03 // UTF-8 encoded Unicode, terminated with \0
+    	    },
+    	    // return a percent-encoded representation of the specified byte range
+    	    // @see http://en.wikipedia.org/wiki/Percent-encoding 
+    	    percentEncode$1 = function percentEncode(bytes, start, end) {
+    	      var i,
+    	        result = '';
+    	      for (i = start; i < end; i++) {
+    	        result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+    	      }
+    	      return result;
+    	    },
+    	    // return the string representation of the specified byte range,
+    	    // interpreted as UTf-8.
+    	    parseUtf8 = function parseUtf8(bytes, start, end) {
+    	      return decodeURIComponent(percentEncode$1(bytes, start, end));
+    	    },
+    	    // return the string representation of the specified byte range,
+    	    // interpreted as ISO-8859-1.
+    	    parseIso88591$1 = function parseIso88591(bytes, start, end) {
+    	      return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line
+    	    },
+    	    parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {
+    	      return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+    	    },
+    	    frameParsers = {
+    	      'APIC': function APIC(frame) {
+    	        var i = 1,
+    	          mimeTypeEndIndex,
+    	          descriptionEndIndex,
+    	          LINK_MIME_TYPE = '-->';
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+
+    	        // parsing fields [ID3v2.4.0 section 4.14.]
+    	        mimeTypeEndIndex = typedArrayIndexOf(frame.data, 0, i);
+    	        if (mimeTypeEndIndex < 0) {
+    	          // malformed frame
+    	          return;
+    	        }
+
+    	        // parsing Mime type field (terminated with \0)
+    	        frame.mimeType = parseIso88591$1(frame.data, i, mimeTypeEndIndex);
+    	        i = mimeTypeEndIndex + 1;
+
+    	        // parsing 1-byte Picture Type field
+    	        frame.pictureType = frame.data[i];
+    	        i++;
+    	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, i);
+    	        if (descriptionEndIndex < 0) {
+    	          // malformed frame
+    	          return;
+    	        }
+
+    	        // parsing Description field (terminated with \0)
+    	        frame.description = parseUtf8(frame.data, i, descriptionEndIndex);
+    	        i = descriptionEndIndex + 1;
+    	        if (frame.mimeType === LINK_MIME_TYPE) {
+    	          // parsing Picture Data field as URL (always represented as ISO-8859-1 [ID3v2.4.0 section 4.])
+    	          frame.url = parseIso88591$1(frame.data, i, frame.data.length);
+    	        } else {
+    	          // parsing Picture Data field as binary data
+    	          frame.pictureData = frame.data.subarray(i, frame.data.length);
+    	        }
+    	      },
+    	      'T*': function T(frame) {
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+
+    	        // parse text field, do not include null terminator in the frame value
+    	        // frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
+    	        frame.value = parseUtf8(frame.data, 1, frame.data.length).replace(/\0*$/, '');
+    	        // text information frames supports multiple strings, stored as a terminator separated list [ID3v2.4.0 section 4.2.]
+    	        frame.values = frame.value.split('\0');
+    	      },
+    	      'TXXX': function TXXX(frame) {
+    	        var descriptionEndIndex;
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+    	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+    	        if (descriptionEndIndex === -1) {
+    	          return;
+    	        }
+
+    	        // parse the text fields
+    	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+    	        // do not include the null terminator in the tag value
+    	        // frames that allow different types of encoding contain terminated text
+    	        // [ID3v2.4.0 section 4.]
+    	        frame.value = parseUtf8(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0*$/, '');
+    	        frame.data = frame.value;
+    	      },
+    	      'W*': function W(frame) {
+    	        // parse URL field; URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+    	        // if the value is followed by a string termination all the following information should be ignored [ID3v2.4.0 section 4.3]
+    	        frame.url = parseIso88591$1(frame.data, 0, frame.data.length).replace(/\0.*$/, '');
+    	      },
+    	      'WXXX': function WXXX(frame) {
+    	        var descriptionEndIndex;
+    	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+    	          // ignore frames with unrecognized character encodings
+    	          return;
+    	        }
+    	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+    	        if (descriptionEndIndex === -1) {
+    	          return;
+    	        }
+
+    	        // parse the description and URL fields
+    	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+    	        // URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+    	        // if the value is followed by a string termination all the following information
+    	        // should be ignored [ID3v2.4.0 section 4.3]
+    	        frame.url = parseIso88591$1(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0.*$/, '');
+    	      },
+    	      'PRIV': function PRIV(frame) {
+    	        var i;
+    	        for (i = 0; i < frame.data.length; i++) {
+    	          if (frame.data[i] === 0) {
+    	            // parse the description and URL fields
+    	            frame.owner = parseIso88591$1(frame.data, 0, i);
+    	            break;
+    	          }
+    	        }
+    	        frame.privateData = frame.data.subarray(i + 1);
+    	        frame.data = frame.privateData;
+    	      }
+    	    };
+    	  var parseId3Frames = function parseId3Frames(data) {
+    	    var frameSize,
+    	      frameHeader,
+    	      frameStart = 10,
+    	      tagSize = 0,
+    	      frames = [];
+
+    	    // If we don't have enough data for a header, 10 bytes, 
+    	    // or 'ID3' in the first 3 bytes this is not a valid ID3 tag.
+    	    if (data.length < 10 || data[0] !== 'I'.charCodeAt(0) || data[1] !== 'D'.charCodeAt(0) || data[2] !== '3'.charCodeAt(0)) {
+    	      return;
+    	    }
+    	    // the frame size is transmitted as a 28-bit integer in the
+    	    // last four bytes of the ID3 header.
+    	    // The most significant bit of each byte is dropped and the
+    	    // results concatenated to recover the actual value.
+    	    tagSize = parseSyncSafeInteger$1(data.subarray(6, 10));
+
+    	    // ID3 reports the tag size excluding the header but it's more
+    	    // convenient for our comparisons to include it
+    	    tagSize += 10;
+    	    // check bit 6 of byte 5 for the extended header flag.
+    	    var hasExtendedHeader = data[5] & 0x40;
+    	    if (hasExtendedHeader) {
+    	      // advance the frame start past the extended header
+    	      frameStart += 4; // header size field
+    	      frameStart += parseSyncSafeInteger$1(data.subarray(10, 14));
+    	      tagSize -= parseSyncSafeInteger$1(data.subarray(16, 20)); // clip any padding off the end
+    	    }
+
+    	    // parse one or more ID3 frames
+    	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    	    do {
+    	      // determine the number of bytes in this frame
+    	      frameSize = parseSyncSafeInteger$1(data.subarray(frameStart + 4, frameStart + 8));
+    	      if (frameSize < 1) {
+    	        break;
+    	      }
+    	      frameHeader = String.fromCharCode(data[frameStart], data[frameStart + 1], data[frameStart + 2], data[frameStart + 3]);
+    	      var frame = {
+    	        id: frameHeader,
+    	        data: data.subarray(frameStart + 10, frameStart + frameSize + 10)
+    	      };
+    	      frame.key = frame.id;
+
+    	      // parse frame values
+    	      if (frameParsers[frame.id]) {
+    	        // use frame specific parser
+    	        frameParsers[frame.id](frame);
+    	      } else if (frame.id[0] === 'T') {
+    	        // use text frame generic parser
+    	        frameParsers['T*'](frame);
+    	      } else if (frame.id[0] === 'W') {
+    	        // use URL link frame generic parser
+    	        frameParsers['W*'](frame);
+    	      }
+    	      frames.push(frame);
+    	      frameStart += 10; // advance past the frame header
+    	      frameStart += frameSize; // advance past the frame body
+    	    } while (frameStart < tagSize);
+    	    return frames;
+    	  };
+    	  var parseId3 = {
+    	    parseId3Frames: parseId3Frames,
+    	    parseSyncSafeInteger: parseSyncSafeInteger$1,
+    	    frameParsers: frameParsers
+    	  };
+
+    	  var _MetadataStream;
+    	  _MetadataStream = function MetadataStream(options) {
+    	    var settings = {
+    	        // the bytes of the program-level descriptor field in MP2T
+    	        // see ISO/IEC 13818-1:2013 (E), section 2.6 "Program and
+    	        // program element descriptors"
+    	        descriptor: options && options.descriptor
+    	      },
+    	      // the total size in bytes of the ID3 tag being parsed
+    	      tagSize = 0,
+    	      // tag data that is not complete enough to be parsed
+    	      buffer = [],
+    	      // the total number of bytes currently in the buffer
+    	      bufferSize = 0,
+    	      i;
+    	    _MetadataStream.prototype.init.call(this);
+
+    	    // calculate the text track in-band metadata track dispatch type
+    	    // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
+    	    this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);
+    	    if (settings.descriptor) {
+    	      for (i = 0; i < settings.descriptor.length; i++) {
+    	        this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);
+    	      }
+    	    }
+    	    this.push = function (chunk) {
+    	      var tag, frameStart, frameSize, frame, i, frameHeader;
+    	      if (chunk.type !== 'timed-metadata') {
+    	        return;
+    	      }
+
+    	      // if data_alignment_indicator is set in the PES header,
+    	      // we must have the start of a new ID3 tag. Assume anything
+    	      // remaining in the buffer was malformed and throw it out
+    	      if (chunk.dataAlignmentIndicator) {
+    	        bufferSize = 0;
+    	        buffer.length = 0;
+    	      }
+
+    	      // ignore events that don't look like ID3 data
+    	      if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {
+    	        this.trigger('log', {
+    	          level: 'warn',
+    	          message: 'Skipping unrecognized metadata packet'
+    	        });
+    	        return;
+    	      }
+
+    	      // add this chunk to the data we've collected so far
+
+    	      buffer.push(chunk);
+    	      bufferSize += chunk.data.byteLength;
+
+    	      // grab the size of the entire frame from the ID3 header
+    	      if (buffer.length === 1) {
+    	        // the frame size is transmitted as a 28-bit integer in the
+    	        // last four bytes of the ID3 header.
+    	        // The most significant bit of each byte is dropped and the
+    	        // results concatenated to recover the actual value.
+    	        tagSize = parseId3.parseSyncSafeInteger(chunk.data.subarray(6, 10));
+
+    	        // ID3 reports the tag size excluding the header but it's more
+    	        // convenient for our comparisons to include it
+    	        tagSize += 10;
+    	      }
+
+    	      // if the entire frame has not arrived, wait for more data
+    	      if (bufferSize < tagSize) {
+    	        return;
+    	      }
+
+    	      // collect the entire frame so it can be parsed
+    	      tag = {
+    	        data: new Uint8Array(tagSize),
+    	        frames: [],
+    	        pts: buffer[0].pts,
+    	        dts: buffer[0].dts
+    	      };
+    	      for (i = 0; i < tagSize;) {
+    	        tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);
+    	        i += buffer[0].data.byteLength;
+    	        bufferSize -= buffer[0].data.byteLength;
+    	        buffer.shift();
+    	      }
+
+    	      // find the start of the first frame and the end of the tag
+    	      frameStart = 10;
+    	      if (tag.data[5] & 0x40) {
+    	        // advance the frame start past the extended header
+    	        frameStart += 4; // header size field
+    	        frameStart += parseId3.parseSyncSafeInteger(tag.data.subarray(10, 14));
+
+    	        // clip any padding off the end
+    	        tagSize -= parseId3.parseSyncSafeInteger(tag.data.subarray(16, 20));
+    	      }
+
+    	      // parse one or more ID3 frames
+    	      // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    	      do {
+    	        // determine the number of bytes in this frame
+    	        frameSize = parseId3.parseSyncSafeInteger(tag.data.subarray(frameStart + 4, frameStart + 8));
+    	        if (frameSize < 1) {
+    	          this.trigger('log', {
+    	            level: 'warn',
+    	            message: 'Malformed ID3 frame encountered. Skipping remaining metadata parsing.'
+    	          });
+    	          // If the frame is malformed, don't parse any further frames but allow previous valid parsed frames
+    	          // to be sent along.
+    	          break;
+    	        }
+    	        frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);
+    	        frame = {
+    	          id: frameHeader,
+    	          data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)
+    	        };
+    	        frame.key = frame.id;
+
+    	        // parse frame values
+    	        if (parseId3.frameParsers[frame.id]) {
+    	          // use frame specific parser
+    	          parseId3.frameParsers[frame.id](frame);
+    	        } else if (frame.id[0] === 'T') {
+    	          // use text frame generic parser
+    	          parseId3.frameParsers['T*'](frame);
+    	        } else if (frame.id[0] === 'W') {
+    	          // use URL link frame generic parser
+    	          parseId3.frameParsers['W*'](frame);
+    	        }
+
+    	        // handle the special PRIV frame used to indicate the start
+    	        // time for raw AAC data
+    	        if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {
+    	          var d = frame.data,
+    	            size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+    	          size *= 4;
+    	          size += d[7] & 0x03;
+    	          frame.timeStamp = size;
+    	          // in raw AAC, all subsequent data will be timestamped based
+    	          // on the value of this frame
+    	          // we couldn't have known the appropriate pts and dts before
+    	          // parsing this ID3 tag so set those values now
+    	          if (tag.pts === undefined && tag.dts === undefined) {
+    	            tag.pts = frame.timeStamp;
+    	            tag.dts = frame.timeStamp;
+    	          }
+    	          this.trigger('timestamp', frame);
+    	        }
+    	        tag.frames.push(frame);
+    	        frameStart += 10; // advance past the frame header
+    	        frameStart += frameSize; // advance past the frame body
+    	      } while (frameStart < tagSize);
+    	      this.trigger('data', tag);
+    	    };
+    	  };
+    	  _MetadataStream.prototype = new stream();
+    	  var metadataStream = _MetadataStream;
+
+    	  var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream;
+
+    	  // object types
+    	  var _TransportPacketStream, _TransportParseStream, _ElementaryStream;
+
+    	  // constants
+    	  var MP2T_PACKET_LENGTH = 188,
+    	    // bytes
+    	    SYNC_BYTE = 0x47;
+
+    	  /**
+    	   * Splits an incoming stream of binary data into MPEG-2 Transport
+    	   * Stream packets.
+    	   */
+    	  _TransportPacketStream = function TransportPacketStream() {
+    	    var buffer = new Uint8Array(MP2T_PACKET_LENGTH),
+    	      bytesInBuffer = 0;
+    	    _TransportPacketStream.prototype.init.call(this);
+
+    	    // Deliver new bytes to the stream.
+
+    	    /**
+    	     * Split a stream of data into M2TS packets
+    	    **/
+    	    this.push = function (bytes) {
+    	      var startIndex = 0,
+    	        endIndex = MP2T_PACKET_LENGTH,
+    	        everything;
+
+    	      // If there are bytes remaining from the last segment, prepend them to the
+    	      // bytes that were pushed in
+    	      if (bytesInBuffer) {
+    	        everything = new Uint8Array(bytes.byteLength + bytesInBuffer);
+    	        everything.set(buffer.subarray(0, bytesInBuffer));
+    	        everything.set(bytes, bytesInBuffer);
+    	        bytesInBuffer = 0;
+    	      } else {
+    	        everything = bytes;
+    	      }
+
+    	      // While we have enough data for a packet
+    	      while (endIndex < everything.byteLength) {
+    	        // Look for a pair of start and end sync bytes in the data..
+    	        if (everything[startIndex] === SYNC_BYTE && everything[endIndex] === SYNC_BYTE) {
+    	          // We found a packet so emit it and jump one whole packet forward in
+    	          // the stream
+    	          this.trigger('data', everything.subarray(startIndex, endIndex));
+    	          startIndex += MP2T_PACKET_LENGTH;
+    	          endIndex += MP2T_PACKET_LENGTH;
+    	          continue;
+    	        }
+    	        // If we get here, we have somehow become de-synchronized and we need to step
+    	        // forward one byte at a time until we find a pair of sync bytes that denote
+    	        // a packet
+    	        startIndex++;
+    	        endIndex++;
+    	      }
+
+    	      // If there was some data left over at the end of the segment that couldn't
+    	      // possibly be a whole packet, keep it because it might be the start of a packet
+    	      // that continues in the next segment
+    	      if (startIndex < everything.byteLength) {
+    	        buffer.set(everything.subarray(startIndex), 0);
+    	        bytesInBuffer = everything.byteLength - startIndex;
+    	      }
+    	    };
+
+    	    /**
+    	     * Passes identified M2TS packets to the TransportParseStream to be parsed
+    	    **/
+    	    this.flush = function () {
+    	      // If the buffer contains a whole packet when we are being flushed, emit it
+    	      // and empty the buffer. Otherwise hold onto the data because it may be
+    	      // important for decoding the next segment
+    	      if (bytesInBuffer === MP2T_PACKET_LENGTH && buffer[0] === SYNC_BYTE) {
+    	        this.trigger('data', buffer);
+    	        bytesInBuffer = 0;
+    	      }
+    	      this.trigger('done');
+    	    };
+    	    this.endTimeline = function () {
+    	      this.flush();
+    	      this.trigger('endedtimeline');
+    	    };
+    	    this.reset = function () {
+    	      bytesInBuffer = 0;
+    	      this.trigger('reset');
+    	    };
+    	  };
+    	  _TransportPacketStream.prototype = new stream();
+
+    	  /**
+    	   * Accepts an MP2T TransportPacketStream and emits data events with parsed
+    	   * forms of the individual transport stream packets.
+    	   */
+    	  _TransportParseStream = function TransportParseStream() {
+    	    var parsePsi, parsePat, parsePmt, self;
+    	    _TransportParseStream.prototype.init.call(this);
+    	    self = this;
+    	    this.packetsWaitingForPmt = [];
+    	    this.programMapTable = undefined;
+    	    parsePsi = function parsePsi(payload, psi) {
+    	      var offset = 0;
+
+    	      // PSI packets may be split into multiple sections and those
+    	      // sections may be split into multiple packets. If a PSI
+    	      // section starts in this packet, the payload_unit_start_indicator
+    	      // will be true and the first byte of the payload will indicate
+    	      // the offset from the current position to the start of the
+    	      // section.
+    	      if (psi.payloadUnitStartIndicator) {
+    	        offset += payload[offset] + 1;
+    	      }
+    	      if (psi.type === 'pat') {
+    	        parsePat(payload.subarray(offset), psi);
+    	      } else {
+    	        parsePmt(payload.subarray(offset), psi);
+    	      }
+    	    };
+    	    parsePat = function parsePat(payload, pat) {
+    	      pat.section_number = payload[7]; // eslint-disable-line camelcase
+    	      pat.last_section_number = payload[8]; // eslint-disable-line camelcase
+
+    	      // skip the PSI header and parse the first PMT entry
+    	      self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];
+    	      pat.pmtPid = self.pmtPid;
+    	    };
+
+    	    /**
+    	     * Parse out the relevant fields of a Program Map Table (PMT).
+    	     * @param payload {Uint8Array} the PMT-specific portion of an MP2T
+    	     * packet. The first byte in this array should be the table_id
+    	     * field.
+    	     * @param pmt {object} the object that should be decorated with
+    	     * fields parsed from the PMT.
+    	     */
+    	    parsePmt = function parsePmt(payload, pmt) {
+    	      var sectionLength, tableEnd, programInfoLength, offset;
+
+    	      // PMTs can be sent ahead of the time when they should actually
+    	      // take effect. We don't believe this should ever be the case
+    	      // for HLS but we'll ignore "forward" PMT declarations if we see
+    	      // them. Future PMT declarations have the current_next_indicator
+    	      // set to zero.
+    	      if (!(payload[5] & 0x01)) {
+    	        return;
+    	      }
+
+    	      // overwrite any existing program map table
+    	      self.programMapTable = {
+    	        video: null,
+    	        audio: null,
+    	        'timed-metadata': {}
+    	      };
+
+    	      // the mapping table ends at the end of the current section
+    	      sectionLength = (payload[1] & 0x0f) << 8 | payload[2];
+    	      tableEnd = 3 + sectionLength - 4;
+
+    	      // to determine where the table is, we have to figure out how
+    	      // long the program info descriptors are
+    	      programInfoLength = (payload[10] & 0x0f) << 8 | payload[11];
+
+    	      // advance the offset to the first entry in the mapping table
+    	      offset = 12 + programInfoLength;
+    	      while (offset < tableEnd) {
+    	        var streamType = payload[offset];
+    	        var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2];
+
+    	        // only map a single elementary_pid for audio and video stream types
+    	        // TODO: should this be done for metadata too? for now maintain behavior of
+    	        //       multiple metadata streams
+    	        if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {
+    	          self.programMapTable.video = pid;
+    	        } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {
+    	          self.programMapTable.audio = pid;
+    	        } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {
+    	          // map pid to stream type for metadata streams
+    	          self.programMapTable['timed-metadata'][pid] = streamType;
+    	        }
+
+    	        // move to the next table entry
+    	        // skip past the elementary stream descriptors, if present
+    	        offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;
+    	      }
+
+    	      // record the map on the packet as well
+    	      pmt.programMapTable = self.programMapTable;
+    	    };
+
+    	    /**
+    	     * Deliver a new MP2T packet to the next stream in the pipeline.
+    	     */
+    	    this.push = function (packet) {
+    	      var result = {},
+    	        offset = 4;
+    	      result.payloadUnitStartIndicator = !!(packet[1] & 0x40);
+
+    	      // pid is a 13-bit field starting at the last bit of packet[1]
+    	      result.pid = packet[1] & 0x1f;
+    	      result.pid <<= 8;
+    	      result.pid |= packet[2];
+
+    	      // if an adaption field is present, its length is specified by the
+    	      // fifth byte of the TS packet header. The adaptation field is
+    	      // used to add stuffing to PES packets that don't fill a complete
+    	      // TS packet, and to specify some forms of timing and control data
+    	      // that we do not currently use.
+    	      if ((packet[3] & 0x30) >>> 4 > 0x01) {
+    	        offset += packet[offset] + 1;
+    	      }
+
+    	      // parse the rest of the packet based on the type
+    	      if (result.pid === 0) {
+    	        result.type = 'pat';
+    	        parsePsi(packet.subarray(offset), result);
+    	        this.trigger('data', result);
+    	      } else if (result.pid === this.pmtPid) {
+    	        result.type = 'pmt';
+    	        parsePsi(packet.subarray(offset), result);
+    	        this.trigger('data', result);
+
+    	        // if there are any packets waiting for a PMT to be found, process them now
+    	        while (this.packetsWaitingForPmt.length) {
+    	          this.processPes_.apply(this, this.packetsWaitingForPmt.shift());
+    	        }
+    	      } else if (this.programMapTable === undefined) {
+    	        // When we have not seen a PMT yet, defer further processing of
+    	        // PES packets until one has been parsed
+    	        this.packetsWaitingForPmt.push([packet, offset, result]);
+    	      } else {
+    	        this.processPes_(packet, offset, result);
+    	      }
+    	    };
+    	    this.processPes_ = function (packet, offset, result) {
+    	      // set the appropriate stream type
+    	      if (result.pid === this.programMapTable.video) {
+    	        result.streamType = streamTypes.H264_STREAM_TYPE;
+    	      } else if (result.pid === this.programMapTable.audio) {
+    	        result.streamType = streamTypes.ADTS_STREAM_TYPE;
+    	      } else {
+    	        // if not video or audio, it is timed-metadata or unknown
+    	        // if unknown, streamType will be undefined
+    	        result.streamType = this.programMapTable['timed-metadata'][result.pid];
+    	      }
+    	      result.type = 'pes';
+    	      result.data = packet.subarray(offset);
+    	      this.trigger('data', result);
+    	    };
+    	  };
+    	  _TransportParseStream.prototype = new stream();
+    	  _TransportParseStream.STREAM_TYPES = {
+    	    h264: 0x1b,
+    	    adts: 0x0f
+    	  };
+
+    	  /**
+    	   * Reconsistutes program elementary stream (PES) packets from parsed
+    	   * transport stream packets. That is, if you pipe an
+    	   * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output
+    	   * events will be events which capture the bytes for individual PES
+    	   * packets plus relevant metadata that has been extracted from the
+    	   * container.
+    	   */
+    	  _ElementaryStream = function ElementaryStream() {
+    	    var self = this,
+    	      segmentHadPmt = false,
+    	      // PES packet fragments
+    	      video = {
+    	        data: [],
+    	        size: 0
+    	      },
+    	      audio = {
+    	        data: [],
+    	        size: 0
+    	      },
+    	      timedMetadata = {
+    	        data: [],
+    	        size: 0
+    	      },
+    	      programMapTable,
+    	      parsePes = function parsePes(payload, pes) {
+    	        var ptsDtsFlags;
+    	        var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2];
+    	        // default to an empty array
+    	        pes.data = new Uint8Array();
+    	        // In certain live streams, the start of a TS fragment has ts packets
+    	        // that are frame data that is continuing from the previous fragment. This
+    	        // is to check that the pes data is the start of a new pes payload
+    	        if (startPrefix !== 1) {
+    	          return;
+    	        }
+    	        // get the packet length, this will be 0 for video
+    	        pes.packetLength = 6 + (payload[4] << 8 | payload[5]);
+
+    	        // find out if this packets starts a new keyframe
+    	        pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0;
+    	        // PES packets may be annotated with a PTS value, or a PTS value
+    	        // and a DTS value. Determine what combination of values is
+    	        // available to work with.
+    	        ptsDtsFlags = payload[7];
+
+    	        // PTS and DTS are normally stored as a 33-bit number.  Javascript
+    	        // performs all bitwise operations on 32-bit integers but javascript
+    	        // supports a much greater range (52-bits) of integer using standard
+    	        // mathematical operations.
+    	        // We construct a 31-bit value using bitwise operators over the 31
+    	        // most significant bits and then multiply by 4 (equal to a left-shift
+    	        // of 2) before we add the final 2 least significant bits of the
+    	        // timestamp (equal to an OR.)
+    	        if (ptsDtsFlags & 0xC0) {
+    	          // the PTS and DTS are not written out directly. For information
+    	          // on how they are encoded, see
+    	          // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
+    	          pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;
+    	          pes.pts *= 4; // Left shift by 2
+    	          pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs
+    	          pes.dts = pes.pts;
+    	          if (ptsDtsFlags & 0x40) {
+    	            pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;
+    	            pes.dts *= 4; // Left shift by 2
+    	            pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs
+    	          }
+    	        }
+    	        // the data section starts immediately after the PES header.
+    	        // pes_header_data_length specifies the number of header bytes
+    	        // that follow the last byte of the field.
+    	        pes.data = payload.subarray(9 + payload[8]);
+    	      },
+    	      /**
+    	        * Pass completely parsed PES packets to the next stream in the pipeline
+    	       **/
+    	      flushStream = function flushStream(stream, type, forceFlush) {
+    	        var packetData = new Uint8Array(stream.size),
+    	          event = {
+    	            type: type
+    	          },
+    	          i = 0,
+    	          offset = 0,
+    	          packetFlushable = false,
+    	          fragment;
+
+    	        // do nothing if there is not enough buffered data for a complete
+    	        // PES header
+    	        if (!stream.data.length || stream.size < 9) {
+    	          return;
+    	        }
+    	        event.trackId = stream.data[0].pid;
+
+    	        // reassemble the packet
+    	        for (i = 0; i < stream.data.length; i++) {
+    	          fragment = stream.data[i];
+    	          packetData.set(fragment.data, offset);
+    	          offset += fragment.data.byteLength;
+    	        }
+
+    	        // parse assembled packet's PES header
+    	        parsePes(packetData, event);
+
+    	        // non-video PES packets MUST have a non-zero PES_packet_length
+    	        // check that there is enough stream data to fill the packet
+    	        packetFlushable = type === 'video' || event.packetLength <= stream.size;
+
+    	        // flush pending packets if the conditions are right
+    	        if (forceFlush || packetFlushable) {
+    	          stream.size = 0;
+    	          stream.data.length = 0;
+    	        }
+
+    	        // only emit packets that are complete. this is to avoid assembling
+    	        // incomplete PES packets due to poor segmentation
+    	        if (packetFlushable) {
+    	          self.trigger('data', event);
+    	        }
+    	      };
+    	    _ElementaryStream.prototype.init.call(this);
+
+    	    /**
+    	     * Identifies M2TS packet types and parses PES packets using metadata
+    	     * parsed from the PMT
+    	     **/
+    	    this.push = function (data) {
+    	      ({
+    	        pat: function pat() {
+    	          // we have to wait for the PMT to arrive as well before we
+    	          // have any meaningful metadata
+    	        },
+    	        pes: function pes() {
+    	          var stream, streamType;
+    	          switch (data.streamType) {
+    	            case streamTypes.H264_STREAM_TYPE:
+    	              stream = video;
+    	              streamType = 'video';
+    	              break;
+    	            case streamTypes.ADTS_STREAM_TYPE:
+    	              stream = audio;
+    	              streamType = 'audio';
+    	              break;
+    	            case streamTypes.METADATA_STREAM_TYPE:
+    	              stream = timedMetadata;
+    	              streamType = 'timed-metadata';
+    	              break;
+    	            default:
+    	              // ignore unknown stream types
+    	              return;
+    	          }
+
+    	          // if a new packet is starting, we can flush the completed
+    	          // packet
+    	          if (data.payloadUnitStartIndicator) {
+    	            flushStream(stream, streamType, true);
+    	          }
+
+    	          // buffer this fragment until we are sure we've received the
+    	          // complete payload
+    	          stream.data.push(data);
+    	          stream.size += data.data.byteLength;
+    	        },
+    	        pmt: function pmt() {
+    	          var event = {
+    	            type: 'metadata',
+    	            tracks: []
+    	          };
+    	          programMapTable = data.programMapTable;
+
+    	          // translate audio and video streams to tracks
+    	          if (programMapTable.video !== null) {
+    	            event.tracks.push({
+    	              timelineStartInfo: {
+    	                baseMediaDecodeTime: 0
+    	              },
+    	              id: +programMapTable.video,
+    	              codec: 'avc',
+    	              type: 'video'
+    	            });
+    	          }
+    	          if (programMapTable.audio !== null) {
+    	            event.tracks.push({
+    	              timelineStartInfo: {
+    	                baseMediaDecodeTime: 0
+    	              },
+    	              id: +programMapTable.audio,
+    	              codec: 'adts',
+    	              type: 'audio'
+    	            });
+    	          }
+    	          segmentHadPmt = true;
+    	          self.trigger('data', event);
+    	        }
+    	      })[data.type]();
+    	    };
+    	    this.reset = function () {
+    	      video.size = 0;
+    	      video.data.length = 0;
+    	      audio.size = 0;
+    	      audio.data.length = 0;
+    	      this.trigger('reset');
+    	    };
+
+    	    /**
+    	     * Flush any remaining input. Video PES packets may be of variable
+    	     * length. Normally, the start of a new video packet can trigger the
+    	     * finalization of the previous packet. That is not possible if no
+    	     * more video is forthcoming, however. In that case, some other
+    	     * mechanism (like the end of the file) has to be employed. When it is
+    	     * clear that no additional data is forthcoming, calling this method
+    	     * will flush the buffered packets.
+    	     */
+    	    this.flushStreams_ = function () {
+    	      // !!THIS ORDER IS IMPORTANT!!
+    	      // video first then audio
+    	      flushStream(video, 'video');
+    	      flushStream(audio, 'audio');
+    	      flushStream(timedMetadata, 'timed-metadata');
+    	    };
+    	    this.flush = function () {
+    	      // if on flush we haven't had a pmt emitted
+    	      // and we have a pmt to emit. emit the pmt
+    	      // so that we trigger a trackinfo downstream.
+    	      if (!segmentHadPmt && programMapTable) {
+    	        var pmt = {
+    	          type: 'metadata',
+    	          tracks: []
+    	        };
+    	        // translate audio and video streams to tracks
+    	        if (programMapTable.video !== null) {
+    	          pmt.tracks.push({
+    	            timelineStartInfo: {
+    	              baseMediaDecodeTime: 0
+    	            },
+    	            id: +programMapTable.video,
+    	            codec: 'avc',
+    	            type: 'video'
+    	          });
+    	        }
+    	        if (programMapTable.audio !== null) {
+    	          pmt.tracks.push({
+    	            timelineStartInfo: {
+    	              baseMediaDecodeTime: 0
+    	            },
+    	            id: +programMapTable.audio,
+    	            codec: 'adts',
+    	            type: 'audio'
+    	          });
+    	        }
+    	        self.trigger('data', pmt);
+    	      }
+    	      segmentHadPmt = false;
+    	      this.flushStreams_();
+    	      this.trigger('done');
+    	    };
+    	  };
+    	  _ElementaryStream.prototype = new stream();
+    	  var m2ts = {
+    	    PAT_PID: 0x0000,
+    	    MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH,
+    	    TransportPacketStream: _TransportPacketStream,
+    	    TransportParseStream: _TransportParseStream,
+    	    ElementaryStream: _ElementaryStream,
+    	    TimestampRolloverStream: TimestampRolloverStream,
+    	    CaptionStream: captionStream.CaptionStream,
+    	    Cea608Stream: captionStream.Cea608Stream,
+    	    Cea708Stream: captionStream.Cea708Stream,
+    	    MetadataStream: metadataStream
+    	  };
+    	  for (var type in streamTypes) {
+    	    if (streamTypes.hasOwnProperty(type)) {
+    	      m2ts[type] = streamTypes[type];
+    	    }
+    	  }
+    	  var m2ts_1 = m2ts;
+
+    	  var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;
+    	  var _AdtsStream;
+    	  var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+
+    	  /*
+    	   * Accepts a ElementaryStream and emits data events with parsed
+    	   * AAC Audio Frames of the individual packets. Input audio in ADTS
+    	   * format is unpacked and re-emitted as AAC frames.
+    	   *
+    	   * @see http://wiki.multimedia.cx/index.php?title=ADTS
+    	   * @see http://wiki.multimedia.cx/?title=Understanding_AAC
+    	   */
+    	  _AdtsStream = function AdtsStream(handlePartialSegments) {
+    	    var buffer,
+    	      frameNum = 0;
+    	    _AdtsStream.prototype.init.call(this);
+    	    this.skipWarn_ = function (start, end) {
+    	      this.trigger('log', {
+    	        level: 'warn',
+    	        message: "adts skiping bytes " + start + " to " + end + " in frame " + frameNum + " outside syncword"
+    	      });
+    	    };
+    	    this.push = function (packet) {
+    	      var i = 0,
+    	        frameLength,
+    	        protectionSkipBytes,
+    	        oldBuffer,
+    	        sampleCount,
+    	        adtsFrameDuration;
+    	      if (!handlePartialSegments) {
+    	        frameNum = 0;
+    	      }
+    	      if (packet.type !== 'audio') {
+    	        // ignore non-audio data
+    	        return;
+    	      }
+
+    	      // Prepend any data in the buffer to the input data so that we can parse
+    	      // aac frames the cross a PES packet boundary
+    	      if (buffer && buffer.length) {
+    	        oldBuffer = buffer;
+    	        buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);
+    	        buffer.set(oldBuffer);
+    	        buffer.set(packet.data, oldBuffer.byteLength);
+    	      } else {
+    	        buffer = packet.data;
+    	      }
+
+    	      // unpack any ADTS frames which have been fully received
+    	      // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS
+    	      var skip;
+
+    	      // We use i + 7 here because we want to be able to parse the entire header.
+    	      // If we don't have enough bytes to do that, then we definitely won't have a full frame.
+    	      while (i + 7 < buffer.length) {
+    	        // Look for the start of an ADTS header..
+    	        if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {
+    	          if (typeof skip !== 'number') {
+    	            skip = i;
+    	          }
+    	          // If a valid header was not found,  jump one forward and attempt to
+    	          // find a valid ADTS header starting at the next byte
+    	          i++;
+    	          continue;
+    	        }
+    	        if (typeof skip === 'number') {
+    	          this.skipWarn_(skip, i);
+    	          skip = null;
+    	        }
+
+    	        // The protection skip bit tells us if we have 2 bytes of CRC data at the
+    	        // end of the ADTS header
+    	        protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2;
+
+    	        // Frame length is a 13 bit integer starting 16 bits from the
+    	        // end of the sync sequence
+    	        // NOTE: frame length includes the size of the header
+    	        frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;
+    	        sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;
+    	        adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$1 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2];
+
+    	        // If we don't have enough data to actually finish this ADTS frame,
+    	        // then we have to wait for more data
+    	        if (buffer.byteLength - i < frameLength) {
+    	          break;
+    	        }
+
+    	        // Otherwise, deliver the complete AAC frame
+    	        this.trigger('data', {
+    	          pts: packet.pts + frameNum * adtsFrameDuration,
+    	          dts: packet.dts + frameNum * adtsFrameDuration,
+    	          sampleCount: sampleCount,
+    	          audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,
+    	          channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,
+    	          samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],
+    	          samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,
+    	          // assume ISO/IEC 14496-12 AudioSampleEntry default of 16
+    	          samplesize: 16,
+    	          // data is the frame without it's header
+    	          data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)
+    	        });
+    	        frameNum++;
+    	        i += frameLength;
+    	      }
+    	      if (typeof skip === 'number') {
+    	        this.skipWarn_(skip, i);
+    	        skip = null;
+    	      }
+
+    	      // remove processed bytes from the buffer.
+    	      buffer = buffer.subarray(i);
+    	    };
+    	    this.flush = function () {
+    	      frameNum = 0;
+    	      this.trigger('done');
+    	    };
+    	    this.reset = function () {
+    	      buffer = void 0;
+    	      this.trigger('reset');
+    	    };
+    	    this.endTimeline = function () {
+    	      buffer = void 0;
+    	      this.trigger('endedtimeline');
+    	    };
+    	  };
+    	  _AdtsStream.prototype = new stream();
+    	  var adts = _AdtsStream;
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   */
+
+    	  var ExpGolomb;
+
+    	  /**
+    	   * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+    	   * scheme used by h264.
+    	   */
+    	  ExpGolomb = function ExpGolomb(workingData) {
+    	    var
+    	      // the number of bytes left to examine in workingData
+    	      workingBytesAvailable = workingData.byteLength,
+    	      // the current word being examined
+    	      workingWord = 0,
+    	      // :uint
+
+    	      // the number of bits left to examine in the current word
+    	      workingBitsAvailable = 0; // :uint;
+
+    	    // ():uint
+    	    this.length = function () {
+    	      return 8 * workingBytesAvailable;
+    	    };
+
+    	    // ():uint
+    	    this.bitsAvailable = function () {
+    	      return 8 * workingBytesAvailable + workingBitsAvailable;
+    	    };
+
+    	    // ():void
+    	    this.loadWord = function () {
+    	      var position = workingData.byteLength - workingBytesAvailable,
+    	        workingBytes = new Uint8Array(4),
+    	        availableBytes = Math.min(4, workingBytesAvailable);
+    	      if (availableBytes === 0) {
+    	        throw new Error('no bytes available');
+    	      }
+    	      workingBytes.set(workingData.subarray(position, position + availableBytes));
+    	      workingWord = new DataView(workingBytes.buffer).getUint32(0);
+
+    	      // track the amount of workingData that has been processed
+    	      workingBitsAvailable = availableBytes * 8;
+    	      workingBytesAvailable -= availableBytes;
+    	    };
+
+    	    // (count:int):void
+    	    this.skipBits = function (count) {
+    	      var skipBytes; // :int
+    	      if (workingBitsAvailable > count) {
+    	        workingWord <<= count;
+    	        workingBitsAvailable -= count;
+    	      } else {
+    	        count -= workingBitsAvailable;
+    	        skipBytes = Math.floor(count / 8);
+    	        count -= skipBytes * 8;
+    	        workingBytesAvailable -= skipBytes;
+    	        this.loadWord();
+    	        workingWord <<= count;
+    	        workingBitsAvailable -= count;
+    	      }
+    	    };
+
+    	    // (size:int):uint
+    	    this.readBits = function (size) {
+    	      var bits = Math.min(workingBitsAvailable, size),
+    	        // :uint
+    	        valu = workingWord >>> 32 - bits; // :uint
+    	      // if size > 31, handle error
+    	      workingBitsAvailable -= bits;
+    	      if (workingBitsAvailable > 0) {
+    	        workingWord <<= bits;
+    	      } else if (workingBytesAvailable > 0) {
+    	        this.loadWord();
+    	      }
+    	      bits = size - bits;
+    	      if (bits > 0) {
+    	        return valu << bits | this.readBits(bits);
+    	      }
+    	      return valu;
+    	    };
+
+    	    // ():uint
+    	    this.skipLeadingZeros = function () {
+    	      var leadingZeroCount; // :uint
+    	      for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {
+    	        if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {
+    	          // the first bit of working word is 1
+    	          workingWord <<= leadingZeroCount;
+    	          workingBitsAvailable -= leadingZeroCount;
+    	          return leadingZeroCount;
+    	        }
+    	      }
+
+    	      // we exhausted workingWord and still have not found a 1
+    	      this.loadWord();
+    	      return leadingZeroCount + this.skipLeadingZeros();
+    	    };
+
+    	    // ():void
+    	    this.skipUnsignedExpGolomb = function () {
+    	      this.skipBits(1 + this.skipLeadingZeros());
+    	    };
+
+    	    // ():void
+    	    this.skipExpGolomb = function () {
+    	      this.skipBits(1 + this.skipLeadingZeros());
+    	    };
+
+    	    // ():uint
+    	    this.readUnsignedExpGolomb = function () {
+    	      var clz = this.skipLeadingZeros(); // :uint
+    	      return this.readBits(clz + 1) - 1;
+    	    };
+
+    	    // ():int
+    	    this.readExpGolomb = function () {
+    	      var valu = this.readUnsignedExpGolomb(); // :int
+    	      if (0x01 & valu) {
+    	        // the number is odd if the low order bit is set
+    	        return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
+    	      }
+
+    	      return -1 * (valu >>> 1); // divide by two then make it negative
+    	    };
+
+    	    // Some convenience functions
+    	    // :Boolean
+    	    this.readBoolean = function () {
+    	      return this.readBits(1) === 1;
+    	    };
+
+    	    // ():int
+    	    this.readUnsignedByte = function () {
+    	      return this.readBits(8);
+    	    };
+    	    this.loadWord();
+    	  };
+    	  var expGolomb = ExpGolomb;
+
+    	  var _H264Stream, _NalByteStream;
+    	  var PROFILES_WITH_OPTIONAL_SPS_DATA;
+
+    	  /**
+    	   * Accepts a NAL unit byte stream and unpacks the embedded NAL units.
+    	   */
+    	  _NalByteStream = function NalByteStream() {
+    	    var syncPoint = 0,
+    	      i,
+    	      buffer;
+    	    _NalByteStream.prototype.init.call(this);
+
+    	    /*
+    	     * Scans a byte stream and triggers a data event with the NAL units found.
+    	     * @param {Object} data Event received from H264Stream
+    	     * @param {Uint8Array} data.data The h264 byte stream to be scanned
+    	     *
+    	     * @see H264Stream.push
+    	     */
+    	    this.push = function (data) {
+    	      var swapBuffer;
+    	      if (!buffer) {
+    	        buffer = data.data;
+    	      } else {
+    	        swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);
+    	        swapBuffer.set(buffer);
+    	        swapBuffer.set(data.data, buffer.byteLength);
+    	        buffer = swapBuffer;
+    	      }
+    	      var len = buffer.byteLength;
+
+    	      // Rec. ITU-T H.264, Annex B
+    	      // scan for NAL unit boundaries
+
+    	      // a match looks like this:
+    	      // 0 0 1 .. NAL .. 0 0 1
+    	      // ^ sync point        ^ i
+    	      // or this:
+    	      // 0 0 1 .. NAL .. 0 0 0
+    	      // ^ sync point        ^ i
+
+    	      // advance the sync point to a NAL start, if necessary
+    	      for (; syncPoint < len - 3; syncPoint++) {
+    	        if (buffer[syncPoint + 2] === 1) {
+    	          // the sync point is properly aligned
+    	          i = syncPoint + 5;
+    	          break;
+    	        }
+    	      }
+    	      while (i < len) {
+    	        // look at the current byte to determine if we've hit the end of
+    	        // a NAL unit boundary
+    	        switch (buffer[i]) {
+    	          case 0:
+    	            // skip past non-sync sequences
+    	            if (buffer[i - 1] !== 0) {
+    	              i += 2;
+    	              break;
+    	            } else if (buffer[i - 2] !== 0) {
+    	              i++;
+    	              break;
+    	            }
+
+    	            // deliver the NAL unit if it isn't empty
+    	            if (syncPoint + 3 !== i - 2) {
+    	              this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+    	            }
+
+    	            // drop trailing zeroes
+    	            do {
+    	              i++;
+    	            } while (buffer[i] !== 1 && i < len);
+    	            syncPoint = i - 2;
+    	            i += 3;
+    	            break;
+    	          case 1:
+    	            // skip past non-sync sequences
+    	            if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {
+    	              i += 3;
+    	              break;
+    	            }
+
+    	            // deliver the NAL unit
+    	            this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+    	            syncPoint = i - 2;
+    	            i += 3;
+    	            break;
+    	          default:
+    	            // the current byte isn't a one or zero, so it cannot be part
+    	            // of a sync sequence
+    	            i += 3;
+    	            break;
+    	        }
+    	      }
+    	      // filter out the NAL units that were delivered
+    	      buffer = buffer.subarray(syncPoint);
+    	      i -= syncPoint;
+    	      syncPoint = 0;
+    	    };
+    	    this.reset = function () {
+    	      buffer = null;
+    	      syncPoint = 0;
+    	      this.trigger('reset');
+    	    };
+    	    this.flush = function () {
+    	      // deliver the last buffered NAL unit
+    	      if (buffer && buffer.byteLength > 3) {
+    	        this.trigger('data', buffer.subarray(syncPoint + 3));
+    	      }
+    	      // reset the stream state
+    	      buffer = null;
+    	      syncPoint = 0;
+    	      this.trigger('done');
+    	    };
+    	    this.endTimeline = function () {
+    	      this.flush();
+    	      this.trigger('endedtimeline');
+    	    };
+    	  };
+    	  _NalByteStream.prototype = new stream();
+
+    	  // values of profile_idc that indicate additional fields are included in the SPS
+    	  // see Recommendation ITU-T H.264 (4/2013),
+    	  // 7.3.2.1.1 Sequence parameter set data syntax
+    	  PROFILES_WITH_OPTIONAL_SPS_DATA = {
+    	    100: true,
+    	    110: true,
+    	    122: true,
+    	    244: true,
+    	    44: true,
+    	    83: true,
+    	    86: true,
+    	    118: true,
+    	    128: true,
+    	    // TODO: the three profiles below don't
+    	    // appear to have sps data in the specificiation anymore?
+    	    138: true,
+    	    139: true,
+    	    134: true
+    	  };
+
+    	  /**
+    	   * Accepts input from a ElementaryStream and produces H.264 NAL unit data
+    	   * events.
+    	   */
+    	  _H264Stream = function H264Stream() {
+    	    var nalByteStream = new _NalByteStream(),
+    	      self,
+    	      trackId,
+    	      currentPts,
+    	      currentDts,
+    	      discardEmulationPreventionBytes,
+    	      readSequenceParameterSet,
+    	      skipScalingList;
+    	    _H264Stream.prototype.init.call(this);
+    	    self = this;
+
+    	    /*
+    	     * Pushes a packet from a stream onto the NalByteStream
+    	     *
+    	     * @param {Object} packet - A packet received from a stream
+    	     * @param {Uint8Array} packet.data - The raw bytes of the packet
+    	     * @param {Number} packet.dts - Decode timestamp of the packet
+    	     * @param {Number} packet.pts - Presentation timestamp of the packet
+    	     * @param {Number} packet.trackId - The id of the h264 track this packet came from
+    	     * @param {('video'|'audio')} packet.type - The type of packet
+    	     *
+    	     */
+    	    this.push = function (packet) {
+    	      if (packet.type !== 'video') {
+    	        return;
+    	      }
+    	      trackId = packet.trackId;
+    	      currentPts = packet.pts;
+    	      currentDts = packet.dts;
+    	      nalByteStream.push(packet);
+    	    };
+
+    	    /*
+    	     * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps
+    	     * for the NALUs to the next stream component.
+    	     * Also, preprocess caption and sequence parameter NALUs.
+    	     *
+    	     * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`
+    	     * @see NalByteStream.push
+    	     */
+    	    nalByteStream.on('data', function (data) {
+    	      var event = {
+    	        trackId: trackId,
+    	        pts: currentPts,
+    	        dts: currentDts,
+    	        data: data,
+    	        nalUnitTypeCode: data[0] & 0x1f
+    	      };
+    	      switch (event.nalUnitTypeCode) {
+    	        case 0x05:
+    	          event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';
+    	          break;
+    	        case 0x06:
+    	          event.nalUnitType = 'sei_rbsp';
+    	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+    	          break;
+    	        case 0x07:
+    	          event.nalUnitType = 'seq_parameter_set_rbsp';
+    	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+    	          event.config = readSequenceParameterSet(event.escapedRBSP);
+    	          break;
+    	        case 0x08:
+    	          event.nalUnitType = 'pic_parameter_set_rbsp';
+    	          break;
+    	        case 0x09:
+    	          event.nalUnitType = 'access_unit_delimiter_rbsp';
+    	          break;
+    	      }
+    	      // This triggers data on the H264Stream
+    	      self.trigger('data', event);
+    	    });
+    	    nalByteStream.on('done', function () {
+    	      self.trigger('done');
+    	    });
+    	    nalByteStream.on('partialdone', function () {
+    	      self.trigger('partialdone');
+    	    });
+    	    nalByteStream.on('reset', function () {
+    	      self.trigger('reset');
+    	    });
+    	    nalByteStream.on('endedtimeline', function () {
+    	      self.trigger('endedtimeline');
+    	    });
+    	    this.flush = function () {
+    	      nalByteStream.flush();
+    	    };
+    	    this.partialFlush = function () {
+    	      nalByteStream.partialFlush();
+    	    };
+    	    this.reset = function () {
+    	      nalByteStream.reset();
+    	    };
+    	    this.endTimeline = function () {
+    	      nalByteStream.endTimeline();
+    	    };
+
+    	    /**
+    	     * Advance the ExpGolomb decoder past a scaling list. The scaling
+    	     * list is optionally transmitted as part of a sequence parameter
+    	     * set and is not relevant to transmuxing.
+    	     * @param count {number} the number of entries in this scaling list
+    	     * @param expGolombDecoder {object} an ExpGolomb pointed to the
+    	     * start of a scaling list
+    	     * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+    	     */
+    	    skipScalingList = function skipScalingList(count, expGolombDecoder) {
+    	      var lastScale = 8,
+    	        nextScale = 8,
+    	        j,
+    	        deltaScale;
+    	      for (j = 0; j < count; j++) {
+    	        if (nextScale !== 0) {
+    	          deltaScale = expGolombDecoder.readExpGolomb();
+    	          nextScale = (lastScale + deltaScale + 256) % 256;
+    	        }
+    	        lastScale = nextScale === 0 ? lastScale : nextScale;
+    	      }
+    	    };
+
+    	    /**
+    	     * Expunge any "Emulation Prevention" bytes from a "Raw Byte
+    	     * Sequence Payload"
+    	     * @param data {Uint8Array} the bytes of a RBSP from a NAL
+    	     * unit
+    	     * @return {Uint8Array} the RBSP without any Emulation
+    	     * Prevention Bytes
+    	     */
+    	    discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+    	      var length = data.byteLength,
+    	        emulationPreventionBytesPositions = [],
+    	        i = 1,
+    	        newLength,
+    	        newData;
+
+    	      // Find all `Emulation Prevention Bytes`
+    	      while (i < length - 2) {
+    	        if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+    	          emulationPreventionBytesPositions.push(i + 2);
+    	          i += 2;
+    	        } else {
+    	          i++;
+    	        }
+    	      }
+
+    	      // If no Emulation Prevention Bytes were found just return the original
+    	      // array
+    	      if (emulationPreventionBytesPositions.length === 0) {
+    	        return data;
+    	      }
+
+    	      // Create a new array to hold the NAL unit data
+    	      newLength = length - emulationPreventionBytesPositions.length;
+    	      newData = new Uint8Array(newLength);
+    	      var sourceIndex = 0;
+    	      for (i = 0; i < newLength; sourceIndex++, i++) {
+    	        if (sourceIndex === emulationPreventionBytesPositions[0]) {
+    	          // Skip this byte
+    	          sourceIndex++;
+    	          // Remove this position index
+    	          emulationPreventionBytesPositions.shift();
+    	        }
+    	        newData[i] = data[sourceIndex];
+    	      }
+    	      return newData;
+    	    };
+
+    	    /**
+    	     * Read a sequence parameter set and return some interesting video
+    	     * properties. A sequence parameter set is the H264 metadata that
+    	     * describes the properties of upcoming video frames.
+    	     * @param data {Uint8Array} the bytes of a sequence parameter set
+    	     * @return {object} an object with configuration parsed from the
+    	     * sequence parameter set, including the dimensions of the
+    	     * associated video frames.
+    	     */
+    	    readSequenceParameterSet = function readSequenceParameterSet(data) {
+    	      var frameCropLeftOffset = 0,
+    	        frameCropRightOffset = 0,
+    	        frameCropTopOffset = 0,
+    	        frameCropBottomOffset = 0,
+    	        expGolombDecoder,
+    	        profileIdc,
+    	        levelIdc,
+    	        profileCompatibility,
+    	        chromaFormatIdc,
+    	        picOrderCntType,
+    	        numRefFramesInPicOrderCntCycle,
+    	        picWidthInMbsMinus1,
+    	        picHeightInMapUnitsMinus1,
+    	        frameMbsOnlyFlag,
+    	        scalingListCount,
+    	        sarRatio = [1, 1],
+    	        aspectRatioIdc,
+    	        i;
+    	      expGolombDecoder = new expGolomb(data);
+    	      profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc
+    	      profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag
+    	      levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)
+    	      expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id
+
+    	      // some profiles have more optional data we don't need
+    	      if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {
+    	        chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
+    	        if (chromaFormatIdc === 3) {
+    	          expGolombDecoder.skipBits(1); // separate_colour_plane_flag
+    	        }
+
+    	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8
+    	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8
+    	        expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
+    	        if (expGolombDecoder.readBoolean()) {
+    	          // seq_scaling_matrix_present_flag
+    	          scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+    	          for (i = 0; i < scalingListCount; i++) {
+    	            if (expGolombDecoder.readBoolean()) {
+    	              // seq_scaling_list_present_flag[ i ]
+    	              if (i < 6) {
+    	                skipScalingList(16, expGolombDecoder);
+    	              } else {
+    	                skipScalingList(64, expGolombDecoder);
+    	              }
+    	            }
+    	          }
+    	        }
+    	      }
+    	      expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4
+    	      picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
+    	      if (picOrderCntType === 0) {
+    	        expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4
+    	      } else if (picOrderCntType === 1) {
+    	        expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag
+    	        expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic
+    	        expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field
+    	        numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();
+    	        for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+    	          expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]
+    	        }
+    	      }
+
+    	      expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames
+    	      expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
+
+    	      picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+    	      picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+    	      frameMbsOnlyFlag = expGolombDecoder.readBits(1);
+    	      if (frameMbsOnlyFlag === 0) {
+    	        expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag
+    	      }
+
+    	      expGolombDecoder.skipBits(1); // direct_8x8_inference_flag
+    	      if (expGolombDecoder.readBoolean()) {
+    	        // frame_cropping_flag
+    	        frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	        frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	        frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	        frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
+    	      }
+    	      if (expGolombDecoder.readBoolean()) {
+    	        // vui_parameters_present_flag
+    	        if (expGolombDecoder.readBoolean()) {
+    	          // aspect_ratio_info_present_flag
+    	          aspectRatioIdc = expGolombDecoder.readUnsignedByte();
+    	          switch (aspectRatioIdc) {
+    	            case 1:
+    	              sarRatio = [1, 1];
+    	              break;
+    	            case 2:
+    	              sarRatio = [12, 11];
+    	              break;
+    	            case 3:
+    	              sarRatio = [10, 11];
+    	              break;
+    	            case 4:
+    	              sarRatio = [16, 11];
+    	              break;
+    	            case 5:
+    	              sarRatio = [40, 33];
+    	              break;
+    	            case 6:
+    	              sarRatio = [24, 11];
+    	              break;
+    	            case 7:
+    	              sarRatio = [20, 11];
+    	              break;
+    	            case 8:
+    	              sarRatio = [32, 11];
+    	              break;
+    	            case 9:
+    	              sarRatio = [80, 33];
+    	              break;
+    	            case 10:
+    	              sarRatio = [18, 11];
+    	              break;
+    	            case 11:
+    	              sarRatio = [15, 11];
+    	              break;
+    	            case 12:
+    	              sarRatio = [64, 33];
+    	              break;
+    	            case 13:
+    	              sarRatio = [160, 99];
+    	              break;
+    	            case 14:
+    	              sarRatio = [4, 3];
+    	              break;
+    	            case 15:
+    	              sarRatio = [3, 2];
+    	              break;
+    	            case 16:
+    	              sarRatio = [2, 1];
+    	              break;
+    	            case 255:
+    	              {
+    	                sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];
+    	                break;
+    	              }
+    	          }
+    	          if (sarRatio) {
+    	            sarRatio[0] / sarRatio[1];
+    	          }
+    	        }
+    	      }
+    	      return {
+    	        profileIdc: profileIdc,
+    	        levelIdc: levelIdc,
+    	        profileCompatibility: profileCompatibility,
+    	        width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,
+    	        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,
+    	        // sar is sample aspect ratio
+    	        sarRatio: sarRatio
+    	      };
+    	    };
+    	  };
+    	  _H264Stream.prototype = new stream();
+    	  var h264 = {
+    	    H264Stream: _H264Stream,
+    	    NalByteStream: _NalByteStream
+    	  };
+
+    	  /**
+    	   * mux.js
+    	   *
+    	   * Copyright (c) Brightcove
+    	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+    	   *
+    	   * Utilities to detect basic properties and metadata about Aac data.
+    	   */
+
+    	  var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+    	  var parseId3TagSize = function parseId3TagSize(header, byteIndex) {
+    	    var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],
+    	      flags = header[byteIndex + 5],
+    	      footerPresent = (flags & 16) >> 4;
+
+    	    // if we get a negative returnSize clamp it to 0
+    	    returnSize = returnSize >= 0 ? returnSize : 0;
+    	    if (footerPresent) {
+    	      return returnSize + 20;
+    	    }
+    	    return returnSize + 10;
+    	  };
+    	  var getId3Offset = function getId3Offset(data, offset) {
+    	    if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {
+    	      return offset;
+    	    }
+    	    offset += parseId3TagSize(data, offset);
+    	    return getId3Offset(data, offset);
+    	  };
+
+    	  // TODO: use vhs-utils
+    	  var isLikelyAacData$1 = function isLikelyAacData(data) {
+    	    var offset = getId3Offset(data, 0);
+    	    return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 &&
+    	    // verify that the 2 layer bits are 0, aka this
+    	    // is not mp3 data but aac data.
+    	    (data[offset + 1] & 0x16) === 0x10;
+    	  };
+    	  var parseSyncSafeInteger = function parseSyncSafeInteger(data) {
+    	    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+    	  };
+
+    	  // return a percent-encoded representation of the specified byte range
+    	  // @see http://en.wikipedia.org/wiki/Percent-encoding
+    	  var percentEncode = function percentEncode(bytes, start, end) {
+    	    var i,
+    	      result = '';
+    	    for (i = start; i < end; i++) {
+    	      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+    	    }
+    	    return result;
+    	  };
+
+    	  // return the string representation of the specified byte range,
+    	  // interpreted as ISO-8859-1.
+    	  var parseIso88591 = function parseIso88591(bytes, start, end) {
+    	    return unescape(percentEncode(bytes, start, end)); // jshint ignore:line
+    	  };
+
+    	  var parseAdtsSize = function parseAdtsSize(header, byteIndex) {
+    	    var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,
+    	      middle = header[byteIndex + 4] << 3,
+    	      highTwo = header[byteIndex + 3] & 0x3 << 11;
+    	    return highTwo | middle | lowThree;
+    	  };
+    	  var parseType = function parseType(header, byteIndex) {
+    	    if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {
+    	      return 'timed-metadata';
+    	    } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {
+    	      return 'audio';
+    	    }
+    	    return null;
+    	  };
+    	  var parseSampleRate = function parseSampleRate(packet) {
+    	    var i = 0;
+    	    while (i + 5 < packet.length) {
+    	      if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {
+    	        // If a valid header was not found,  jump one forward and attempt to
+    	        // find a valid ADTS header starting at the next byte
+    	        i++;
+    	        continue;
+    	      }
+    	      return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];
+    	    }
+    	    return null;
+    	  };
+    	  var parseAacTimestamp = function parseAacTimestamp(packet) {
+    	    var frameStart, frameSize, frame, frameHeader;
+
+    	    // find the start of the first frame and the end of the tag
+    	    frameStart = 10;
+    	    if (packet[5] & 0x40) {
+    	      // advance the frame start past the extended header
+    	      frameStart += 4; // header size field
+    	      frameStart += parseSyncSafeInteger(packet.subarray(10, 14));
+    	    }
+
+    	    // parse one or more ID3 frames
+    	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    	    do {
+    	      // determine the number of bytes in this frame
+    	      frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));
+    	      if (frameSize < 1) {
+    	        return null;
+    	      }
+    	      frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);
+    	      if (frameHeader === 'PRIV') {
+    	        frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);
+    	        for (var i = 0; i < frame.byteLength; i++) {
+    	          if (frame[i] === 0) {
+    	            var owner = parseIso88591(frame, 0, i);
+    	            if (owner === 'com.apple.streaming.transportStreamTimestamp') {
+    	              var d = frame.subarray(i + 1);
+    	              var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+    	              size *= 4;
+    	              size += d[7] & 0x03;
+    	              return size;
+    	            }
+    	            break;
+    	          }
+    	        }
+    	      }
+    	      frameStart += 10; // advance past the frame header
+    	      frameStart += frameSize; // advance past the frame body
+    	    } while (frameStart < packet.byteLength);
+    	    return null;
+    	  };
+    	  var utils = {
+    	    isLikelyAacData: isLikelyAacData$1,
+    	    parseId3TagSize: parseId3TagSize,
+    	    parseAdtsSize: parseAdtsSize,
+    	    parseType: parseType,
+    	    parseSampleRate: parseSampleRate,
+    	    parseAacTimestamp: parseAacTimestamp
+    	  };
+
+    	  // Constants
+    	  var _AacStream;
+
+    	  /**
+    	   * Splits an incoming stream of binary data into ADTS and ID3 Frames.
+    	   */
+
+    	  _AacStream = function AacStream() {
+    	    var everything = new Uint8Array(),
+    	      timeStamp = 0;
+    	    _AacStream.prototype.init.call(this);
+    	    this.setTimestamp = function (timestamp) {
+    	      timeStamp = timestamp;
+    	    };
+    	    this.push = function (bytes) {
+    	      var frameSize = 0,
+    	        byteIndex = 0,
+    	        bytesLeft,
+    	        chunk,
+    	        packet,
+    	        tempLength;
+
+    	      // If there are bytes remaining from the last segment, prepend them to the
+    	      // bytes that were pushed in
+    	      if (everything.length) {
+    	        tempLength = everything.length;
+    	        everything = new Uint8Array(bytes.byteLength + tempLength);
+    	        everything.set(everything.subarray(0, tempLength));
+    	        everything.set(bytes, tempLength);
+    	      } else {
+    	        everything = bytes;
+    	      }
+    	      while (everything.length - byteIndex >= 3) {
+    	        if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {
+    	          // Exit early because we don't have enough to parse
+    	          // the ID3 tag header
+    	          if (everything.length - byteIndex < 10) {
+    	            break;
+    	          }
+
+    	          // check framesize
+    	          frameSize = utils.parseId3TagSize(everything, byteIndex);
+
+    	          // Exit early if we don't have enough in the buffer
+    	          // to emit a full packet
+    	          // Add to byteIndex to support multiple ID3 tags in sequence
+    	          if (byteIndex + frameSize > everything.length) {
+    	            break;
+    	          }
+    	          chunk = {
+    	            type: 'timed-metadata',
+    	            data: everything.subarray(byteIndex, byteIndex + frameSize)
+    	          };
+    	          this.trigger('data', chunk);
+    	          byteIndex += frameSize;
+    	          continue;
+    	        } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {
+    	          // Exit early because we don't have enough to parse
+    	          // the ADTS frame header
+    	          if (everything.length - byteIndex < 7) {
+    	            break;
+    	          }
+    	          frameSize = utils.parseAdtsSize(everything, byteIndex);
+
+    	          // Exit early if we don't have enough in the buffer
+    	          // to emit a full packet
+    	          if (byteIndex + frameSize > everything.length) {
+    	            break;
+    	          }
+    	          packet = {
+    	            type: 'audio',
+    	            data: everything.subarray(byteIndex, byteIndex + frameSize),
+    	            pts: timeStamp,
+    	            dts: timeStamp
+    	          };
+    	          this.trigger('data', packet);
+    	          byteIndex += frameSize;
+    	          continue;
+    	        }
+    	        byteIndex++;
+    	      }
+    	      bytesLeft = everything.length - byteIndex;
+    	      if (bytesLeft > 0) {
+    	        everything = everything.subarray(byteIndex);
+    	      } else {
+    	        everything = new Uint8Array();
+    	      }
+    	    };
+    	    this.reset = function () {
+    	      everything = new Uint8Array();
+    	      this.trigger('reset');
+    	    };
+    	    this.endTimeline = function () {
+    	      everything = new Uint8Array();
+    	      this.trigger('endedtimeline');
+    	    };
+    	  };
+    	  _AacStream.prototype = new stream();
+    	  var aac = _AacStream;
+
+    	  // constants
+    	  var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];
+    	  var audioProperties = AUDIO_PROPERTIES;
+
+    	  var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];
+    	  var videoProperties = VIDEO_PROPERTIES;
+
+    	  var H264Stream = h264.H264Stream;
+    	  var isLikelyAacData = utils.isLikelyAacData;
+    	  var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;
+
+    	  // object types
+    	  var _VideoSegmentStream, _AudioSegmentStream, _Transmuxer, _CoalesceStream;
+    	  var retriggerForStream = function retriggerForStream(key, event) {
+    	    event.stream = key;
+    	    this.trigger('log', event);
+    	  };
+    	  var addPipelineLogRetriggers = function addPipelineLogRetriggers(transmuxer, pipeline) {
+    	    var keys = Object.keys(pipeline);
+    	    for (var i = 0; i < keys.length; i++) {
+    	      var key = keys[i];
+
+    	      // skip non-stream keys and headOfPipeline
+    	      // which is just a duplicate
+    	      if (key === 'headOfPipeline' || !pipeline[key].on) {
+    	        continue;
+    	      }
+    	      pipeline[key].on('log', retriggerForStream.bind(transmuxer, key));
+    	    }
+    	  };
+
+    	  /**
+    	   * Compare two arrays (even typed) for same-ness
+    	   */
+    	  var arrayEquals = function arrayEquals(a, b) {
+    	    var i;
+    	    if (a.length !== b.length) {
+    	      return false;
+    	    }
+
+    	    // compare the value of each element in the array
+    	    for (i = 0; i < a.length; i++) {
+    	      if (a[i] !== b[i]) {
+    	        return false;
+    	      }
+    	    }
+    	    return true;
+    	  };
+    	  var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {
+    	    var ptsOffsetFromDts = startPts - startDts,
+    	      decodeDuration = endDts - startDts,
+    	      presentationDuration = endPts - startPts;
+
+    	    // The PTS and DTS values are based on the actual stream times from the segment,
+    	    // however, the player time values will reflect a start from the baseMediaDecodeTime.
+    	    // In order to provide relevant values for the player times, base timing info on the
+    	    // baseMediaDecodeTime and the DTS and PTS durations of the segment.
+    	    return {
+    	      start: {
+    	        dts: baseMediaDecodeTime,
+    	        pts: baseMediaDecodeTime + ptsOffsetFromDts
+    	      },
+    	      end: {
+    	        dts: baseMediaDecodeTime + decodeDuration,
+    	        pts: baseMediaDecodeTime + presentationDuration
+    	      },
+    	      prependedContentDuration: prependedContentDuration,
+    	      baseMediaDecodeTime: baseMediaDecodeTime
+    	    };
+    	  };
+
+    	  /**
+    	   * Constructs a single-track, ISO BMFF media segment from AAC data
+    	   * events. The output of this stream can be fed to a SourceBuffer
+    	   * configured with a suitable initialization segment.
+    	   * @param track {object} track metadata configuration
+    	   * @param options {object} transmuxer options object
+    	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at 0.
+    	   */
+    	  _AudioSegmentStream = function AudioSegmentStream(track, options) {
+    	    var adtsFrames = [],
+    	      sequenceNumber,
+    	      earliestAllowedDts = 0,
+    	      audioAppendStartTs = 0,
+    	      videoBaseMediaDecodeTime = Infinity;
+    	    options = options || {};
+    	    sequenceNumber = options.firstSequenceNumber || 0;
+    	    _AudioSegmentStream.prototype.init.call(this);
+    	    this.push = function (data) {
+    	      trackDecodeInfo.collectDtsInfo(track, data);
+    	      if (track) {
+    	        audioProperties.forEach(function (prop) {
+    	          track[prop] = data[prop];
+    	        });
+    	      }
+
+    	      // buffer audio data until end() is called
+    	      adtsFrames.push(data);
+    	    };
+    	    this.setEarliestDts = function (earliestDts) {
+    	      earliestAllowedDts = earliestDts;
+    	    };
+    	    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+    	      videoBaseMediaDecodeTime = baseMediaDecodeTime;
+    	    };
+    	    this.setAudioAppendStart = function (timestamp) {
+    	      audioAppendStartTs = timestamp;
+    	    };
+    	    this.flush = function () {
+    	      var frames, moof, mdat, boxes, frameDuration, segmentDuration, videoClockCyclesOfSilencePrefixed;
+
+    	      // return early if no audio data has been observed
+    	      if (adtsFrames.length === 0) {
+    	        this.trigger('done', 'AudioSegmentStream');
+    	        return;
+    	      }
+    	      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);
+    	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+
+    	      // amount of audio filled but the value is in video clock rather than audio clock
+    	      videoClockCyclesOfSilencePrefixed = audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime);
+
+    	      // we have to build the index from byte locations to
+    	      // samples (that is, adts frames) in the audio data
+    	      track.samples = audioFrameUtils.generateSampleTable(frames);
+
+    	      // concatenate the audio data to constuct the mdat
+    	      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));
+    	      adtsFrames = [];
+    	      moof = mp4Generator.moof(sequenceNumber, [track]);
+    	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+    	      // bump the sequence number for next time
+    	      sequenceNumber++;
+    	      boxes.set(moof);
+    	      boxes.set(mdat, moof.byteLength);
+    	      trackDecodeInfo.clearDtsInfo(track);
+    	      frameDuration = Math.ceil(ONE_SECOND_IN_TS * 1024 / track.samplerate);
+
+    	      // TODO this check was added to maintain backwards compatibility (particularly with
+    	      // tests) on adding the timingInfo event. However, it seems unlikely that there's a
+    	      // valid use-case where an init segment/data should be triggered without associated
+    	      // frames. Leaving for now, but should be looked into.
+    	      if (frames.length) {
+    	        segmentDuration = frames.length * frameDuration;
+    	        this.trigger('segmentTimingInfo', generateSegmentTimingInfo(
+    	        // The audio track's baseMediaDecodeTime is in audio clock cycles, but the
+    	        // frame info is in video clock cycles. Convert to match expectation of
+    	        // listeners (that all timestamps will be based on video clock cycles).
+    	        clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate),
+    	        // frame times are already in video clock, as is segment duration
+    	        frames[0].dts, frames[0].pts, frames[0].dts + segmentDuration, frames[0].pts + segmentDuration, videoClockCyclesOfSilencePrefixed || 0));
+    	        this.trigger('timingInfo', {
+    	          start: frames[0].pts,
+    	          end: frames[0].pts + segmentDuration
+    	        });
+    	      }
+    	      this.trigger('data', {
+    	        track: track,
+    	        boxes: boxes
+    	      });
+    	      this.trigger('done', 'AudioSegmentStream');
+    	    };
+    	    this.reset = function () {
+    	      trackDecodeInfo.clearDtsInfo(track);
+    	      adtsFrames = [];
+    	      this.trigger('reset');
+    	    };
+    	  };
+    	  _AudioSegmentStream.prototype = new stream();
+
+    	  /**
+    	   * Constructs a single-track, ISO BMFF media segment from H264 data
+    	   * events. The output of this stream can be fed to a SourceBuffer
+    	   * configured with a suitable initialization segment.
+    	   * @param track {object} track metadata configuration
+    	   * @param options {object} transmuxer options object
+    	   * @param options.alignGopsAtEnd {boolean} If true, start from the end of the
+    	   *        gopsToAlignWith list when attempting to align gop pts
+    	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at 0.
+    	   */
+    	  _VideoSegmentStream = function VideoSegmentStream(track, options) {
+    	    var sequenceNumber,
+    	      nalUnits = [],
+    	      gopsToAlignWith = [],
+    	      config,
+    	      pps;
+    	    options = options || {};
+    	    sequenceNumber = options.firstSequenceNumber || 0;
+    	    _VideoSegmentStream.prototype.init.call(this);
+    	    delete track.minPTS;
+    	    this.gopCache_ = [];
+
+    	    /**
+    	      * Constructs a ISO BMFF segment given H264 nalUnits
+    	      * @param {Object} nalUnit A data event representing a nalUnit
+    	      * @param {String} nalUnit.nalUnitType
+    	      * @param {Object} nalUnit.config Properties for a mp4 track
+    	      * @param {Uint8Array} nalUnit.data The nalUnit bytes
+    	      * @see lib/codecs/h264.js
+    	     **/
+    	    this.push = function (nalUnit) {
+    	      trackDecodeInfo.collectDtsInfo(track, nalUnit);
+
+    	      // record the track config
+    	      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {
+    	        config = nalUnit.config;
+    	        track.sps = [nalUnit.data];
+    	        videoProperties.forEach(function (prop) {
+    	          track[prop] = config[prop];
+    	        }, this);
+    	      }
+    	      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {
+    	        pps = nalUnit.data;
+    	        track.pps = [nalUnit.data];
+    	      }
+
+    	      // buffer video until flush() is called
+    	      nalUnits.push(nalUnit);
+    	    };
+
+    	    /**
+    	      * Pass constructed ISO BMFF track and boxes on to the
+    	      * next stream in the pipeline
+    	     **/
+    	    this.flush = function () {
+    	      var frames,
+    	        gopForFusion,
+    	        gops,
+    	        moof,
+    	        mdat,
+    	        boxes,
+    	        prependedContentDuration = 0,
+    	        firstGop,
+    	        lastGop;
+
+    	      // Throw away nalUnits at the start of the byte stream until
+    	      // we find the first AUD
+    	      while (nalUnits.length) {
+    	        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
+    	          break;
+    	        }
+    	        nalUnits.shift();
+    	      }
+
+    	      // Return early if no video data has been observed
+    	      if (nalUnits.length === 0) {
+    	        this.resetStream_();
+    	        this.trigger('done', 'VideoSegmentStream');
+    	        return;
+    	      }
+
+    	      // Organize the raw nal-units into arrays that represent
+    	      // higher-level constructs such as frames and gops
+    	      // (group-of-pictures)
+    	      frames = frameUtils.groupNalsIntoFrames(nalUnits);
+    	      gops = frameUtils.groupFramesIntoGops(frames);
+
+    	      // If the first frame of this fragment is not a keyframe we have
+    	      // a problem since MSE (on Chrome) requires a leading keyframe.
+    	      //
+    	      // We have two approaches to repairing this situation:
+    	      // 1) GOP-FUSION:
+    	      //    This is where we keep track of the GOPS (group-of-pictures)
+    	      //    from previous fragments and attempt to find one that we can
+    	      //    prepend to the current fragment in order to create a valid
+    	      //    fragment.
+    	      // 2) KEYFRAME-PULLING:
+    	      //    Here we search for the first keyframe in the fragment and
+    	      //    throw away all the frames between the start of the fragment
+    	      //    and that keyframe. We then extend the duration and pull the
+    	      //    PTS of the keyframe forward so that it covers the time range
+    	      //    of the frames that were disposed of.
+    	      //
+    	      // #1 is far prefereable over #2 which can cause "stuttering" but
+    	      // requires more things to be just right.
+    	      if (!gops[0][0].keyFrame) {
+    	        // Search for a gop for fusion from our gopCache
+    	        gopForFusion = this.getGopForFusion_(nalUnits[0], track);
+    	        if (gopForFusion) {
+    	          // in order to provide more accurate timing information about the segment, save
+    	          // the number of seconds prepended to the original segment due to GOP fusion
+    	          prependedContentDuration = gopForFusion.duration;
+    	          gops.unshift(gopForFusion);
+    	          // Adjust Gops' metadata to account for the inclusion of the
+    	          // new gop at the beginning
+    	          gops.byteLength += gopForFusion.byteLength;
+    	          gops.nalCount += gopForFusion.nalCount;
+    	          gops.pts = gopForFusion.pts;
+    	          gops.dts = gopForFusion.dts;
+    	          gops.duration += gopForFusion.duration;
+    	        } else {
+    	          // If we didn't find a candidate gop fall back to keyframe-pulling
+    	          gops = frameUtils.extendFirstKeyFrame(gops);
+    	        }
+    	      }
+
+    	      // Trim gops to align with gopsToAlignWith
+    	      if (gopsToAlignWith.length) {
+    	        var alignedGops;
+    	        if (options.alignGopsAtEnd) {
+    	          alignedGops = this.alignGopsAtEnd_(gops);
+    	        } else {
+    	          alignedGops = this.alignGopsAtStart_(gops);
+    	        }
+    	        if (!alignedGops) {
+    	          // save all the nals in the last GOP into the gop cache
+    	          this.gopCache_.unshift({
+    	            gop: gops.pop(),
+    	            pps: track.pps,
+    	            sps: track.sps
+    	          });
+
+    	          // Keep a maximum of 6 GOPs in the cache
+    	          this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+    	          // Clear nalUnits
+    	          nalUnits = [];
+
+    	          // return early no gops can be aligned with desired gopsToAlignWith
+    	          this.resetStream_();
+    	          this.trigger('done', 'VideoSegmentStream');
+    	          return;
+    	        }
+
+    	        // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct
+    	        // when recalculated before sending off to CoalesceStream
+    	        trackDecodeInfo.clearDtsInfo(track);
+    	        gops = alignedGops;
+    	      }
+    	      trackDecodeInfo.collectDtsInfo(track, gops);
+
+    	      // First, we have to build the index from byte locations to
+    	      // samples (that is, frames) in the video data
+    	      track.samples = frameUtils.generateSampleTable(gops);
+
+    	      // Concatenate the video data and construct the mdat
+    	      mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));
+    	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+    	      this.trigger('processedGopsInfo', gops.map(function (gop) {
+    	        return {
+    	          pts: gop.pts,
+    	          dts: gop.dts,
+    	          byteLength: gop.byteLength
+    	        };
+    	      }));
+    	      firstGop = gops[0];
+    	      lastGop = gops[gops.length - 1];
+    	      this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));
+    	      this.trigger('timingInfo', {
+    	        start: gops[0].pts,
+    	        end: gops[gops.length - 1].pts + gops[gops.length - 1].duration
+    	      });
+
+    	      // save all the nals in the last GOP into the gop cache
+    	      this.gopCache_.unshift({
+    	        gop: gops.pop(),
+    	        pps: track.pps,
+    	        sps: track.sps
+    	      });
+
+    	      // Keep a maximum of 6 GOPs in the cache
+    	      this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+    	      // Clear nalUnits
+    	      nalUnits = [];
+    	      this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);
+    	      this.trigger('timelineStartInfo', track.timelineStartInfo);
+    	      moof = mp4Generator.moof(sequenceNumber, [track]);
+
+    	      // it would be great to allocate this array up front instead of
+    	      // throwing away hundreds of media segment fragments
+    	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+    	      // Bump the sequence number for next time
+    	      sequenceNumber++;
+    	      boxes.set(moof);
+    	      boxes.set(mdat, moof.byteLength);
+    	      this.trigger('data', {
+    	        track: track,
+    	        boxes: boxes
+    	      });
+    	      this.resetStream_();
+
+    	      // Continue with the flush process now
+    	      this.trigger('done', 'VideoSegmentStream');
+    	    };
+    	    this.reset = function () {
+    	      this.resetStream_();
+    	      nalUnits = [];
+    	      this.gopCache_.length = 0;
+    	      gopsToAlignWith.length = 0;
+    	      this.trigger('reset');
+    	    };
+    	    this.resetStream_ = function () {
+    	      trackDecodeInfo.clearDtsInfo(track);
+
+    	      // reset config and pps because they may differ across segments
+    	      // for instance, when we are rendition switching
+    	      config = undefined;
+    	      pps = undefined;
+    	    };
+
+    	    // Search for a candidate Gop for gop-fusion from the gop cache and
+    	    // return it or return null if no good candidate was found
+    	    this.getGopForFusion_ = function (nalUnit) {
+    	      var halfSecond = 45000,
+    	        // Half-a-second in a 90khz clock
+    	        allowableOverlap = 10000,
+    	        // About 3 frames @ 30fps
+    	        nearestDistance = Infinity,
+    	        dtsDistance,
+    	        nearestGopObj,
+    	        currentGop,
+    	        currentGopObj,
+    	        i;
+
+    	      // Search for the GOP nearest to the beginning of this nal unit
+    	      for (i = 0; i < this.gopCache_.length; i++) {
+    	        currentGopObj = this.gopCache_[i];
+    	        currentGop = currentGopObj.gop;
+
+    	        // Reject Gops with different SPS or PPS
+    	        if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {
+    	          continue;
+    	        }
+
+    	        // Reject Gops that would require a negative baseMediaDecodeTime
+    	        if (currentGop.dts < track.timelineStartInfo.dts) {
+    	          continue;
+    	        }
+
+    	        // The distance between the end of the gop and the start of the nalUnit
+    	        dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration;
+
+    	        // Only consider GOPS that start before the nal unit and end within
+    	        // a half-second of the nal unit
+    	        if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {
+    	          // Always use the closest GOP we found if there is more than
+    	          // one candidate
+    	          if (!nearestGopObj || nearestDistance > dtsDistance) {
+    	            nearestGopObj = currentGopObj;
+    	            nearestDistance = dtsDistance;
+    	          }
+    	        }
+    	      }
+    	      if (nearestGopObj) {
+    	        return nearestGopObj.gop;
+    	      }
+    	      return null;
+    	    };
+
+    	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+    	    // of gopsToAlignWith starting from the START of the list
+    	    this.alignGopsAtStart_ = function (gops) {
+    	      var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;
+    	      byteLength = gops.byteLength;
+    	      nalCount = gops.nalCount;
+    	      duration = gops.duration;
+    	      alignIndex = gopIndex = 0;
+    	      while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {
+    	        align = gopsToAlignWith[alignIndex];
+    	        gop = gops[gopIndex];
+    	        if (align.pts === gop.pts) {
+    	          break;
+    	        }
+    	        if (gop.pts > align.pts) {
+    	          // this current gop starts after the current gop we want to align on, so increment
+    	          // align index
+    	          alignIndex++;
+    	          continue;
+    	        }
+
+    	        // current gop starts before the current gop we want to align on. so increment gop
+    	        // index
+    	        gopIndex++;
+    	        byteLength -= gop.byteLength;
+    	        nalCount -= gop.nalCount;
+    	        duration -= gop.duration;
+    	      }
+    	      if (gopIndex === 0) {
+    	        // no gops to trim
+    	        return gops;
+    	      }
+    	      if (gopIndex === gops.length) {
+    	        // all gops trimmed, skip appending all gops
+    	        return null;
+    	      }
+    	      alignedGops = gops.slice(gopIndex);
+    	      alignedGops.byteLength = byteLength;
+    	      alignedGops.duration = duration;
+    	      alignedGops.nalCount = nalCount;
+    	      alignedGops.pts = alignedGops[0].pts;
+    	      alignedGops.dts = alignedGops[0].dts;
+    	      return alignedGops;
+    	    };
+
+    	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+    	    // of gopsToAlignWith starting from the END of the list
+    	    this.alignGopsAtEnd_ = function (gops) {
+    	      var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;
+    	      alignIndex = gopsToAlignWith.length - 1;
+    	      gopIndex = gops.length - 1;
+    	      alignEndIndex = null;
+    	      matchFound = false;
+    	      while (alignIndex >= 0 && gopIndex >= 0) {
+    	        align = gopsToAlignWith[alignIndex];
+    	        gop = gops[gopIndex];
+    	        if (align.pts === gop.pts) {
+    	          matchFound = true;
+    	          break;
+    	        }
+    	        if (align.pts > gop.pts) {
+    	          alignIndex--;
+    	          continue;
+    	        }
+    	        if (alignIndex === gopsToAlignWith.length - 1) {
+    	          // gop.pts is greater than the last alignment candidate. If no match is found
+    	          // by the end of this loop, we still want to append gops that come after this
+    	          // point
+    	          alignEndIndex = gopIndex;
+    	        }
+    	        gopIndex--;
+    	      }
+    	      if (!matchFound && alignEndIndex === null) {
+    	        return null;
+    	      }
+    	      var trimIndex;
+    	      if (matchFound) {
+    	        trimIndex = gopIndex;
+    	      } else {
+    	        trimIndex = alignEndIndex;
+    	      }
+    	      if (trimIndex === 0) {
+    	        return gops;
+    	      }
+    	      var alignedGops = gops.slice(trimIndex);
+    	      var metadata = alignedGops.reduce(function (total, gop) {
+    	        total.byteLength += gop.byteLength;
+    	        total.duration += gop.duration;
+    	        total.nalCount += gop.nalCount;
+    	        return total;
+    	      }, {
+    	        byteLength: 0,
+    	        duration: 0,
+    	        nalCount: 0
+    	      });
+    	      alignedGops.byteLength = metadata.byteLength;
+    	      alignedGops.duration = metadata.duration;
+    	      alignedGops.nalCount = metadata.nalCount;
+    	      alignedGops.pts = alignedGops[0].pts;
+    	      alignedGops.dts = alignedGops[0].dts;
+    	      return alignedGops;
+    	    };
+    	    this.alignGopsWith = function (newGopsToAlignWith) {
+    	      gopsToAlignWith = newGopsToAlignWith;
+    	    };
+    	  };
+    	  _VideoSegmentStream.prototype = new stream();
+
+    	  /**
+    	   * A Stream that can combine multiple streams (ie. audio & video)
+    	   * into a single output segment for MSE. Also supports audio-only
+    	   * and video-only streams.
+    	   * @param options {object} transmuxer options object
+    	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+    	   *        in the source; false to adjust the first segment to start at media timeline start.
+    	   */
+    	  _CoalesceStream = function CoalesceStream(options, metadataStream) {
+    	    // Number of Tracks per output segment
+    	    // If greater than 1, we combine multiple
+    	    // tracks into a single segment
+    	    this.numberOfTracks = 0;
+    	    this.metadataStream = metadataStream;
+    	    options = options || {};
+    	    if (typeof options.remux !== 'undefined') {
+    	      this.remuxTracks = !!options.remux;
+    	    } else {
+    	      this.remuxTracks = true;
+    	    }
+    	    if (typeof options.keepOriginalTimestamps === 'boolean') {
+    	      this.keepOriginalTimestamps = options.keepOriginalTimestamps;
+    	    } else {
+    	      this.keepOriginalTimestamps = false;
+    	    }
+    	    this.pendingTracks = [];
+    	    this.videoTrack = null;
+    	    this.pendingBoxes = [];
+    	    this.pendingCaptions = [];
+    	    this.pendingMetadata = [];
+    	    this.pendingBytes = 0;
+    	    this.emittedTracks = 0;
+    	    _CoalesceStream.prototype.init.call(this);
+
+    	    // Take output from multiple
+    	    this.push = function (output) {
+    	      // buffer incoming captions until the associated video segment
+    	      // finishes
+    	      if (output.text) {
+    	        return this.pendingCaptions.push(output);
+    	      }
+    	      // buffer incoming id3 tags until the final flush
+    	      if (output.frames) {
+    	        return this.pendingMetadata.push(output);
+    	      }
+
+    	      // Add this track to the list of pending tracks and store
+    	      // important information required for the construction of
+    	      // the final segment
+    	      this.pendingTracks.push(output.track);
+    	      this.pendingBytes += output.boxes.byteLength;
+
+    	      // TODO: is there an issue for this against chrome?
+    	      // We unshift audio and push video because
+    	      // as of Chrome 75 when switching from
+    	      // one init segment to another if the video
+    	      // mdat does not appear after the audio mdat
+    	      // only audio will play for the duration of our transmux.
+    	      if (output.track.type === 'video') {
+    	        this.videoTrack = output.track;
+    	        this.pendingBoxes.push(output.boxes);
+    	      }
+    	      if (output.track.type === 'audio') {
+    	        this.audioTrack = output.track;
+    	        this.pendingBoxes.unshift(output.boxes);
+    	      }
+    	    };
+    	  };
+    	  _CoalesceStream.prototype = new stream();
+    	  _CoalesceStream.prototype.flush = function (flushSource) {
+    	    var offset = 0,
+    	      event = {
+    	        captions: [],
+    	        captionStreams: {},
+    	        metadata: [],
+    	        info: {}
+    	      },
+    	      caption,
+    	      id3,
+    	      initSegment,
+    	      timelineStartPts = 0,
+    	      i;
+    	    if (this.pendingTracks.length < this.numberOfTracks) {
+    	      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {
+    	        // Return because we haven't received a flush from a data-generating
+    	        // portion of the segment (meaning that we have only recieved meta-data
+    	        // or captions.)
+    	        return;
+    	      } else if (this.remuxTracks) {
+    	        // Return until we have enough tracks from the pipeline to remux (if we
+    	        // are remuxing audio and video into a single MP4)
+    	        return;
+    	      } else if (this.pendingTracks.length === 0) {
+    	        // In the case where we receive a flush without any data having been
+    	        // received we consider it an emitted track for the purposes of coalescing
+    	        // `done` events.
+    	        // We do this for the case where there is an audio and video track in the
+    	        // segment but no audio data. (seen in several playlists with alternate
+    	        // audio tracks and no audio present in the main TS segments.)
+    	        this.emittedTracks++;
+    	        if (this.emittedTracks >= this.numberOfTracks) {
+    	          this.trigger('done');
+    	          this.emittedTracks = 0;
+    	        }
+    	        return;
+    	      }
+    	    }
+    	    if (this.videoTrack) {
+    	      timelineStartPts = this.videoTrack.timelineStartInfo.pts;
+    	      videoProperties.forEach(function (prop) {
+    	        event.info[prop] = this.videoTrack[prop];
+    	      }, this);
+    	    } else if (this.audioTrack) {
+    	      timelineStartPts = this.audioTrack.timelineStartInfo.pts;
+    	      audioProperties.forEach(function (prop) {
+    	        event.info[prop] = this.audioTrack[prop];
+    	      }, this);
+    	    }
+    	    if (this.videoTrack || this.audioTrack) {
+    	      if (this.pendingTracks.length === 1) {
+    	        event.type = this.pendingTracks[0].type;
+    	      } else {
+    	        event.type = 'combined';
+    	      }
+    	      this.emittedTracks += this.pendingTracks.length;
+    	      initSegment = mp4Generator.initSegment(this.pendingTracks);
+
+    	      // Create a new typed array to hold the init segment
+    	      event.initSegment = new Uint8Array(initSegment.byteLength);
+
+    	      // Create an init segment containing a moov
+    	      // and track definitions
+    	      event.initSegment.set(initSegment);
+
+    	      // Create a new typed array to hold the moof+mdats
+    	      event.data = new Uint8Array(this.pendingBytes);
+
+    	      // Append each moof+mdat (one per track) together
+    	      for (i = 0; i < this.pendingBoxes.length; i++) {
+    	        event.data.set(this.pendingBoxes[i], offset);
+    	        offset += this.pendingBoxes[i].byteLength;
+    	      }
+
+    	      // Translate caption PTS times into second offsets to match the
+    	      // video timeline for the segment, and add track info
+    	      for (i = 0; i < this.pendingCaptions.length; i++) {
+    	        caption = this.pendingCaptions[i];
+    	        caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);
+    	        caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);
+    	        event.captionStreams[caption.stream] = true;
+    	        event.captions.push(caption);
+    	      }
+
+    	      // Translate ID3 frame PTS times into second offsets to match the
+    	      // video timeline for the segment
+    	      for (i = 0; i < this.pendingMetadata.length; i++) {
+    	        id3 = this.pendingMetadata[i];
+    	        id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);
+    	        event.metadata.push(id3);
+    	      }
+
+    	      // We add this to every single emitted segment even though we only need
+    	      // it for the first
+    	      event.metadata.dispatchType = this.metadataStream.dispatchType;
+
+    	      // Reset stream state
+    	      this.pendingTracks.length = 0;
+    	      this.videoTrack = null;
+    	      this.pendingBoxes.length = 0;
+    	      this.pendingCaptions.length = 0;
+    	      this.pendingBytes = 0;
+    	      this.pendingMetadata.length = 0;
+
+    	      // Emit the built segment
+    	      // We include captions and ID3 tags for backwards compatibility,
+    	      // ideally we should send only video and audio in the data event
+    	      this.trigger('data', event);
+    	      // Emit each caption to the outside world
+    	      // Ideally, this would happen immediately on parsing captions,
+    	      // but we need to ensure that video data is sent back first
+    	      // so that caption timing can be adjusted to match video timing
+    	      for (i = 0; i < event.captions.length; i++) {
+    	        caption = event.captions[i];
+    	        this.trigger('caption', caption);
+    	      }
+    	      // Emit each id3 tag to the outside world
+    	      // Ideally, this would happen immediately on parsing the tag,
+    	      // but we need to ensure that video data is sent back first
+    	      // so that ID3 frame timing can be adjusted to match video timing
+    	      for (i = 0; i < event.metadata.length; i++) {
+    	        id3 = event.metadata[i];
+    	        this.trigger('id3Frame', id3);
+    	      }
+    	    }
+
+    	    // Only emit `done` if all tracks have been flushed and emitted
+    	    if (this.emittedTracks >= this.numberOfTracks) {
+    	      this.trigger('done');
+    	      this.emittedTracks = 0;
+    	    }
+    	  };
+    	  _CoalesceStream.prototype.setRemux = function (val) {
+    	    this.remuxTracks = val;
+    	  };
+    	  /**
+    	   * A Stream that expects MP2T binary data as input and produces
+    	   * corresponding media segments, suitable for use with Media Source
+    	   * Extension (MSE) implementations that support the ISO BMFF byte
+    	   * stream format, like Chrome.
+    	   */
+    	  _Transmuxer = function Transmuxer(options) {
+    	    var self = this,
+    	      hasFlushed = true,
+    	      videoTrack,
+    	      audioTrack;
+    	    _Transmuxer.prototype.init.call(this);
+    	    options = options || {};
+    	    var duration = this.duration = options.duration || 0xffffffff;
+    	    this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;
+    	    this.transmuxPipeline_ = {};
+    	    this.setupAacPipeline = function () {
+    	      var pipeline = {};
+    	      this.transmuxPipeline_ = pipeline;
+    	      pipeline.type = 'aac';
+    	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+    	      // set up the parsing pipeline
+    	      pipeline.aacStream = new aac();
+    	      pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');
+    	      pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');
+    	      pipeline.adtsStream = new adts();
+    	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+    	      pipeline.headOfPipeline = pipeline.aacStream;
+    	      pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);
+    	      pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+    	      pipeline.metadataStream.on('timestamp', function (frame) {
+    	        pipeline.aacStream.setTimestamp(frame.timeStamp);
+    	      });
+    	      pipeline.aacStream.on('data', function (data) {
+    	        if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {
+    	          return;
+    	        }
+    	        audioTrack = audioTrack || {
+    	          timelineStartInfo: {
+    	            baseMediaDecodeTime: self.baseMediaDecodeTime
+    	          },
+    	          codec: 'adts',
+    	          type: 'audio'
+    	        };
+    	        // hook up the audio segment stream to the first track with aac data
+    	        pipeline.coalesceStream.numberOfTracks++;
+    	        pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+    	        pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+    	        pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+
+    	        // Set up the final part of the audio pipeline
+    	        pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+
+    	        // emit pmt info
+    	        self.trigger('trackinfo', {
+    	          hasAudio: !!audioTrack,
+    	          hasVideo: !!videoTrack
+    	        });
+    	      });
+
+    	      // Re-emit any data coming from the coalesce stream to the outside world
+    	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+    	      // Let the consumer know we have finished flushing the entire pipeline
+    	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+    	      addPipelineLogRetriggers(this, pipeline);
+    	    };
+    	    this.setupTsPipeline = function () {
+    	      var pipeline = {};
+    	      this.transmuxPipeline_ = pipeline;
+    	      pipeline.type = 'ts';
+    	      pipeline.duration = duration * 9e4;
+    	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+    	      // set up the parsing pipeline
+    	      pipeline.packetStream = new m2ts_1.TransportPacketStream();
+    	      pipeline.parseStream = new m2ts_1.TransportParseStream();
+    	      pipeline.elementaryStream = new m2ts_1.ElementaryStream();
+    	      pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();
+    	      pipeline.adtsStream = new adts();
+    	      pipeline.h264Stream = new H264Stream();
+    	      pipeline.captionStream = new m2ts_1.CaptionStream(options);
+    	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+    	      pipeline.headOfPipeline = pipeline.packetStream;
+
+    	      // disassemble MPEG2-TS packets into elementary streams
+    	      pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream);
+
+    	      // !!THIS ORDER IS IMPORTANT!!
+    	      // demux the streams
+    	      pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);
+    	      pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);
+    	      pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+
+    	      // Hook up CEA-608/708 caption stream
+    	      pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);
+    	      pipeline.elementaryStream.on('data', function (data) {
+    	        var i;
+    	        if (data.type === 'metadata') {
+    	          i = data.tracks.length;
+
+    	          // scan the tracks listed in the metadata
+    	          while (i--) {
+    	            if (!videoTrack && data.tracks[i].type === 'video') {
+    	              videoTrack = data.tracks[i];
+    	              videoTrack.duration = pipeline.duration / 2;
+    	              videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+    	            } else if (!audioTrack && data.tracks[i].type === 'audio') {
+    	              audioTrack = data.tracks[i];
+    	              audioTrack.duration = pipeline.duration / 2;
+    	              audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+    	            }
+    	          }
+
+    	          // hook up the video segment stream to the first track with h264 data
+    	          if (videoTrack && !pipeline.videoSegmentStream) {
+    	            pipeline.coalesceStream.numberOfTracks++;
+    	            pipeline.videoSegmentStream = new _VideoSegmentStream(videoTrack, options);
+    	            pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));
+    	            pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {
+    	              // When video emits timelineStartInfo data after a flush, we forward that
+    	              // info to the AudioSegmentStream, if it exists, because video timeline
+    	              // data takes precedence.  Do not do this if keepOriginalTimestamps is set,
+    	              // because this is a particularly subtle form of timestamp alteration.
+    	              if (audioTrack && !options.keepOriginalTimestamps) {
+    	                audioTrack.timelineStartInfo = timelineStartInfo;
+    	                // On the first segment we trim AAC frames that exist before the
+    	                // very earliest DTS we have seen in video because Chrome will
+    	                // interpret any video track with a baseMediaDecodeTime that is
+    	                // non-zero as a gap.
+    	                pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);
+    	              }
+    	            });
+    	            pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));
+    	            pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));
+    	            pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {
+    	              if (audioTrack) {
+    	                pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);
+    	              }
+    	            });
+    	            pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo'));
+
+    	            // Set up the final part of the video pipeline
+    	            pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);
+    	          }
+    	          if (audioTrack && !pipeline.audioSegmentStream) {
+    	            // hook up the audio segment stream to the first track with aac data
+    	            pipeline.coalesceStream.numberOfTracks++;
+    	            pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+    	            pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+    	            pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+    	            pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo'));
+
+    	            // Set up the final part of the audio pipeline
+    	            pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+    	          }
+
+    	          // emit pmt info
+    	          self.trigger('trackinfo', {
+    	            hasAudio: !!audioTrack,
+    	            hasVideo: !!videoTrack
+    	          });
+    	        }
+    	      });
+
+    	      // Re-emit any data coming from the coalesce stream to the outside world
+    	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+    	      pipeline.coalesceStream.on('id3Frame', function (id3Frame) {
+    	        id3Frame.dispatchType = pipeline.metadataStream.dispatchType;
+    	        self.trigger('id3Frame', id3Frame);
+    	      });
+    	      pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption'));
+    	      // Let the consumer know we have finished flushing the entire pipeline
+    	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+    	      addPipelineLogRetriggers(this, pipeline);
+    	    };
+
+    	    // hook up the segment streams once track metadata is delivered
+    	    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+    	      var pipeline = this.transmuxPipeline_;
+    	      if (!options.keepOriginalTimestamps) {
+    	        this.baseMediaDecodeTime = baseMediaDecodeTime;
+    	      }
+    	      if (audioTrack) {
+    	        audioTrack.timelineStartInfo.dts = undefined;
+    	        audioTrack.timelineStartInfo.pts = undefined;
+    	        trackDecodeInfo.clearDtsInfo(audioTrack);
+    	        if (pipeline.audioTimestampRolloverStream) {
+    	          pipeline.audioTimestampRolloverStream.discontinuity();
+    	        }
+    	      }
+    	      if (videoTrack) {
+    	        if (pipeline.videoSegmentStream) {
+    	          pipeline.videoSegmentStream.gopCache_ = [];
+    	        }
+    	        videoTrack.timelineStartInfo.dts = undefined;
+    	        videoTrack.timelineStartInfo.pts = undefined;
+    	        trackDecodeInfo.clearDtsInfo(videoTrack);
+    	        pipeline.captionStream.reset();
+    	      }
+    	      if (pipeline.timestampRolloverStream) {
+    	        pipeline.timestampRolloverStream.discontinuity();
+    	      }
+    	    };
+    	    this.setAudioAppendStart = function (timestamp) {
+    	      if (audioTrack) {
+    	        this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);
+    	      }
+    	    };
+    	    this.setRemux = function (val) {
+    	      var pipeline = this.transmuxPipeline_;
+    	      options.remux = val;
+    	      if (pipeline && pipeline.coalesceStream) {
+    	        pipeline.coalesceStream.setRemux(val);
+    	      }
+    	    };
+    	    this.alignGopsWith = function (gopsToAlignWith) {
+    	      if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {
+    	        this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);
+    	      }
+    	    };
+    	    this.getLogTrigger_ = function (key) {
+    	      var self = this;
+    	      return function (event) {
+    	        event.stream = key;
+    	        self.trigger('log', event);
+    	      };
+    	    };
+    	    // feed incoming data to the front of the parsing pipeline
+    	    this.push = function (data) {
+    	      if (hasFlushed) {
+    	        var isAac = isLikelyAacData(data);
+    	        if (isAac && this.transmuxPipeline_.type !== 'aac') {
+    	          this.setupAacPipeline();
+    	        } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {
+    	          this.setupTsPipeline();
+    	        }
+    	        hasFlushed = false;
+    	      }
+    	      this.transmuxPipeline_.headOfPipeline.push(data);
+    	    };
+
+    	    // flush any buffered data
+    	    this.flush = function () {
+    	      hasFlushed = true;
+    	      // Start at the top of the pipeline and flush all pending work
+    	      this.transmuxPipeline_.headOfPipeline.flush();
+    	    };
+    	    this.endTimeline = function () {
+    	      this.transmuxPipeline_.headOfPipeline.endTimeline();
+    	    };
+    	    this.reset = function () {
+    	      if (this.transmuxPipeline_.headOfPipeline) {
+    	        this.transmuxPipeline_.headOfPipeline.reset();
+    	      }
+    	    };
+
+    	    // Caption data has to be reset when seeking outside buffered range
+    	    this.resetCaptions = function () {
+    	      if (this.transmuxPipeline_.captionStream) {
+    	        this.transmuxPipeline_.captionStream.reset();
+    	      }
+    	    };
+    	  };
+    	  _Transmuxer.prototype = new stream();
+    	  var transmuxer = _Transmuxer;
+
+    	  return transmuxer;
+
+    	})); 
+    } (mp4Transmuxer));
+
+    var mp4TransmuxerExports = mp4Transmuxer.exports;
+    var Transmuxer = /*@__PURE__*/getDefaultExportFromCjs(mp4TransmuxerExports);
+
     var aesJs = {exports: {}};
 
     /*! MIT License. Copyright 2015-2018 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */
@@ -886,7 +7328,23 @@
     var aesJsExports = aesJs.exports;
     var aesjs = /*@__PURE__*/getDefaultExportFromCjs(aesJsExports);
 
-    var createFFmpeg = FFmpeg.createFFmpeg, fetchFile = FFmpeg.fetchFile;
+    function fetchFile(url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, arrayBuffer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch(url)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.arrayBuffer()];
+                    case 2:
+                        arrayBuffer = _a.sent();
+                        return [2 /*return*/, new Uint8Array(arrayBuffer)];
+                }
+            });
+        });
+    }
+
     var TaskType;
     (function (TaskType) {
         TaskType[TaskType["loadFFmeg"] = 0] = "loadFFmeg";
@@ -905,11 +7363,11 @@
     }
     var Hls2Mp4 = /** @class */ (function () {
         function Hls2Mp4(_a, onProgress) {
-            var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c, options = __rest(_a, ["maxRetry", "tsDownloadConcurrency"]);
+            var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c;
             this.loadRetryTime = 0;
             this.totalSegments = 0;
-            this.savedSegments = 0;
-            this.instance = createFFmpeg(options);
+            this.duration = 0;
+            this.savedSegments = new Map();
             this.maxRetry = maxRetry;
             this.onProgress = onProgress;
             this.tsDownloadConcurrency = tsDownloadConcurrency;
@@ -1015,7 +7473,7 @@
                 var _this = this;
                 return __generator(this, function (_a) {
                     return [2 /*return*/, Promise.all(segs.map(function (_a) {
-                            var name = _a.name, url = _a.url, source = _a.source;
+                            var index = _a.index, url = _a.url;
                             return __awaiter(_this, void 0, void 0, function () {
                                 var tsData, buffer;
                                 var _b;
@@ -1025,14 +7483,9 @@
                                         case 1:
                                             tsData = _c.sent();
                                             buffer = key ? this.aesDecrypt(tsData, key, iv) : this.transformBuffer(tsData);
-                                            this.instance.FS('writeFile', name, buffer);
-                                            this.savedSegments += 1;
-                                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments / this.totalSegments);
-                                            return [2 /*return*/, {
-                                                    source: source,
-                                                    url: url,
-                                                    name: name
-                                                }];
+                                            this.savedSegments.set(index, buffer);
+                                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments.size / this.totalSegments);
+                                            return [2 /*return*/];
                                     }
                                 });
                             });
@@ -1040,9 +7493,20 @@
                 });
             });
         };
+        Hls2Mp4.prototype.computeTotalDuration = function (content) {
+            var duration = 0;
+            var tags = content.match(/#EXTINF:\d+(.\d+)?/gi);
+            tags === null || tags === void 0 ? void 0 : tags.forEach(function (tag) {
+                var dur = tag.match(/\d+(.\d+)?/);
+                if (dur) {
+                    duration += Number(dur[0]);
+                }
+            });
+            return duration;
+        };
         Hls2Mp4.prototype.downloadM3u8 = function (url) {
             return __awaiter(this, void 0, void 0, function () {
-                var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1, m3u8;
+                var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1;
                 var e_1, _b;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
@@ -1057,31 +7521,29 @@
                             if (!matches) {
                                 throw new Error('Invalid m3u8 file, no ts file found');
                             }
+                            this.duration = this.computeTotalDuration(content);
                             segments = [];
-                            if (matches) {
-                                for (i = 0; i < matches.length; i++) {
-                                    matched = matches[i];
-                                    if (matched.match(/#EXT-X-KEY/)) {
-                                        matchedKey = matched.match(keyMatchRegExp);
-                                        matchedIV = matched.match(/(?<=IV=)\w+$/);
-                                        segments.push({
-                                            key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
-                                            iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
-                                            segments: []
-                                        });
-                                    }
-                                    else if (i === 0) {
-                                        segments.push({
-                                            segments: [matched]
-                                        });
-                                    }
-                                    else {
-                                        segments[segments.length - 1].segments.push(matched);
-                                    }
+                            for (i = 0; i < matches.length; i++) {
+                                matched = matches[i];
+                                if (matched.match(/#EXT-X-KEY/)) {
+                                    matchedKey = matched.match(keyMatchRegExp);
+                                    matchedIV = matched.match(/(?<=IV=)\w+$/);
+                                    segments.push({
+                                        key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
+                                        iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
+                                        segments: []
+                                    });
+                                }
+                                else if (i === 0) {
+                                    segments.push({
+                                        segments: [matched]
+                                    });
+                                }
+                                else {
+                                    segments[segments.length - 1].segments.push(matched);
                                 }
                             }
                             this.totalSegments = segments.reduce(function (prev, current) { return prev + current.segments.length; }, 0);
-                            this.savedSegments = 0;
                             batch = this.tsDownloadConcurrency;
                             treatedSegments = 0;
                             _c.label = 2;
@@ -1102,34 +7564,17 @@
                             _c.label = 5;
                         case 5:
                             _loop_1 = function (i) {
-                                var downloadSegs, downloadSegs_1, downloadSegs_1_1, _d, source, name_1;
-                                var e_2, _e;
-                                return __generator(this, function (_f) {
-                                    switch (_f.label) {
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
                                         case 0: return [4 /*yield*/, this_1.downloadSegments(group.segments.slice(i * batch, Math.min(total, (i + 1) * batch)).map(function (seg, j) {
                                                 var url = parseUrl(parsedUrl, seg);
-                                                var name = "seg-".concat(treatedSegments + i * batch + j, ".ts");
                                                 return {
-                                                    source: seg,
-                                                    url: url,
-                                                    name: name
+                                                    index: treatedSegments + i * batch + j,
+                                                    url: url
                                                 };
                                             }), keyBuffer, group.iv)];
                                         case 1:
-                                            downloadSegs = _f.sent();
-                                            try {
-                                                for (downloadSegs_1 = (e_2 = void 0, __values(downloadSegs)), downloadSegs_1_1 = downloadSegs_1.next(); !downloadSegs_1_1.done; downloadSegs_1_1 = downloadSegs_1.next()) {
-                                                    _d = downloadSegs_1_1.value, source = _d.source, name_1 = _d.name;
-                                                    content = content.replace(source, name_1);
-                                                }
-                                            }
-                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                                            finally {
-                                                try {
-                                                    if (downloadSegs_1_1 && !downloadSegs_1_1.done && (_e = downloadSegs_1.return)) _e.call(downloadSegs_1);
-                                                }
-                                                finally { if (e_2) throw e_2.error; }
-                                            }
+                                            _d.sent();
                                             return [2 /*return*/];
                                     }
                                 });
@@ -1163,11 +7608,7 @@
                             }
                             finally { if (e_1) throw e_1.error; }
                             return [7 /*endfinally*/];
-                        case 14:
-                            content = content.replace(keyTagMatchRegExp, '');
-                            m3u8 = 'temp.m3u8';
-                            this.instance.FS('writeFile', m3u8, content);
-                            return [2 /*return*/, m3u8];
+                        case 14: return [2 /*return*/];
                     }
                 });
             });
@@ -1202,49 +7643,100 @@
                 });
             });
         };
-        Hls2Mp4.prototype.loadFFmpeg = function () {
+        Hls2Mp4.prototype.mergeDataArray = function (data) {
+            var e_2, _a;
+            var totalByteLength = data.reduce(function (prev, current) { return prev + current.byteLength; }, 0);
+            var dataArray = new Uint8Array(totalByteLength);
+            var byteOffset = 0;
+            try {
+                for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                    var part = data_1_1.value;
+                    dataArray.set(part, byteOffset);
+                    byteOffset += part.byteLength;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return dataArray;
+        };
+        Hls2Mp4.prototype.transmuxerSegments = function () {
             var _a, _b;
             return __awaiter(this, void 0, void 0, function () {
-                var done;
-                var _this = this;
+                var transmuxer, transmuxerFirstSegment, transmuxerSegment, chunks, i, segment, chunk, data;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
-                            (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.loadFFmeg, 0);
-                            return [4 /*yield*/, this.loopLoadFile(function () { return _this.instance.load(); })];
+                            (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
+                            transmuxer = new Transmuxer({
+                                duration: this.duration
+                            });
+                            transmuxerFirstSegment = function (data) {
+                                return new Promise(function (resolve) {
+                                    transmuxer.on('data', function (segment) {
+                                        var data = new Uint8Array(segment.initSegment.byteLength + segment.data.byteLength);
+                                        data.set(segment.initSegment, 0);
+                                        data.set(segment.data, segment.initSegment.byteLength);
+                                        resolve(data);
+                                    });
+                                    transmuxer.push(data);
+                                    transmuxer.flush();
+                                });
+                            };
+                            transmuxerSegment = function (buffer) {
+                                return new Promise(function (resolve) {
+                                    transmuxer.off('data');
+                                    transmuxer.on('data', function (segment) { return resolve(segment.data); });
+                                    transmuxer.push(buffer);
+                                    transmuxer.flush();
+                                });
+                            };
+                            chunks = [];
+                            i = 0;
+                            _c.label = 1;
                         case 1:
-                            done = (_c.sent()).done;
-                            if (done) {
-                                (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.loadFFmeg, done ? 1 : -1);
-                            }
-                            else {
-                                throw new Error('FFmpeg load failed');
-                            }
-                            return [2 /*return*/];
+                            if (!(i < this.savedSegments.size)) return [3 /*break*/, 7];
+                            segment = this.savedSegments.get(i);
+                            chunk = void 0;
+                            if (!(i === 0)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, transmuxerFirstSegment(segment)];
+                        case 2:
+                            chunk = _c.sent();
+                            return [3 /*break*/, 5];
+                        case 3: return [4 /*yield*/, transmuxerSegment(segment)];
+                        case 4:
+                            chunk = _c.sent();
+                            _c.label = 5;
+                        case 5:
+                            chunks.push(chunk);
+                            _c.label = 6;
+                        case 6:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 7:
+                            data = this.mergeDataArray(chunks);
+                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
+                            return [2 /*return*/, data];
                     }
                 });
             });
         };
         Hls2Mp4.prototype.download = function (url) {
-            var _a, _b;
             return __awaiter(this, void 0, void 0, function () {
-                var m3u8, data;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0: return [4 /*yield*/, this.loadFFmpeg()];
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.downloadM3u8(url)];
                         case 1:
-                            _c.sent();
-                            return [4 /*yield*/, this.downloadM3u8(url)];
+                            _a.sent();
+                            return [4 /*yield*/, this.transmuxerSegments()];
                         case 2:
-                            m3u8 = _c.sent();
-                            (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
-                            return [4 /*yield*/, this.instance.run('-i', m3u8, '-c', 'copy', 'temp.mp4', '-loglevel', 'debug')];
-                        case 3:
-                            _c.sent();
-                            data = this.instance.FS('readFile', 'temp.mp4');
-                            this.instance.exit();
-                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
-                            return [2 /*return*/, data.buffer];
+                            data = _a.sent();
+                            return [2 /*return*/, data];
                     }
                 });
             });
@@ -1257,7 +7749,7 @@
             anchor.click();
             setTimeout(function () { return URL.revokeObjectURL(objectUrl); }, 100);
         };
-        Hls2Mp4.version = '1.1.8';
+        Hls2Mp4.version = '2.0';
         Hls2Mp4.TaskType = TaskType;
         return Hls2Mp4;
     }());
diff --git a/dist/index.d.ts b/dist/index.d.ts
index 8054633..4c1e015 100644
--- a/dist/index.d.ts
+++ b/dist/index.d.ts
@@ -1,4 +1,3 @@
-import { type CreateFFmpegOptions } from '@ffmpeg/ffmpeg';
 declare enum TaskType {
     loadFFmeg = 0,
     parseM3u8 = 1,
@@ -23,16 +22,16 @@ export interface M3u8Parsed {
     content: string;
 }
 declare class Hls2Mp4 {
-    private instance;
     private maxRetry;
     private loadRetryTime;
     private onProgress?;
     private tsDownloadConcurrency;
     private totalSegments;
+    private duration;
     private savedSegments;
     static version: string;
     static TaskType: typeof TaskType;
-    constructor({ maxRetry, tsDownloadConcurrency, ...options }: CreateFFmpegOptions & Hls2Mp4Options, onProgress?: ProgressCallback);
+    constructor({ maxRetry, tsDownloadConcurrency }: Hls2Mp4Options, onProgress?: ProgressCallback);
     private transformBuffer;
     private hexToUint8Array;
     private aesDecrypt;
@@ -40,10 +39,12 @@ declare class Hls2Mp4 {
     private parseM3u8;
     private downloadFile;
     private downloadSegments;
+    private computeTotalDuration;
     private downloadM3u8;
     private loopLoadFile;
-    private loadFFmpeg;
-    download(url: string): Promise<ArrayBufferLike>;
+    private mergeDataArray;
+    private transmuxerSegments;
+    download(url: string): Promise<Uint8Array>;
     saveToFile(buffer: ArrayBufferLike, filename: string): void;
 }
 export default Hls2Mp4;
diff --git a/dist/index.js b/dist/index.js
index 3c77b58..f422ed3 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -1,5 +1,3 @@
-import FFmpeg from '@ffmpeg/ffmpeg';
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -17,18 +15,6 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise */
 
 
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -79,10 +65,6464 @@ function __values(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
+var mp4Transmuxer = {exports: {}};
+
+/*! @name mux.js @version 6.3.0 @license Apache-2.0 */
+
+(function (module, exports) {
+	(function (global, factory) {
+	  module.exports = factory() ;
+	})(commonjsGlobal, (function () {
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   *
+	   * A lightweight readable stream implemention that handles event dispatching.
+	   * Objects that inherit from streams should call init in their constructors.
+	   */
+
+	  var Stream = function Stream() {
+	    this.init = function () {
+	      var listeners = {};
+	      /**
+	       * Add a listener for a specified event type.
+	       * @param type {string} the event name
+	       * @param listener {function} the callback to be invoked when an event of
+	       * the specified type occurs
+	       */
+	      this.on = function (type, listener) {
+	        if (!listeners[type]) {
+	          listeners[type] = [];
+	        }
+	        listeners[type] = listeners[type].concat(listener);
+	      };
+	      /**
+	       * Remove a listener for a specified event type.
+	       * @param type {string} the event name
+	       * @param listener {function} a function previously registered for this
+	       * type of event through `on`
+	       */
+	      this.off = function (type, listener) {
+	        var index;
+	        if (!listeners[type]) {
+	          return false;
+	        }
+	        index = listeners[type].indexOf(listener);
+	        listeners[type] = listeners[type].slice();
+	        listeners[type].splice(index, 1);
+	        return index > -1;
+	      };
+	      /**
+	       * Trigger an event of the specified type on this stream. Any additional
+	       * arguments to this function are passed as parameters to event listeners.
+	       * @param type {string} the event name
+	       */
+	      this.trigger = function (type) {
+	        var callbacks, i, length, args;
+	        callbacks = listeners[type];
+	        if (!callbacks) {
+	          return;
+	        }
+	        // Slicing the arguments on every invocation of this method
+	        // can add a significant amount of overhead. Avoid the
+	        // intermediate object creation for the common case of a
+	        // single callback argument
+	        if (arguments.length === 2) {
+	          length = callbacks.length;
+	          for (i = 0; i < length; ++i) {
+	            callbacks[i].call(this, arguments[1]);
+	          }
+	        } else {
+	          args = [];
+	          i = arguments.length;
+	          for (i = 1; i < arguments.length; ++i) {
+	            args.push(arguments[i]);
+	          }
+	          length = callbacks.length;
+	          for (i = 0; i < length; ++i) {
+	            callbacks[i].apply(this, args);
+	          }
+	        }
+	      };
+	      /**
+	       * Destroys the stream and cleans up.
+	       */
+	      this.dispose = function () {
+	        listeners = {};
+	      };
+	    };
+	  };
+
+	  /**
+	   * Forwards all `data` events on this stream to the destination stream. The
+	   * destination stream should provide a method `push` to receive the data
+	   * events as they arrive.
+	   * @param destination {stream} the stream that will receive all `data` events
+	   * @param autoFlush {boolean} if false, we will not call `flush` on the destination
+	   *                            when the current stream emits a 'done' event
+	   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
+	   */
+	  Stream.prototype.pipe = function (destination) {
+	    this.on('data', function (data) {
+	      destination.push(data);
+	    });
+	    this.on('done', function (flushSource) {
+	      destination.flush(flushSource);
+	    });
+	    this.on('partialdone', function (flushSource) {
+	      destination.partialFlush(flushSource);
+	    });
+	    this.on('endedtimeline', function (flushSource) {
+	      destination.endTimeline(flushSource);
+	    });
+	    this.on('reset', function (flushSource) {
+	      destination.reset(flushSource);
+	    });
+	    return destination;
+	  };
+
+	  // Default stream functions that are expected to be overridden to perform
+	  // actual work. These are provided by the prototype as a sort of no-op
+	  // implementation so that we don't have to check for their existence in the
+	  // `pipe` function above.
+	  Stream.prototype.push = function (data) {
+	    this.trigger('data', data);
+	  };
+	  Stream.prototype.flush = function (flushSource) {
+	    this.trigger('done', flushSource);
+	  };
+	  Stream.prototype.partialFlush = function (flushSource) {
+	    this.trigger('partialdone', flushSource);
+	  };
+	  Stream.prototype.endTimeline = function (flushSource) {
+	    this.trigger('endedtimeline', flushSource);
+	  };
+	  Stream.prototype.reset = function (flushSource) {
+	    this.trigger('reset', flushSource);
+	  };
+	  var stream = Stream;
+
+	  var MAX_UINT32$1 = Math.pow(2, 32);
+	  var getUint64 = function getUint64(uint8) {
+	    var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+	    var value;
+	    if (dv.getBigUint64) {
+	      value = dv.getBigUint64(0);
+	      if (value < Number.MAX_SAFE_INTEGER) {
+	        return Number(value);
+	      }
+	      return value;
+	    }
+	    return dv.getUint32(0) * MAX_UINT32$1 + dv.getUint32(4);
+	  };
+	  var numbers = {
+	    getUint64: getUint64,
+	    MAX_UINT32: MAX_UINT32$1
+	  };
+
+	  var MAX_UINT32 = numbers.MAX_UINT32;
+	  var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS;
+
+	  // pre-calculate constants
+	  (function () {
+	    var i;
+	    types = {
+	      avc1: [],
+	      // codingname
+	      avcC: [],
+	      btrt: [],
+	      dinf: [],
+	      dref: [],
+	      esds: [],
+	      ftyp: [],
+	      hdlr: [],
+	      mdat: [],
+	      mdhd: [],
+	      mdia: [],
+	      mfhd: [],
+	      minf: [],
+	      moof: [],
+	      moov: [],
+	      mp4a: [],
+	      // codingname
+	      mvex: [],
+	      mvhd: [],
+	      pasp: [],
+	      sdtp: [],
+	      smhd: [],
+	      stbl: [],
+	      stco: [],
+	      stsc: [],
+	      stsd: [],
+	      stsz: [],
+	      stts: [],
+	      styp: [],
+	      tfdt: [],
+	      tfhd: [],
+	      traf: [],
+	      trak: [],
+	      trun: [],
+	      trex: [],
+	      tkhd: [],
+	      vmhd: []
+	    };
+
+	    // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we
+	    // don't throw an error
+	    if (typeof Uint8Array === 'undefined') {
+	      return;
+	    }
+	    for (i in types) {
+	      if (types.hasOwnProperty(i)) {
+	        types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
+	      }
+	    }
+	    MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);
+	    AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);
+	    MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);
+	    VIDEO_HDLR = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // pre_defined
+	    0x76, 0x69, 0x64, 0x65,
+	    // handler_type: 'vide'
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
+	    ]);
+
+	    AUDIO_HDLR = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // pre_defined
+	    0x73, 0x6f, 0x75, 0x6e,
+	    // handler_type: 'soun'
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
+	    ]);
+
+	    HDLR_TYPES = {
+	      video: VIDEO_HDLR,
+	      audio: AUDIO_HDLR
+	    };
+	    DREF = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x01,
+	    // entry_count
+	    0x00, 0x00, 0x00, 0x0c,
+	    // entry_size
+	    0x75, 0x72, 0x6c, 0x20,
+	    // 'url' type
+	    0x00,
+	    // version 0
+	    0x00, 0x00, 0x01 // entry_flags
+	    ]);
+
+	    SMHD = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00,
+	    // balance, 0 means centered
+	    0x00, 0x00 // reserved
+	    ]);
+
+	    STCO = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00 // entry_count
+	    ]);
+
+	    STSC = STCO;
+	    STSZ = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // sample_size
+	    0x00, 0x00, 0x00, 0x00 // sample_count
+	    ]);
+
+	    STTS = STCO;
+	    VMHD = new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x01,
+	    // flags
+	    0x00, 0x00,
+	    // graphicsmode
+	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
+	    ]);
+	  })();
+
+	  box = function box(type) {
+	    var payload = [],
+	      size = 0,
+	      i,
+	      result,
+	      view;
+	    for (i = 1; i < arguments.length; i++) {
+	      payload.push(arguments[i]);
+	    }
+	    i = payload.length;
+
+	    // calculate the total size we need to allocate
+	    while (i--) {
+	      size += payload[i].byteLength;
+	    }
+	    result = new Uint8Array(size + 8);
+	    view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+	    view.setUint32(0, result.byteLength);
+	    result.set(type, 4);
+
+	    // copy the payload into the result
+	    for (i = 0, size = 8; i < payload.length; i++) {
+	      result.set(payload[i], size);
+	      size += payload[i].byteLength;
+	    }
+	    return result;
+	  };
+	  dinf = function dinf() {
+	    return box(types.dinf, box(types.dref, DREF));
+	  };
+	  esds = function esds(track) {
+	    return box(types.esds, new Uint8Array([0x00,
+	    // version
+	    0x00, 0x00, 0x00,
+	    // flags
+
+	    // ES_Descriptor
+	    0x03,
+	    // tag, ES_DescrTag
+	    0x19,
+	    // length
+	    0x00, 0x00,
+	    // ES_ID
+	    0x00,
+	    // streamDependenceFlag, URL_flag, reserved, streamPriority
+
+	    // DecoderConfigDescriptor
+	    0x04,
+	    // tag, DecoderConfigDescrTag
+	    0x11,
+	    // length
+	    0x40,
+	    // object type
+	    0x15,
+	    // streamType
+	    0x00, 0x06, 0x00,
+	    // bufferSizeDB
+	    0x00, 0x00, 0xda, 0xc0,
+	    // maxBitrate
+	    0x00, 0x00, 0xda, 0xc0,
+	    // avgBitrate
+
+	    // DecoderSpecificInfo
+	    0x05,
+	    // tag, DecoderSpecificInfoTag
+	    0x02,
+	    // length
+	    // ISO/IEC 14496-3, AudioSpecificConfig
+	    // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
+	    track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig
+	    ]));
+	  };
+
+	  ftyp = function ftyp() {
+	    return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);
+	  };
+	  hdlr = function hdlr(type) {
+	    return box(types.hdlr, HDLR_TYPES[type]);
+	  };
+	  mdat = function mdat(data) {
+	    return box(types.mdat, data);
+	  };
+	  mdhd = function mdhd(track) {
+	    var result = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x02,
+	    // creation_time
+	    0x00, 0x00, 0x00, 0x03,
+	    // modification_time
+	    0x00, 0x01, 0x5f, 0x90,
+	    // timescale, 90,000 "ticks" per second
+
+	    track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF,
+	    // duration
+	    0x55, 0xc4,
+	    // 'und' language (undetermined)
+	    0x00, 0x00]);
+
+	    // Use the sample rate from the track metadata, when it is
+	    // defined. The sample rate can be parsed out of an ADTS header, for
+	    // instance.
+	    if (track.samplerate) {
+	      result[12] = track.samplerate >>> 24 & 0xFF;
+	      result[13] = track.samplerate >>> 16 & 0xFF;
+	      result[14] = track.samplerate >>> 8 & 0xFF;
+	      result[15] = track.samplerate & 0xFF;
+	    }
+	    return box(types.mdhd, result);
+	  };
+	  mdia = function mdia(track) {
+	    return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));
+	  };
+	  mfhd = function mfhd(sequenceNumber) {
+	    return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
+	    // flags
+	    (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number
+	    ]));
+	  };
+
+	  minf = function minf(track) {
+	    return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));
+	  };
+	  moof = function moof(sequenceNumber, tracks) {
+	    var trackFragments = [],
+	      i = tracks.length;
+	    // build traf boxes for each track fragment
+	    while (i--) {
+	      trackFragments[i] = traf(tracks[i]);
+	    }
+	    return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));
+	  };
+	  /**
+	   * Returns a movie box.
+	   * @param tracks {array} the tracks associated with this movie
+	   * @see ISO/IEC 14496-12:2012(E), section 8.2.1
+	   */
+	  moov = function moov(tracks, duration) {
+	    var i = tracks.length,
+	      boxes = [];
+	    while (i--) {
+	      boxes[i] = trak(tracks[i]);
+	    }
+	    return box.apply(null, [types.moov, mvhd(duration || 0xffffffff)].concat(boxes).concat(mvex(tracks)));
+	  };
+	  mvex = function mvex(tracks) {
+	    var i = tracks.length,
+	      boxes = [];
+	    while (i--) {
+	      boxes[i] = trex(tracks[i]);
+	    }
+	    return box.apply(null, [types.mvex].concat(boxes));
+	  };
+	  mvhd = function mvhd(duration) {
+	    var bytes = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    0x00, 0x00, 0x00, 0x01,
+	    // creation_time
+	    0x00, 0x00, 0x00, 0x02,
+	    // modification_time
+	    0x00, 0x01, 0x5f, 0x90,
+	    // timescale, 90,000 "ticks" per second
+	    (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF,
+	    // duration
+	    0x00, 0x01, 0x00, 0x00,
+	    // 1.0 rate
+	    0x01, 0x00,
+	    // 1.0 volume
+	    0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+	    // transformation: unity matrix
+	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	    // pre_defined
+	    0xff, 0xff, 0xff, 0xff // next_track_ID
+	    ]);
+
+	    return box(types.mvhd, bytes);
+	  };
+	  sdtp = function sdtp(track) {
+	    var samples = track.samples || [],
+	      bytes = new Uint8Array(4 + samples.length),
+	      flags,
+	      i;
+
+	    // leave the full box header (4 bytes) all zero
+
+	    // write the sample table
+	    for (i = 0; i < samples.length; i++) {
+	      flags = samples[i].flags;
+	      bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
+	    }
+	    return box(types.sdtp, bytes);
+	  };
+	  stbl = function stbl(track) {
+	    return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));
+	  };
+	  (function () {
+	    var videoSample, audioSample;
+	    stsd = function stsd(track) {
+	      return box(types.stsd, new Uint8Array([0x00,
+	      // version 0
+	      0x00, 0x00, 0x00,
+	      // flags
+	      0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));
+	    };
+	    videoSample = function videoSample(track) {
+	      var sps = track.sps || [],
+	        pps = track.pps || [],
+	        sequenceParameterSets = [],
+	        pictureParameterSets = [],
+	        i,
+	        avc1Box;
+
+	      // assemble the SPSs
+	      for (i = 0; i < sps.length; i++) {
+	        sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);
+	        sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength
+	        sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS
+	      }
+
+	      // assemble the PPSs
+	      for (i = 0; i < pps.length; i++) {
+	        pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);
+	        pictureParameterSets.push(pps[i].byteLength & 0xFF);
+	        pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));
+	      }
+	      avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x01,
+	      // data_reference_index
+	      0x00, 0x00,
+	      // pre_defined
+	      0x00, 0x00,
+	      // reserved
+	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // pre_defined
+	      (track.width & 0xff00) >> 8, track.width & 0xff,
+	      // width
+	      (track.height & 0xff00) >> 8, track.height & 0xff,
+	      // height
+	      0x00, 0x48, 0x00, 0x00,
+	      // horizresolution
+	      0x00, 0x48, 0x00, 0x00,
+	      // vertresolution
+	      0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x01,
+	      // frame_count
+	      0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // compressorname
+	      0x00, 0x18,
+	      // depth = 24
+	      0x11, 0x11 // pre_defined = -1
+	      ]), box(types.avcC, new Uint8Array([0x01,
+	      // configurationVersion
+	      track.profileIdc,
+	      // AVCProfileIndication
+	      track.profileCompatibility,
+	      // profile_compatibility
+	      track.levelIdc,
+	      // AVCLevelIndication
+	      0xff // lengthSizeMinusOne, hard-coded to 4 bytes
+	      ].concat([sps.length],
+	      // numOfSequenceParameterSets
+	      sequenceParameterSets,
+	      // "SPS"
+	      [pps.length],
+	      // numOfPictureParameterSets
+	      pictureParameterSets // "PPS"
+	      ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
+	      // bufferSizeDB
+	      0x00, 0x2d, 0xc6, 0xc0,
+	      // maxBitrate
+	      0x00, 0x2d, 0xc6, 0xc0 // avgBitrate
+	      ]))];
+
+	      if (track.sarRatio) {
+	        var hSpacing = track.sarRatio[0],
+	          vSpacing = track.sarRatio[1];
+	        avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));
+	      }
+	      return box.apply(null, avc1Box);
+	    };
+	    audioSample = function audioSample(track) {
+	      return box(types.mp4a, new Uint8Array([
+	      // SampleEntry, ISO/IEC 14496-12
+	      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x01,
+	      // data_reference_index
+
+	      // AudioSampleEntry, ISO/IEC 14496-12
+	      0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      0x00, 0x00, 0x00, 0x00,
+	      // reserved
+	      (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff,
+	      // channelcount
+
+	      (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff,
+	      // samplesize
+	      0x00, 0x00,
+	      // pre_defined
+	      0x00, 0x00,
+	      // reserved
+
+	      (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16
+
+	      // MP4AudioSampleEntry, ISO/IEC 14496-14
+	      ]), esds(track));
+	    };
+	  })();
+	  tkhd = function tkhd(track) {
+	    var result = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x07,
+	    // flags
+	    0x00, 0x00, 0x00, 0x00,
+	    // creation_time
+	    0x00, 0x00, 0x00, 0x00,
+	    // modification_time
+	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+	    // track_ID
+	    0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF,
+	    // duration
+	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	    // reserved
+	    0x00, 0x00,
+	    // layer
+	    0x00, 0x00,
+	    // alternate_group
+	    0x01, 0x00,
+	    // non-audio track volume
+	    0x00, 0x00,
+	    // reserved
+	    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+	    // transformation: unity matrix
+	    (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00,
+	    // width
+	    (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height
+	    ]);
+
+	    return box(types.tkhd, result);
+	  };
+
+	  /**
+	   * Generate a track fragment (traf) box. A traf box collects metadata
+	   * about tracks in a movie fragment (moof) box.
+	   */
+	  traf = function traf(track) {
+	    var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;
+	    trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x3a,
+	    // flags
+	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+	    // track_ID
+	    0x00, 0x00, 0x00, 0x01,
+	    // sample_description_index
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_duration
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_size
+	    0x00, 0x00, 0x00, 0x00 // default_sample_flags
+	    ]));
+
+	    upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / MAX_UINT32);
+	    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % MAX_UINT32);
+	    trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01,
+	    // version 1
+	    0x00, 0x00, 0x00,
+	    // flags
+	    // baseMediaDecodeTime
+	    upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF]));
+
+	    // the data offset specifies the number of bytes from the start of
+	    // the containing moof to the first payload byte of the associated
+	    // mdat
+	    dataOffset = 32 +
+	    // tfhd
+	    20 +
+	    // tfdt
+	    8 +
+	    // traf header
+	    16 +
+	    // mfhd
+	    8 +
+	    // moof header
+	    8; // mdat header
+
+	    // audio tracks require less metadata
+	    if (track.type === 'audio') {
+	      trackFragmentRun = trun(track, dataOffset);
+	      return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);
+	    }
+
+	    // video tracks should contain an independent and disposable samples
+	    // box (sdtp)
+	    // generate one and adjust offsets to match
+	    sampleDependencyTable = sdtp(track);
+	    trackFragmentRun = trun(track, sampleDependencyTable.length + dataOffset);
+	    return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);
+	  };
+
+	  /**
+	   * Generate a track box.
+	   * @param track {object} a track definition
+	   * @return {Uint8Array} the track box
+	   */
+	  trak = function trak(track) {
+	    track.duration = track.duration || 0xffffffff;
+	    return box(types.trak, tkhd(track), mdia(track));
+	  };
+	  trex = function trex(track) {
+	    var result = new Uint8Array([0x00,
+	    // version 0
+	    0x00, 0x00, 0x00,
+	    // flags
+	    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+	    // track_ID
+	    0x00, 0x00, 0x00, 0x01,
+	    // default_sample_description_index
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_duration
+	    0x00, 0x00, 0x00, 0x00,
+	    // default_sample_size
+	    0x00, 0x01, 0x00, 0x01 // default_sample_flags
+	    ]);
+	    // the last two bytes of default_sample_flags is the sample
+	    // degradation priority, a hint about the importance of this sample
+	    // relative to others. Lower the degradation priority for all sample
+	    // types other than video.
+	    if (track.type !== 'video') {
+	      result[result.length - 1] = 0x00;
+	    }
+	    return box(types.trex, result);
+	  };
+	  (function () {
+	    var audioTrun, videoTrun, trunHeader;
+
+	    // This method assumes all samples are uniform. That is, if a
+	    // duration is present for the first sample, it will be present for
+	    // all subsequent samples.
+	    // see ISO/IEC 14496-12:2012, Section 8.8.8.1
+	    trunHeader = function trunHeader(samples, offset) {
+	      var durationPresent = 0,
+	        sizePresent = 0,
+	        flagsPresent = 0,
+	        compositionTimeOffset = 0;
+
+	      // trun flag constants
+	      if (samples.length) {
+	        if (samples[0].duration !== undefined) {
+	          durationPresent = 0x1;
+	        }
+	        if (samples[0].size !== undefined) {
+	          sizePresent = 0x2;
+	        }
+	        if (samples[0].flags !== undefined) {
+	          flagsPresent = 0x4;
+	        }
+	        if (samples[0].compositionTimeOffset !== undefined) {
+	          compositionTimeOffset = 0x8;
+	        }
+	      }
+	      return [0x00,
+	      // version 0
+	      0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01,
+	      // flags
+	      (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF,
+	      // sample_count
+	      (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset
+	      ];
+	    };
+
+	    videoTrun = function videoTrun(track, offset) {
+	      var bytesOffest, bytes, header, samples, sample, i;
+	      samples = track.samples || [];
+	      offset += 8 + 12 + 16 * samples.length;
+	      header = trunHeader(samples, offset);
+	      bytes = new Uint8Array(header.length + samples.length * 16);
+	      bytes.set(header);
+	      bytesOffest = header.length;
+	      for (i = 0; i < samples.length; i++) {
+	        sample = samples[i];
+	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+	        bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;
+	        bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;
+	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;
+	        bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags
+	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset
+	      }
+
+	      return box(types.trun, bytes);
+	    };
+	    audioTrun = function audioTrun(track, offset) {
+	      var bytes, bytesOffest, header, samples, sample, i;
+	      samples = track.samples || [];
+	      offset += 8 + 12 + 8 * samples.length;
+	      header = trunHeader(samples, offset);
+	      bytes = new Uint8Array(header.length + samples.length * 8);
+	      bytes.set(header);
+	      bytesOffest = header.length;
+	      for (i = 0; i < samples.length; i++) {
+	        sample = samples[i];
+	        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+	        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+	        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+	        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+	        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+	      }
+
+	      return box(types.trun, bytes);
+	    };
+	    trun = function trun(track, offset) {
+	      if (track.type === 'audio') {
+	        return audioTrun(track, offset);
+	      }
+	      return videoTrun(track, offset);
+	    };
+	  })();
+	  var mp4Generator = {
+	    ftyp: ftyp,
+	    mdat: mdat,
+	    moof: moof,
+	    moov: moov,
+	    initSegment: function initSegment(tracks) {
+	      var duration = tracks.reduce(function (p, n) {
+	        return p + n.duration;
+	      }, 0);
+	      var fileType = ftyp(),
+	        movie = moov(tracks, duration),
+	        result;
+	      result = new Uint8Array(fileType.byteLength + movie.byteLength);
+	      result.set(fileType);
+	      result.set(movie, fileType.byteLength);
+	      return result;
+	    }
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  // Convert an array of nal units into an array of frames with each frame being
+	  // composed of the nal units that make up that frame
+	  // Also keep track of cummulative data about the frame from the nal units such
+	  // as the frame duration, starting pts, etc.
+	  var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {
+	    var i,
+	      currentNal,
+	      currentFrame = [],
+	      frames = [];
+
+	    // TODO added for LHLS, make sure this is OK
+	    frames.byteLength = 0;
+	    frames.nalCount = 0;
+	    frames.duration = 0;
+	    currentFrame.byteLength = 0;
+	    for (i = 0; i < nalUnits.length; i++) {
+	      currentNal = nalUnits[i];
+
+	      // Split on 'aud'-type nal units
+	      if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
+	        // Since the very first nal unit is expected to be an AUD
+	        // only push to the frames array when currentFrame is not empty
+	        if (currentFrame.length) {
+	          currentFrame.duration = currentNal.dts - currentFrame.dts;
+	          // TODO added for LHLS, make sure this is OK
+	          frames.byteLength += currentFrame.byteLength;
+	          frames.nalCount += currentFrame.length;
+	          frames.duration += currentFrame.duration;
+	          frames.push(currentFrame);
+	        }
+	        currentFrame = [currentNal];
+	        currentFrame.byteLength = currentNal.data.byteLength;
+	        currentFrame.pts = currentNal.pts;
+	        currentFrame.dts = currentNal.dts;
+	      } else {
+	        // Specifically flag key frames for ease of use later
+	        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
+	          currentFrame.keyFrame = true;
+	        }
+	        currentFrame.duration = currentNal.dts - currentFrame.dts;
+	        currentFrame.byteLength += currentNal.data.byteLength;
+	        currentFrame.push(currentNal);
+	      }
+	    }
+
+	    // For the last frame, use the duration of the previous frame if we
+	    // have nothing better to go on
+	    if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {
+	      currentFrame.duration = frames[frames.length - 1].duration;
+	    }
+
+	    // Push the final frame
+	    // TODO added for LHLS, make sure this is OK
+	    frames.byteLength += currentFrame.byteLength;
+	    frames.nalCount += currentFrame.length;
+	    frames.duration += currentFrame.duration;
+	    frames.push(currentFrame);
+	    return frames;
+	  };
+
+	  // Convert an array of frames into an array of Gop with each Gop being composed
+	  // of the frames that make up that Gop
+	  // Also keep track of cummulative data about the Gop from the frames such as the
+	  // Gop duration, starting pts, etc.
+	  var groupFramesIntoGops = function groupFramesIntoGops(frames) {
+	    var i,
+	      currentFrame,
+	      currentGop = [],
+	      gops = [];
+
+	    // We must pre-set some of the values on the Gop since we
+	    // keep running totals of these values
+	    currentGop.byteLength = 0;
+	    currentGop.nalCount = 0;
+	    currentGop.duration = 0;
+	    currentGop.pts = frames[0].pts;
+	    currentGop.dts = frames[0].dts;
+
+	    // store some metadata about all the Gops
+	    gops.byteLength = 0;
+	    gops.nalCount = 0;
+	    gops.duration = 0;
+	    gops.pts = frames[0].pts;
+	    gops.dts = frames[0].dts;
+	    for (i = 0; i < frames.length; i++) {
+	      currentFrame = frames[i];
+	      if (currentFrame.keyFrame) {
+	        // Since the very first frame is expected to be an keyframe
+	        // only push to the gops array when currentGop is not empty
+	        if (currentGop.length) {
+	          gops.push(currentGop);
+	          gops.byteLength += currentGop.byteLength;
+	          gops.nalCount += currentGop.nalCount;
+	          gops.duration += currentGop.duration;
+	        }
+	        currentGop = [currentFrame];
+	        currentGop.nalCount = currentFrame.length;
+	        currentGop.byteLength = currentFrame.byteLength;
+	        currentGop.pts = currentFrame.pts;
+	        currentGop.dts = currentFrame.dts;
+	        currentGop.duration = currentFrame.duration;
+	      } else {
+	        currentGop.duration += currentFrame.duration;
+	        currentGop.nalCount += currentFrame.length;
+	        currentGop.byteLength += currentFrame.byteLength;
+	        currentGop.push(currentFrame);
+	      }
+	    }
+	    if (gops.length && currentGop.duration <= 0) {
+	      currentGop.duration = gops[gops.length - 1].duration;
+	    }
+	    gops.byteLength += currentGop.byteLength;
+	    gops.nalCount += currentGop.nalCount;
+	    gops.duration += currentGop.duration;
+
+	    // push the final Gop
+	    gops.push(currentGop);
+	    return gops;
+	  };
+
+	  /*
+	   * Search for the first keyframe in the GOPs and throw away all frames
+	   * until that keyframe. Then extend the duration of the pulled keyframe
+	   * and pull the PTS and DTS of the keyframe so that it covers the time
+	   * range of the frames that were disposed.
+	   *
+	   * @param {Array} gops video GOPs
+	   * @returns {Array} modified video GOPs
+	   */
+	  var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {
+	    var currentGop;
+	    if (!gops[0][0].keyFrame && gops.length > 1) {
+	      // Remove the first GOP
+	      currentGop = gops.shift();
+	      gops.byteLength -= currentGop.byteLength;
+	      gops.nalCount -= currentGop.nalCount;
+
+	      // Extend the first frame of what is now the
+	      // first gop to cover the time period of the
+	      // frames we just removed
+	      gops[0][0].dts = currentGop.dts;
+	      gops[0][0].pts = currentGop.pts;
+	      gops[0][0].duration += currentGop.duration;
+	    }
+	    return gops;
+	  };
+
+	  /**
+	   * Default sample object
+	   * see ISO/IEC 14496-12:2012, section 8.6.4.3
+	   */
+	  var createDefaultSample = function createDefaultSample() {
+	    return {
+	      size: 0,
+	      flags: {
+	        isLeading: 0,
+	        dependsOn: 1,
+	        isDependedOn: 0,
+	        hasRedundancy: 0,
+	        degradationPriority: 0,
+	        isNonSyncSample: 1
+	      }
+	    };
+	  };
+
+	  /*
+	   * Collates information from a video frame into an object for eventual
+	   * entry into an MP4 sample table.
+	   *
+	   * @param {Object} frame the video frame
+	   * @param {Number} dataOffset the byte offset to position the sample
+	   * @return {Object} object containing sample table info for a frame
+	   */
+	  var sampleForFrame = function sampleForFrame(frame, dataOffset) {
+	    var sample = createDefaultSample();
+	    sample.dataOffset = dataOffset;
+	    sample.compositionTimeOffset = frame.pts - frame.dts;
+	    sample.duration = frame.duration;
+	    sample.size = 4 * frame.length; // Space for nal unit size
+	    sample.size += frame.byteLength;
+	    if (frame.keyFrame) {
+	      sample.flags.dependsOn = 2;
+	      sample.flags.isNonSyncSample = 0;
+	    }
+	    return sample;
+	  };
+
+	  // generate the track's sample table from an array of gops
+	  var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {
+	    var h,
+	      i,
+	      sample,
+	      currentGop,
+	      currentFrame,
+	      dataOffset = baseDataOffset || 0,
+	      samples = [];
+	    for (h = 0; h < gops.length; h++) {
+	      currentGop = gops[h];
+	      for (i = 0; i < currentGop.length; i++) {
+	        currentFrame = currentGop[i];
+	        sample = sampleForFrame(currentFrame, dataOffset);
+	        dataOffset += sample.size;
+	        samples.push(sample);
+	      }
+	    }
+	    return samples;
+	  };
+
+	  // generate the track's raw mdat data from an array of gops
+	  var concatenateNalData = function concatenateNalData(gops) {
+	    var h,
+	      i,
+	      j,
+	      currentGop,
+	      currentFrame,
+	      currentNal,
+	      dataOffset = 0,
+	      nalsByteLength = gops.byteLength,
+	      numberOfNals = gops.nalCount,
+	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+	      data = new Uint8Array(totalByteLength),
+	      view = new DataView(data.buffer);
+
+	    // For each Gop..
+	    for (h = 0; h < gops.length; h++) {
+	      currentGop = gops[h];
+
+	      // For each Frame..
+	      for (i = 0; i < currentGop.length; i++) {
+	        currentFrame = currentGop[i];
+
+	        // For each NAL..
+	        for (j = 0; j < currentFrame.length; j++) {
+	          currentNal = currentFrame[j];
+	          view.setUint32(dataOffset, currentNal.data.byteLength);
+	          dataOffset += 4;
+	          data.set(currentNal.data, dataOffset);
+	          dataOffset += currentNal.data.byteLength;
+	        }
+	      }
+	    }
+	    return data;
+	  };
+
+	  // generate the track's sample table from a frame
+	  var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {
+	    var sample,
+	      dataOffset = baseDataOffset || 0,
+	      samples = [];
+	    sample = sampleForFrame(frame, dataOffset);
+	    samples.push(sample);
+	    return samples;
+	  };
+
+	  // generate the track's raw mdat data from a frame
+	  var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {
+	    var i,
+	      currentNal,
+	      dataOffset = 0,
+	      nalsByteLength = frame.byteLength,
+	      numberOfNals = frame.length,
+	      totalByteLength = nalsByteLength + 4 * numberOfNals,
+	      data = new Uint8Array(totalByteLength),
+	      view = new DataView(data.buffer);
+
+	    // For each NAL..
+	    for (i = 0; i < frame.length; i++) {
+	      currentNal = frame[i];
+	      view.setUint32(dataOffset, currentNal.data.byteLength);
+	      dataOffset += 4;
+	      data.set(currentNal.data, dataOffset);
+	      dataOffset += currentNal.data.byteLength;
+	    }
+	    return data;
+	  };
+	  var frameUtils = {
+	    groupNalsIntoFrames: groupNalsIntoFrames,
+	    groupFramesIntoGops: groupFramesIntoGops,
+	    extendFirstKeyFrame: extendFirstKeyFrame,
+	    generateSampleTable: generateSampleTable$1,
+	    concatenateNalData: concatenateNalData,
+	    generateSampleTableForFrame: generateSampleTableForFrame,
+	    concatenateNalDataForFrame: concatenateNalDataForFrame
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  var highPrefix = [33, 16, 5, 32, 164, 27];
+	  var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];
+	  var zeroFill = function zeroFill(count) {
+	    var a = [];
+	    while (count--) {
+	      a.push(0);
+	    }
+	    return a;
+	  };
+	  var makeTable = function makeTable(metaTable) {
+	    return Object.keys(metaTable).reduce(function (obj, key) {
+	      obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {
+	        return arr.concat(part);
+	      }, []));
+	      return obj;
+	    }, {});
+	  };
+	  var silence;
+	  var silence_1 = function silence_1() {
+	    if (!silence) {
+	      // Frames-of-silence to use for filling in missing AAC frames
+	      var coneOfSilence = {
+	        96000: [highPrefix, [227, 64], zeroFill(154), [56]],
+	        88200: [highPrefix, [231], zeroFill(170), [56]],
+	        64000: [highPrefix, [248, 192], zeroFill(240), [56]],
+	        48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],
+	        44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],
+	        32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],
+	        24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],
+	        16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],
+	        12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],
+	        11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],
+	        8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]
+	      };
+	      silence = makeTable(coneOfSilence);
+	    }
+	    return silence;
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  var ONE_SECOND_IN_TS$3 = 90000,
+	    // 90kHz clock
+	    secondsToVideoTs,
+	    secondsToAudioTs,
+	    videoTsToSeconds,
+	    audioTsToSeconds,
+	    audioTsToVideoTs,
+	    videoTsToAudioTs,
+	    metadataTsToSeconds;
+	  secondsToVideoTs = function secondsToVideoTs(seconds) {
+	    return seconds * ONE_SECOND_IN_TS$3;
+	  };
+	  secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {
+	    return seconds * sampleRate;
+	  };
+	  videoTsToSeconds = function videoTsToSeconds(timestamp) {
+	    return timestamp / ONE_SECOND_IN_TS$3;
+	  };
+	  audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {
+	    return timestamp / sampleRate;
+	  };
+	  audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {
+	    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
+	  };
+	  videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {
+	    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
+	  };
+
+	  /**
+	   * Adjust ID3 tag or caption timing information by the timeline pts values
+	   * (if keepOriginalTimestamps is false) and convert to seconds
+	   */
+	  metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {
+	    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
+	  };
+	  var clock = {
+	    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$3,
+	    secondsToVideoTs: secondsToVideoTs,
+	    secondsToAudioTs: secondsToAudioTs,
+	    videoTsToSeconds: videoTsToSeconds,
+	    audioTsToSeconds: audioTsToSeconds,
+	    audioTsToVideoTs: audioTsToVideoTs,
+	    videoTsToAudioTs: videoTsToAudioTs,
+	    metadataTsToSeconds: metadataTsToSeconds
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+
+	  /**
+	   * Sum the `byteLength` properties of the data in each AAC frame
+	   */
+	  var sumFrameByteLengths = function sumFrameByteLengths(array) {
+	    var i,
+	      currentObj,
+	      sum = 0;
+
+	    // sum the byteLength's all each nal unit in the frame
+	    for (i = 0; i < array.length; i++) {
+	      currentObj = array[i];
+	      sum += currentObj.data.byteLength;
+	    }
+	    return sum;
+	  };
+
+	  // Possibly pad (prefix) the audio track with silence if appending this track
+	  // would lead to the introduction of a gap in the audio buffer
+	  var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {
+	    var baseMediaDecodeTimeTs,
+	      frameDuration = 0,
+	      audioGapDuration = 0,
+	      audioFillFrameCount = 0,
+	      audioFillDuration = 0,
+	      silentFrame,
+	      i,
+	      firstFrame;
+	    if (!frames.length) {
+	      return;
+	    }
+	    baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate);
+	    // determine frame clock duration based on sample rate, round up to avoid overfills
+	    frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));
+	    if (audioAppendStartTs && videoBaseMediaDecodeTime) {
+	      // insert the shortest possible amount (audio gap or audio to video gap)
+	      audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime);
+	      // number of full frames in the audio gap
+	      audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);
+	      audioFillDuration = audioFillFrameCount * frameDuration;
+	    }
+
+	    // don't attempt to fill gaps smaller than a single frame or larger
+	    // than a half second
+	    if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {
+	      return;
+	    }
+	    silentFrame = silence_1()[track.samplerate];
+	    if (!silentFrame) {
+	      // we don't have a silent frame pregenerated for the sample rate, so use a frame
+	      // from the content instead
+	      silentFrame = frames[0].data;
+	    }
+	    for (i = 0; i < audioFillFrameCount; i++) {
+	      firstFrame = frames[0];
+	      frames.splice(0, 0, {
+	        data: silentFrame,
+	        dts: firstFrame.dts - frameDuration,
+	        pts: firstFrame.pts - frameDuration
+	      });
+	    }
+	    track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));
+	    return audioFillDuration;
+	  };
+
+	  // If the audio segment extends before the earliest allowed dts
+	  // value, remove AAC frames until starts at or after the earliest
+	  // allowed DTS so that we don't end up with a negative baseMedia-
+	  // DecodeTime for the audio track
+	  var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {
+	    if (track.minSegmentDts >= earliestAllowedDts) {
+	      return adtsFrames;
+	    }
+
+	    // We will need to recalculate the earliest segment Dts
+	    track.minSegmentDts = Infinity;
+	    return adtsFrames.filter(function (currentFrame) {
+	      // If this is an allowed frame, keep it and record it's Dts
+	      if (currentFrame.dts >= earliestAllowedDts) {
+	        track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);
+	        track.minSegmentPts = track.minSegmentDts;
+	        return true;
+	      }
+	      // Otherwise, discard it
+	      return false;
+	    });
+	  };
+
+	  // generate the track's raw mdat data from an array of frames
+	  var generateSampleTable = function generateSampleTable(frames) {
+	    var i,
+	      currentFrame,
+	      samples = [];
+	    for (i = 0; i < frames.length; i++) {
+	      currentFrame = frames[i];
+	      samples.push({
+	        size: currentFrame.data.byteLength,
+	        duration: 1024 // For AAC audio, all samples contain 1024 samples
+	      });
+	    }
+
+	    return samples;
+	  };
+
+	  // generate the track's sample table from an array of frames
+	  var concatenateFrameData = function concatenateFrameData(frames) {
+	    var i,
+	      currentFrame,
+	      dataOffset = 0,
+	      data = new Uint8Array(sumFrameByteLengths(frames));
+	    for (i = 0; i < frames.length; i++) {
+	      currentFrame = frames[i];
+	      data.set(currentFrame.data, dataOffset);
+	      dataOffset += currentFrame.data.byteLength;
+	    }
+	    return data;
+	  };
+	  var audioFrameUtils = {
+	    prefixWithSilence: prefixWithSilence,
+	    trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,
+	    generateSampleTable: generateSampleTable,
+	    concatenateFrameData: concatenateFrameData
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+	  var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS;
+
+	  /**
+	   * Store information about the start and end of the track and the
+	   * duration for each frame/sample we process in order to calculate
+	   * the baseMediaDecodeTime
+	   */
+	  var collectDtsInfo = function collectDtsInfo(track, data) {
+	    if (typeof data.pts === 'number') {
+	      if (track.timelineStartInfo.pts === undefined) {
+	        track.timelineStartInfo.pts = data.pts;
+	      }
+	      if (track.minSegmentPts === undefined) {
+	        track.minSegmentPts = data.pts;
+	      } else {
+	        track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);
+	      }
+	      if (track.maxSegmentPts === undefined) {
+	        track.maxSegmentPts = data.pts;
+	      } else {
+	        track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);
+	      }
+	    }
+	    if (typeof data.dts === 'number') {
+	      if (track.timelineStartInfo.dts === undefined) {
+	        track.timelineStartInfo.dts = data.dts;
+	      }
+	      if (track.minSegmentDts === undefined) {
+	        track.minSegmentDts = data.dts;
+	      } else {
+	        track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);
+	      }
+	      if (track.maxSegmentDts === undefined) {
+	        track.maxSegmentDts = data.dts;
+	      } else {
+	        track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);
+	      }
+	    }
+	  };
+
+	  /**
+	   * Clear values used to calculate the baseMediaDecodeTime between
+	   * tracks
+	   */
+	  var clearDtsInfo = function clearDtsInfo(track) {
+	    delete track.minSegmentDts;
+	    delete track.maxSegmentDts;
+	    delete track.minSegmentPts;
+	    delete track.maxSegmentPts;
+	  };
+
+	  /**
+	   * Calculate the track's baseMediaDecodeTime based on the earliest
+	   * DTS the transmuxer has ever seen and the minimum DTS for the
+	   * current track
+	   * @param track {object} track metadata configuration
+	   * @param keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at 0.
+	   */
+	  var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {
+	    var baseMediaDecodeTime,
+	      scale,
+	      minSegmentDts = track.minSegmentDts;
+
+	    // Optionally adjust the time so the first segment starts at zero.
+	    if (!keepOriginalTimestamps) {
+	      minSegmentDts -= track.timelineStartInfo.dts;
+	    }
+
+	    // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where
+	    // we want the start of the first segment to be placed
+	    baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime;
+
+	    // Add to that the distance this segment is from the very first
+	    baseMediaDecodeTime += minSegmentDts;
+
+	    // baseMediaDecodeTime must not become negative
+	    baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);
+	    if (track.type === 'audio') {
+	      // Audio has a different clock equal to the sampling_rate so we need to
+	      // scale the PTS values into the clock rate of the track
+	      scale = track.samplerate / ONE_SECOND_IN_TS$2;
+	      baseMediaDecodeTime *= scale;
+	      baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);
+	    }
+	    return baseMediaDecodeTime;
+	  };
+	  var trackDecodeInfo = {
+	    clearDtsInfo: clearDtsInfo,
+	    calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,
+	    collectDtsInfo: collectDtsInfo
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   *
+	   * Reads in-band caption information from a video elementary
+	   * stream. Captions must follow the CEA-708 standard for injection
+	   * into an MPEG-2 transport streams.
+	   * @see https://en.wikipedia.org/wiki/CEA-708
+	   * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf
+	   */
+
+	  // Supplemental enhancement information (SEI) NAL units have a
+	  // payload type field to indicate how they are to be
+	  // interpreted. CEAS-708 caption content is always transmitted with
+	  // payload type 0x04.
+	  var USER_DATA_REGISTERED_ITU_T_T35 = 4,
+	    RBSP_TRAILING_BITS = 128;
+
+	  /**
+	    * Parse a supplemental enhancement information (SEI) NAL unit.
+	    * Stops parsing once a message of type ITU T T35 has been found.
+	    *
+	    * @param bytes {Uint8Array} the bytes of a SEI NAL unit
+	    * @return {object} the parsed SEI payload
+	    * @see Rec. ITU-T H.264, 7.3.2.3.1
+	    */
+	  var parseSei = function parseSei(bytes) {
+	    var i = 0,
+	      result = {
+	        payloadType: -1,
+	        payloadSize: 0
+	      },
+	      payloadType = 0,
+	      payloadSize = 0;
+
+	    // go through the sei_rbsp parsing each each individual sei_message
+	    while (i < bytes.byteLength) {
+	      // stop once we have hit the end of the sei_rbsp
+	      if (bytes[i] === RBSP_TRAILING_BITS) {
+	        break;
+	      }
+
+	      // Parse payload type
+	      while (bytes[i] === 0xFF) {
+	        payloadType += 255;
+	        i++;
+	      }
+	      payloadType += bytes[i++];
+
+	      // Parse payload size
+	      while (bytes[i] === 0xFF) {
+	        payloadSize += 255;
+	        i++;
+	      }
+	      payloadSize += bytes[i++];
+
+	      // this sei_message is a 608/708 caption so save it and break
+	      // there can only ever be one caption message in a frame's sei
+	      if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {
+	        var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);
+	        if (userIdentifier === 'GA94') {
+	          result.payloadType = payloadType;
+	          result.payloadSize = payloadSize;
+	          result.payload = bytes.subarray(i, i + payloadSize);
+	          break;
+	        } else {
+	          result.payload = void 0;
+	        }
+	      }
+
+	      // skip the payload and parse the next message
+	      i += payloadSize;
+	      payloadType = 0;
+	      payloadSize = 0;
+	    }
+	    return result;
+	  };
+
+	  // see ANSI/SCTE 128-1 (2013), section 8.1
+	  var parseUserData = function parseUserData(sei) {
+	    // itu_t_t35_contry_code must be 181 (United States) for
+	    // captions
+	    if (sei.payload[0] !== 181) {
+	      return null;
+	    }
+
+	    // itu_t_t35_provider_code should be 49 (ATSC) for captions
+	    if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {
+	      return null;
+	    }
+
+	    // the user_identifier should be "GA94" to indicate ATSC1 data
+	    if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {
+	      return null;
+	    }
+
+	    // finally, user_data_type_code should be 0x03 for caption data
+	    if (sei.payload[7] !== 0x03) {
+	      return null;
+	    }
+
+	    // return the user_data_type_structure and strip the trailing
+	    // marker bits
+	    return sei.payload.subarray(8, sei.payload.length - 1);
+	  };
+
+	  // see CEA-708-D, section 4.4
+	  var parseCaptionPackets = function parseCaptionPackets(pts, userData) {
+	    var results = [],
+	      i,
+	      count,
+	      offset,
+	      data;
+
+	    // if this is just filler, return immediately
+	    if (!(userData[0] & 0x40)) {
+	      return results;
+	    }
+
+	    // parse out the cc_data_1 and cc_data_2 fields
+	    count = userData[0] & 0x1f;
+	    for (i = 0; i < count; i++) {
+	      offset = i * 3;
+	      data = {
+	        type: userData[offset + 2] & 0x03,
+	        pts: pts
+	      };
+
+	      // capture cc data when cc_valid is 1
+	      if (userData[offset + 2] & 0x04) {
+	        data.ccData = userData[offset + 3] << 8 | userData[offset + 4];
+	        results.push(data);
+	      }
+	    }
+	    return results;
+	  };
+	  var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+	    var length = data.byteLength,
+	      emulationPreventionBytesPositions = [],
+	      i = 1,
+	      newLength,
+	      newData;
+
+	    // Find all `Emulation Prevention Bytes`
+	    while (i < length - 2) {
+	      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+	        emulationPreventionBytesPositions.push(i + 2);
+	        i += 2;
+	      } else {
+	        i++;
+	      }
+	    }
+
+	    // If no Emulation Prevention Bytes were found just return the original
+	    // array
+	    if (emulationPreventionBytesPositions.length === 0) {
+	      return data;
+	    }
+
+	    // Create a new array to hold the NAL unit data
+	    newLength = length - emulationPreventionBytesPositions.length;
+	    newData = new Uint8Array(newLength);
+	    var sourceIndex = 0;
+	    for (i = 0; i < newLength; sourceIndex++, i++) {
+	      if (sourceIndex === emulationPreventionBytesPositions[0]) {
+	        // Skip this byte
+	        sourceIndex++;
+	        // Remove this position index
+	        emulationPreventionBytesPositions.shift();
+	      }
+	      newData[i] = data[sourceIndex];
+	    }
+	    return newData;
+	  };
+
+	  // exports
+	  var captionPacketParser = {
+	    parseSei: parseSei,
+	    parseUserData: parseUserData,
+	    parseCaptionPackets: parseCaptionPackets,
+	    discardEmulationPreventionBytes: discardEmulationPreventionBytes,
+	    USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35
+	  };
+
+	  // -----------------
+	  // Link To Transport
+	  // -----------------
+
+	  var CaptionStream = function CaptionStream(options) {
+	    options = options || {};
+	    CaptionStream.prototype.init.call(this);
+
+	    // parse708captions flag, default to true
+	    this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;
+	    this.captionPackets_ = [];
+	    this.ccStreams_ = [new Cea608Stream(0, 0),
+	    // eslint-disable-line no-use-before-define
+	    new Cea608Stream(0, 1),
+	    // eslint-disable-line no-use-before-define
+	    new Cea608Stream(1, 0),
+	    // eslint-disable-line no-use-before-define
+	    new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define
+	    ];
+
+	    if (this.parse708captions_) {
+	      this.cc708Stream_ = new Cea708Stream({
+	        captionServices: options.captionServices
+	      }); // eslint-disable-line no-use-before-define
+	    }
+
+	    this.reset();
+
+	    // forward data and done events from CCs to this CaptionStream
+	    this.ccStreams_.forEach(function (cc) {
+	      cc.on('data', this.trigger.bind(this, 'data'));
+	      cc.on('partialdone', this.trigger.bind(this, 'partialdone'));
+	      cc.on('done', this.trigger.bind(this, 'done'));
+	    }, this);
+	    if (this.parse708captions_) {
+	      this.cc708Stream_.on('data', this.trigger.bind(this, 'data'));
+	      this.cc708Stream_.on('partialdone', this.trigger.bind(this, 'partialdone'));
+	      this.cc708Stream_.on('done', this.trigger.bind(this, 'done'));
+	    }
+	  };
+	  CaptionStream.prototype = new stream();
+	  CaptionStream.prototype.push = function (event) {
+	    var sei, userData, newCaptionPackets;
+
+	    // only examine SEI NALs
+	    if (event.nalUnitType !== 'sei_rbsp') {
+	      return;
+	    }
+
+	    // parse the sei
+	    sei = captionPacketParser.parseSei(event.escapedRBSP);
+
+	    // no payload data, skip
+	    if (!sei.payload) {
+	      return;
+	    }
+
+	    // ignore everything but user_data_registered_itu_t_t35
+	    if (sei.payloadType !== captionPacketParser.USER_DATA_REGISTERED_ITU_T_T35) {
+	      return;
+	    }
+
+	    // parse out the user data payload
+	    userData = captionPacketParser.parseUserData(sei);
+
+	    // ignore unrecognized userData
+	    if (!userData) {
+	      return;
+	    }
+
+	    // Sometimes, the same segment # will be downloaded twice. To stop the
+	    // caption data from being processed twice, we track the latest dts we've
+	    // received and ignore everything with a dts before that. However, since
+	    // data for a specific dts can be split across packets on either side of
+	    // a segment boundary, we need to make sure we *don't* ignore the packets
+	    // from the *next* segment that have dts === this.latestDts_. By constantly
+	    // tracking the number of packets received with dts === this.latestDts_, we
+	    // know how many should be ignored once we start receiving duplicates.
+	    if (event.dts < this.latestDts_) {
+	      // We've started getting older data, so set the flag.
+	      this.ignoreNextEqualDts_ = true;
+	      return;
+	    } else if (event.dts === this.latestDts_ && this.ignoreNextEqualDts_) {
+	      this.numSameDts_--;
+	      if (!this.numSameDts_) {
+	        // We've received the last duplicate packet, time to start processing again
+	        this.ignoreNextEqualDts_ = false;
+	      }
+	      return;
+	    }
+
+	    // parse out CC data packets and save them for later
+	    newCaptionPackets = captionPacketParser.parseCaptionPackets(event.pts, userData);
+	    this.captionPackets_ = this.captionPackets_.concat(newCaptionPackets);
+	    if (this.latestDts_ !== event.dts) {
+	      this.numSameDts_ = 0;
+	    }
+	    this.numSameDts_++;
+	    this.latestDts_ = event.dts;
+	  };
+	  CaptionStream.prototype.flushCCStreams = function (flushType) {
+	    this.ccStreams_.forEach(function (cc) {
+	      return flushType === 'flush' ? cc.flush() : cc.partialFlush();
+	    }, this);
+	  };
+	  CaptionStream.prototype.flushStream = function (flushType) {
+	    // make sure we actually parsed captions before proceeding
+	    if (!this.captionPackets_.length) {
+	      this.flushCCStreams(flushType);
+	      return;
+	    }
+
+	    // In Chrome, the Array#sort function is not stable so add a
+	    // presortIndex that we can use to ensure we get a stable-sort
+	    this.captionPackets_.forEach(function (elem, idx) {
+	      elem.presortIndex = idx;
+	    });
+
+	    // sort caption byte-pairs based on their PTS values
+	    this.captionPackets_.sort(function (a, b) {
+	      if (a.pts === b.pts) {
+	        return a.presortIndex - b.presortIndex;
+	      }
+	      return a.pts - b.pts;
+	    });
+	    this.captionPackets_.forEach(function (packet) {
+	      if (packet.type < 2) {
+	        // Dispatch packet to the right Cea608Stream
+	        this.dispatchCea608Packet(packet);
+	      } else {
+	        // Dispatch packet to the Cea708Stream
+	        this.dispatchCea708Packet(packet);
+	      }
+	    }, this);
+	    this.captionPackets_.length = 0;
+	    this.flushCCStreams(flushType);
+	  };
+	  CaptionStream.prototype.flush = function () {
+	    return this.flushStream('flush');
+	  };
+
+	  // Only called if handling partial data
+	  CaptionStream.prototype.partialFlush = function () {
+	    return this.flushStream('partialFlush');
+	  };
+	  CaptionStream.prototype.reset = function () {
+	    this.latestDts_ = null;
+	    this.ignoreNextEqualDts_ = false;
+	    this.numSameDts_ = 0;
+	    this.activeCea608Channel_ = [null, null];
+	    this.ccStreams_.forEach(function (ccStream) {
+	      ccStream.reset();
+	    });
+	  };
+
+	  // From the CEA-608 spec:
+	  /*
+	   * When XDS sub-packets are interleaved with other services, the end of each sub-packet shall be followed
+	   * by a control pair to change to a different service. When any of the control codes from 0x10 to 0x1F is
+	   * used to begin a control code pair, it indicates the return to captioning or Text data. The control code pair
+	   * and subsequent data should then be processed according to the FCC rules. It may be necessary for the
+	   * line 21 data encoder to automatically insert a control code pair (i.e. RCL, RU2, RU3, RU4, RDC, or RTD)
+	   * to switch to captioning or Text.
+	  */
+	  // With that in mind, we ignore any data between an XDS control code and a
+	  // subsequent closed-captioning control code.
+	  CaptionStream.prototype.dispatchCea608Packet = function (packet) {
+	    // NOTE: packet.type is the CEA608 field
+	    if (this.setsTextOrXDSActive(packet)) {
+	      this.activeCea608Channel_[packet.type] = null;
+	    } else if (this.setsChannel1Active(packet)) {
+	      this.activeCea608Channel_[packet.type] = 0;
+	    } else if (this.setsChannel2Active(packet)) {
+	      this.activeCea608Channel_[packet.type] = 1;
+	    }
+	    if (this.activeCea608Channel_[packet.type] === null) {
+	      // If we haven't received anything to set the active channel, or the
+	      // packets are Text/XDS data, discard the data; we don't want jumbled
+	      // captions
+	      return;
+	    }
+	    this.ccStreams_[(packet.type << 1) + this.activeCea608Channel_[packet.type]].push(packet);
+	  };
+	  CaptionStream.prototype.setsChannel1Active = function (packet) {
+	    return (packet.ccData & 0x7800) === 0x1000;
+	  };
+	  CaptionStream.prototype.setsChannel2Active = function (packet) {
+	    return (packet.ccData & 0x7800) === 0x1800;
+	  };
+	  CaptionStream.prototype.setsTextOrXDSActive = function (packet) {
+	    return (packet.ccData & 0x7100) === 0x0100 || (packet.ccData & 0x78fe) === 0x102a || (packet.ccData & 0x78fe) === 0x182a;
+	  };
+	  CaptionStream.prototype.dispatchCea708Packet = function (packet) {
+	    if (this.parse708captions_) {
+	      this.cc708Stream_.push(packet);
+	    }
+	  };
+
+	  // ----------------------
+	  // Session to Application
+	  // ----------------------
+
+	  // This hash maps special and extended character codes to their
+	  // proper Unicode equivalent. The first one-byte key is just a
+	  // non-standard character code. The two-byte keys that follow are
+	  // the extended CEA708 character codes, along with the preceding
+	  // 0x10 extended character byte to distinguish these codes from
+	  // non-extended character codes. Every CEA708 character code that
+	  // is not in this object maps directly to a standard unicode
+	  // character code.
+	  // The transparent space and non-breaking transparent space are
+	  // technically not fully supported since there is no code to
+	  // make them transparent, so they have normal non-transparent
+	  // stand-ins.
+	  // The special closed caption (CC) character isn't a standard
+	  // unicode character, so a fairly similar unicode character was
+	  // chosen in it's place.
+	  var CHARACTER_TRANSLATION_708 = {
+	    0x7f: 0x266a,
+	    // ♪
+	    0x1020: 0x20,
+	    // Transparent Space
+	    0x1021: 0xa0,
+	    // Nob-breaking Transparent Space
+	    0x1025: 0x2026,
+	    // …
+	    0x102a: 0x0160,
+	    // Š
+	    0x102c: 0x0152,
+	    // Œ
+	    0x1030: 0x2588,
+	    // █
+	    0x1031: 0x2018,
+	    // ‘
+	    0x1032: 0x2019,
+	    // ’
+	    0x1033: 0x201c,
+	    // “
+	    0x1034: 0x201d,
+	    // ”
+	    0x1035: 0x2022,
+	    // •
+	    0x1039: 0x2122,
+	    // ™
+	    0x103a: 0x0161,
+	    // š
+	    0x103c: 0x0153,
+	    // œ
+	    0x103d: 0x2120,
+	    // ℠
+	    0x103f: 0x0178,
+	    // Ÿ
+	    0x1076: 0x215b,
+	    // ⅛
+	    0x1077: 0x215c,
+	    // ⅜
+	    0x1078: 0x215d,
+	    // ⅝
+	    0x1079: 0x215e,
+	    // ⅞
+	    0x107a: 0x23d0,
+	    // ⏐
+	    0x107b: 0x23a4,
+	    // ⎤
+	    0x107c: 0x23a3,
+	    // ⎣
+	    0x107d: 0x23af,
+	    // ⎯
+	    0x107e: 0x23a6,
+	    // ⎦
+	    0x107f: 0x23a1,
+	    // ⎡
+	    0x10a0: 0x3138 // ㄸ (CC char)
+	  };
+
+	  var get708CharFromCode = function get708CharFromCode(code) {
+	    var newCode = CHARACTER_TRANSLATION_708[code] || code;
+	    if (code & 0x1000 && code === newCode) {
+	      // Invalid extended code
+	      return '';
+	    }
+	    return String.fromCharCode(newCode);
+	  };
+	  var within708TextBlock = function within708TextBlock(b) {
+	    return 0x20 <= b && b <= 0x7f || 0xa0 <= b && b <= 0xff;
+	  };
+	  var Cea708Window = function Cea708Window(windowNum) {
+	    this.windowNum = windowNum;
+	    this.reset();
+	  };
+	  Cea708Window.prototype.reset = function () {
+	    this.clearText();
+	    this.pendingNewLine = false;
+	    this.winAttr = {};
+	    this.penAttr = {};
+	    this.penLoc = {};
+	    this.penColor = {};
+
+	    // These default values are arbitrary,
+	    // defineWindow will usually override them
+	    this.visible = 0;
+	    this.rowLock = 0;
+	    this.columnLock = 0;
+	    this.priority = 0;
+	    this.relativePositioning = 0;
+	    this.anchorVertical = 0;
+	    this.anchorHorizontal = 0;
+	    this.anchorPoint = 0;
+	    this.rowCount = 1;
+	    this.virtualRowCount = this.rowCount + 1;
+	    this.columnCount = 41;
+	    this.windowStyle = 0;
+	    this.penStyle = 0;
+	  };
+	  Cea708Window.prototype.getText = function () {
+	    return this.rows.join('\n');
+	  };
+	  Cea708Window.prototype.clearText = function () {
+	    this.rows = [''];
+	    this.rowIdx = 0;
+	  };
+	  Cea708Window.prototype.newLine = function (pts) {
+	    if (this.rows.length >= this.virtualRowCount && typeof this.beforeRowOverflow === 'function') {
+	      this.beforeRowOverflow(pts);
+	    }
+	    if (this.rows.length > 0) {
+	      this.rows.push('');
+	      this.rowIdx++;
+	    }
+
+	    // Show all virtual rows since there's no visible scrolling
+	    while (this.rows.length > this.virtualRowCount) {
+	      this.rows.shift();
+	      this.rowIdx--;
+	    }
+	  };
+	  Cea708Window.prototype.isEmpty = function () {
+	    if (this.rows.length === 0) {
+	      return true;
+	    } else if (this.rows.length === 1) {
+	      return this.rows[0] === '';
+	    }
+	    return false;
+	  };
+	  Cea708Window.prototype.addText = function (text) {
+	    this.rows[this.rowIdx] += text;
+	  };
+	  Cea708Window.prototype.backspace = function () {
+	    if (!this.isEmpty()) {
+	      var row = this.rows[this.rowIdx];
+	      this.rows[this.rowIdx] = row.substr(0, row.length - 1);
+	    }
+	  };
+	  var Cea708Service = function Cea708Service(serviceNum, encoding, stream) {
+	    this.serviceNum = serviceNum;
+	    this.text = '';
+	    this.currentWindow = new Cea708Window(-1);
+	    this.windows = [];
+	    this.stream = stream;
+
+	    // Try to setup a TextDecoder if an `encoding` value was provided
+	    if (typeof encoding === 'string') {
+	      this.createTextDecoder(encoding);
+	    }
+	  };
+
+	  /**
+	   * Initialize service windows
+	   * Must be run before service use
+	   *
+	   * @param  {Integer}  pts               PTS value
+	   * @param  {Function} beforeRowOverflow Function to execute before row overflow of a window
+	   */
+	  Cea708Service.prototype.init = function (pts, beforeRowOverflow) {
+	    this.startPts = pts;
+	    for (var win = 0; win < 8; win++) {
+	      this.windows[win] = new Cea708Window(win);
+	      if (typeof beforeRowOverflow === 'function') {
+	        this.windows[win].beforeRowOverflow = beforeRowOverflow;
+	      }
+	    }
+	  };
+
+	  /**
+	   * Set current window of service to be affected by commands
+	   *
+	   * @param  {Integer} windowNum Window number
+	   */
+	  Cea708Service.prototype.setCurrentWindow = function (windowNum) {
+	    this.currentWindow = this.windows[windowNum];
+	  };
+
+	  /**
+	   * Try to create a TextDecoder if it is natively supported
+	   */
+	  Cea708Service.prototype.createTextDecoder = function (encoding) {
+	    if (typeof TextDecoder === 'undefined') {
+	      this.stream.trigger('log', {
+	        level: 'warn',
+	        message: 'The `encoding` option is unsupported without TextDecoder support'
+	      });
+	    } else {
+	      try {
+	        this.textDecoder_ = new TextDecoder(encoding);
+	      } catch (error) {
+	        this.stream.trigger('log', {
+	          level: 'warn',
+	          message: 'TextDecoder could not be created with ' + encoding + ' encoding. ' + error
+	        });
+	      }
+	    }
+	  };
+	  var Cea708Stream = function Cea708Stream(options) {
+	    options = options || {};
+	    Cea708Stream.prototype.init.call(this);
+	    var self = this;
+	    var captionServices = options.captionServices || {};
+	    var captionServiceEncodings = {};
+	    var serviceProps;
+
+	    // Get service encodings from captionServices option block
+	    Object.keys(captionServices).forEach(function (serviceName) {
+	      serviceProps = captionServices[serviceName];
+	      if (/^SERVICE/.test(serviceName)) {
+	        captionServiceEncodings[serviceName] = serviceProps.encoding;
+	      }
+	    });
+	    this.serviceEncodings = captionServiceEncodings;
+	    this.current708Packet = null;
+	    this.services = {};
+	    this.push = function (packet) {
+	      if (packet.type === 3) {
+	        // 708 packet start
+	        self.new708Packet();
+	        self.add708Bytes(packet);
+	      } else {
+	        if (self.current708Packet === null) {
+	          // This should only happen at the start of a file if there's no packet start.
+	          self.new708Packet();
+	        }
+	        self.add708Bytes(packet);
+	      }
+	    };
+	  };
+	  Cea708Stream.prototype = new stream();
+
+	  /**
+	   * Push current 708 packet, create new 708 packet.
+	   */
+	  Cea708Stream.prototype.new708Packet = function () {
+	    if (this.current708Packet !== null) {
+	      this.push708Packet();
+	    }
+	    this.current708Packet = {
+	      data: [],
+	      ptsVals: []
+	    };
+	  };
+
+	  /**
+	   * Add pts and both bytes from packet into current 708 packet.
+	   */
+	  Cea708Stream.prototype.add708Bytes = function (packet) {
+	    var data = packet.ccData;
+	    var byte0 = data >>> 8;
+	    var byte1 = data & 0xff;
+
+	    // I would just keep a list of packets instead of bytes, but it isn't clear in the spec
+	    // that service blocks will always line up with byte pairs.
+	    this.current708Packet.ptsVals.push(packet.pts);
+	    this.current708Packet.data.push(byte0);
+	    this.current708Packet.data.push(byte1);
+	  };
+
+	  /**
+	   * Parse completed 708 packet into service blocks and push each service block.
+	   */
+	  Cea708Stream.prototype.push708Packet = function () {
+	    var packet708 = this.current708Packet;
+	    var packetData = packet708.data;
+	    var serviceNum = null;
+	    var blockSize = null;
+	    var i = 0;
+	    var b = packetData[i++];
+	    packet708.seq = b >> 6;
+	    packet708.sizeCode = b & 0x3f; // 0b00111111;
+
+	    for (; i < packetData.length; i++) {
+	      b = packetData[i++];
+	      serviceNum = b >> 5;
+	      blockSize = b & 0x1f; // 0b00011111
+
+	      if (serviceNum === 7 && blockSize > 0) {
+	        // Extended service num
+	        b = packetData[i++];
+	        serviceNum = b;
+	      }
+	      this.pushServiceBlock(serviceNum, i, blockSize);
+	      if (blockSize > 0) {
+	        i += blockSize - 1;
+	      }
+	    }
+	  };
+
+	  /**
+	   * Parse service block, execute commands, read text.
+	   *
+	   * Note: While many of these commands serve important purposes,
+	   * many others just parse out the parameters or attributes, but
+	   * nothing is done with them because this is not a full and complete
+	   * implementation of the entire 708 spec.
+	   *
+	   * @param  {Integer} serviceNum Service number
+	   * @param  {Integer} start      Start index of the 708 packet data
+	   * @param  {Integer} size       Block size
+	   */
+	  Cea708Stream.prototype.pushServiceBlock = function (serviceNum, start, size) {
+	    var b;
+	    var i = start;
+	    var packetData = this.current708Packet.data;
+	    var service = this.services[serviceNum];
+	    if (!service) {
+	      service = this.initService(serviceNum, i);
+	    }
+	    for (; i < start + size && i < packetData.length; i++) {
+	      b = packetData[i];
+	      if (within708TextBlock(b)) {
+	        i = this.handleText(i, service);
+	      } else if (b === 0x18) {
+	        i = this.multiByteCharacter(i, service);
+	      } else if (b === 0x10) {
+	        i = this.extendedCommands(i, service);
+	      } else if (0x80 <= b && b <= 0x87) {
+	        i = this.setCurrentWindow(i, service);
+	      } else if (0x98 <= b && b <= 0x9f) {
+	        i = this.defineWindow(i, service);
+	      } else if (b === 0x88) {
+	        i = this.clearWindows(i, service);
+	      } else if (b === 0x8c) {
+	        i = this.deleteWindows(i, service);
+	      } else if (b === 0x89) {
+	        i = this.displayWindows(i, service);
+	      } else if (b === 0x8a) {
+	        i = this.hideWindows(i, service);
+	      } else if (b === 0x8b) {
+	        i = this.toggleWindows(i, service);
+	      } else if (b === 0x97) {
+	        i = this.setWindowAttributes(i, service);
+	      } else if (b === 0x90) {
+	        i = this.setPenAttributes(i, service);
+	      } else if (b === 0x91) {
+	        i = this.setPenColor(i, service);
+	      } else if (b === 0x92) {
+	        i = this.setPenLocation(i, service);
+	      } else if (b === 0x8f) {
+	        service = this.reset(i, service);
+	      } else if (b === 0x08) {
+	        // BS: Backspace
+	        service.currentWindow.backspace();
+	      } else if (b === 0x0c) {
+	        // FF: Form feed
+	        service.currentWindow.clearText();
+	      } else if (b === 0x0d) {
+	        // CR: Carriage return
+	        service.currentWindow.pendingNewLine = true;
+	      } else if (b === 0x0e) {
+	        // HCR: Horizontal carriage return
+	        service.currentWindow.clearText();
+	      } else if (b === 0x8d) {
+	        // DLY: Delay, nothing to do
+	        i++;
+	      } else ;
+	    }
+	  };
+
+	  /**
+	   * Execute an extended command
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.extendedCommands = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    if (within708TextBlock(b)) {
+	      i = this.handleText(i, service, {
+	        isExtended: true
+	      });
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Get PTS value of a given byte index
+	   *
+	   * @param  {Integer} byteIndex  Index of the byte
+	   * @return {Integer}            PTS
+	   */
+	  Cea708Stream.prototype.getPts = function (byteIndex) {
+	    // There's 1 pts value per 2 bytes
+	    return this.current708Packet.ptsVals[Math.floor(byteIndex / 2)];
+	  };
+
+	  /**
+	   * Initializes a service
+	   *
+	   * @param  {Integer} serviceNum Service number
+	   * @return {Service}            Initialized service object
+	   */
+	  Cea708Stream.prototype.initService = function (serviceNum, i) {
+	    var serviceName = 'SERVICE' + serviceNum;
+	    var self = this;
+	    var serviceName;
+	    var encoding;
+	    if (serviceName in this.serviceEncodings) {
+	      encoding = this.serviceEncodings[serviceName];
+	    }
+	    this.services[serviceNum] = new Cea708Service(serviceNum, encoding, self);
+	    this.services[serviceNum].init(this.getPts(i), function (pts) {
+	      self.flushDisplayed(pts, self.services[serviceNum]);
+	    });
+	    return this.services[serviceNum];
+	  };
+
+	  /**
+	   * Execute text writing to current window
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.handleText = function (i, service, options) {
+	    var isExtended = options && options.isExtended;
+	    var isMultiByte = options && options.isMultiByte;
+	    var packetData = this.current708Packet.data;
+	    var extended = isExtended ? 0x1000 : 0x0000;
+	    var currentByte = packetData[i];
+	    var nextByte = packetData[i + 1];
+	    var win = service.currentWindow;
+	    var char;
+	    var charCodeArray;
+
+	    // Use the TextDecoder if one was created for this service
+	    if (service.textDecoder_ && !isExtended) {
+	      if (isMultiByte) {
+	        charCodeArray = [currentByte, nextByte];
+	        i++;
+	      } else {
+	        charCodeArray = [currentByte];
+	      }
+	      char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
+	    } else {
+	      char = get708CharFromCode(extended | currentByte);
+	    }
+	    if (win.pendingNewLine && !win.isEmpty()) {
+	      win.newLine(this.getPts(i));
+	    }
+	    win.pendingNewLine = false;
+	    win.addText(char);
+	    return i;
+	  };
+
+	  /**
+	   * Handle decoding of multibyte character
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.multiByteCharacter = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var firstByte = packetData[i + 1];
+	    var secondByte = packetData[i + 2];
+	    if (within708TextBlock(firstByte) && within708TextBlock(secondByte)) {
+	      i = this.handleText(++i, service, {
+	        isMultiByte: true
+	      });
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the CW# command.
+	   *
+	   * Set the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setCurrentWindow = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var windowNum = b & 0x07;
+	    service.setCurrentWindow(windowNum);
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the DF# command.
+	   *
+	   * Define a window and set it as the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.defineWindow = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var windowNum = b & 0x07;
+	    service.setCurrentWindow(windowNum);
+	    var win = service.currentWindow;
+	    b = packetData[++i];
+	    win.visible = (b & 0x20) >> 5; // v
+	    win.rowLock = (b & 0x10) >> 4; // rl
+	    win.columnLock = (b & 0x08) >> 3; // cl
+	    win.priority = b & 0x07; // p
+
+	    b = packetData[++i];
+	    win.relativePositioning = (b & 0x80) >> 7; // rp
+	    win.anchorVertical = b & 0x7f; // av
+
+	    b = packetData[++i];
+	    win.anchorHorizontal = b; // ah
+
+	    b = packetData[++i];
+	    win.anchorPoint = (b & 0xf0) >> 4; // ap
+	    win.rowCount = b & 0x0f; // rc
+
+	    b = packetData[++i];
+	    win.columnCount = b & 0x3f; // cc
+
+	    b = packetData[++i];
+	    win.windowStyle = (b & 0x38) >> 3; // ws
+	    win.penStyle = b & 0x07; // ps
+
+	    // The spec says there are (rowCount+1) "virtual rows"
+	    win.virtualRowCount = win.rowCount + 1;
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SWA command.
+	   *
+	   * Set attributes of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setWindowAttributes = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var winAttr = service.currentWindow.winAttr;
+	    b = packetData[++i];
+	    winAttr.fillOpacity = (b & 0xc0) >> 6; // fo
+	    winAttr.fillRed = (b & 0x30) >> 4; // fr
+	    winAttr.fillGreen = (b & 0x0c) >> 2; // fg
+	    winAttr.fillBlue = b & 0x03; // fb
+
+	    b = packetData[++i];
+	    winAttr.borderType = (b & 0xc0) >> 6; // bt
+	    winAttr.borderRed = (b & 0x30) >> 4; // br
+	    winAttr.borderGreen = (b & 0x0c) >> 2; // bg
+	    winAttr.borderBlue = b & 0x03; // bb
+
+	    b = packetData[++i];
+	    winAttr.borderType += (b & 0x80) >> 5; // bt
+	    winAttr.wordWrap = (b & 0x40) >> 6; // ww
+	    winAttr.printDirection = (b & 0x30) >> 4; // pd
+	    winAttr.scrollDirection = (b & 0x0c) >> 2; // sd
+	    winAttr.justify = b & 0x03; // j
+
+	    b = packetData[++i];
+	    winAttr.effectSpeed = (b & 0xf0) >> 4; // es
+	    winAttr.effectDirection = (b & 0x0c) >> 2; // ed
+	    winAttr.displayEffect = b & 0x03; // de
+
+	    return i;
+	  };
+
+	  /**
+	   * Gather text from all displayed windows and push a caption to output.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   */
+	  Cea708Stream.prototype.flushDisplayed = function (pts, service) {
+	    var displayedText = [];
+
+	    // TODO: Positioning not supported, displaying multiple windows will not necessarily
+	    // display text in the correct order, but sample files so far have not shown any issue.
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (service.windows[winId].visible && !service.windows[winId].isEmpty()) {
+	        displayedText.push(service.windows[winId].getText());
+	      }
+	    }
+	    service.endPts = pts;
+	    service.text = displayedText.join('\n\n');
+	    this.pushCaption(service);
+	    service.startPts = pts;
+	  };
+
+	  /**
+	   * Push a caption to output if the caption contains text.
+	   *
+	   * @param  {Service} service  The service object to be affected
+	   */
+	  Cea708Stream.prototype.pushCaption = function (service) {
+	    if (service.text !== '') {
+	      this.trigger('data', {
+	        startPts: service.startPts,
+	        endPts: service.endPts,
+	        text: service.text,
+	        stream: 'cc708_' + service.serviceNum
+	      });
+	      service.text = '';
+	      service.startPts = service.endPts;
+	    }
+	  };
+
+	  /**
+	   * Parse and execute the DSW command.
+	   *
+	   * Set visible property of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.displayWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].visible = 1;
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the HDW command.
+	   *
+	   * Set visible property of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.hideWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].visible = 0;
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the TGW command.
+	   *
+	   * Set visible property of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.toggleWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].visible ^= 1;
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the CLW command.
+	   *
+	   * Clear text of windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.clearWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].clearText();
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the DLW command.
+	   *
+	   * Re-initialize windows based on the parsed bitmask.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.deleteWindows = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[++i];
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    for (var winId = 0; winId < 8; winId++) {
+	      if (b & 0x01 << winId) {
+	        service.windows[winId].reset();
+	      }
+	    }
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SPA command.
+	   *
+	   * Set pen attributes of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setPenAttributes = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var penAttr = service.currentWindow.penAttr;
+	    b = packetData[++i];
+	    penAttr.textTag = (b & 0xf0) >> 4; // tt
+	    penAttr.offset = (b & 0x0c) >> 2; // o
+	    penAttr.penSize = b & 0x03; // s
+
+	    b = packetData[++i];
+	    penAttr.italics = (b & 0x80) >> 7; // i
+	    penAttr.underline = (b & 0x40) >> 6; // u
+	    penAttr.edgeType = (b & 0x38) >> 3; // et
+	    penAttr.fontStyle = b & 0x07; // fs
+
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SPC command.
+	   *
+	   * Set pen color of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setPenColor = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var penColor = service.currentWindow.penColor;
+	    b = packetData[++i];
+	    penColor.fgOpacity = (b & 0xc0) >> 6; // fo
+	    penColor.fgRed = (b & 0x30) >> 4; // fr
+	    penColor.fgGreen = (b & 0x0c) >> 2; // fg
+	    penColor.fgBlue = b & 0x03; // fb
+
+	    b = packetData[++i];
+	    penColor.bgOpacity = (b & 0xc0) >> 6; // bo
+	    penColor.bgRed = (b & 0x30) >> 4; // br
+	    penColor.bgGreen = (b & 0x0c) >> 2; // bg
+	    penColor.bgBlue = b & 0x03; // bb
+
+	    b = packetData[++i];
+	    penColor.edgeRed = (b & 0x30) >> 4; // er
+	    penColor.edgeGreen = (b & 0x0c) >> 2; // eg
+	    penColor.edgeBlue = b & 0x03; // eb
+
+	    return i;
+	  };
+
+	  /**
+	   * Parse and execute the SPL command.
+	   *
+	   * Set pen location of the current window.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Integer}          New index after parsing
+	   */
+	  Cea708Stream.prototype.setPenLocation = function (i, service) {
+	    var packetData = this.current708Packet.data;
+	    var b = packetData[i];
+	    var penLoc = service.currentWindow.penLoc;
+
+	    // Positioning isn't really supported at the moment, so this essentially just inserts a linebreak
+	    service.currentWindow.pendingNewLine = true;
+	    b = packetData[++i];
+	    penLoc.row = b & 0x0f; // r
+
+	    b = packetData[++i];
+	    penLoc.column = b & 0x3f; // c
+
+	    return i;
+	  };
+
+	  /**
+	   * Execute the RST command.
+	   *
+	   * Reset service to a clean slate. Re-initialize.
+	   *
+	   * @param  {Integer} i        Current index in the 708 packet
+	   * @param  {Service} service  The service object to be affected
+	   * @return {Service}          Re-initialized service
+	   */
+	  Cea708Stream.prototype.reset = function (i, service) {
+	    var pts = this.getPts(i);
+	    this.flushDisplayed(pts, service);
+	    return this.initService(service.serviceNum, i);
+	  };
+
+	  // This hash maps non-ASCII, special, and extended character codes to their
+	  // proper Unicode equivalent. The first keys that are only a single byte
+	  // are the non-standard ASCII characters, which simply map the CEA608 byte
+	  // to the standard ASCII/Unicode. The two-byte keys that follow are the CEA608
+	  // character codes, but have their MSB bitmasked with 0x03 so that a lookup
+	  // can be performed regardless of the field and data channel on which the
+	  // character code was received.
+	  var CHARACTER_TRANSLATION = {
+	    0x2a: 0xe1,
+	    // á
+	    0x5c: 0xe9,
+	    // é
+	    0x5e: 0xed,
+	    // í
+	    0x5f: 0xf3,
+	    // ó
+	    0x60: 0xfa,
+	    // ú
+	    0x7b: 0xe7,
+	    // ç
+	    0x7c: 0xf7,
+	    // ÷
+	    0x7d: 0xd1,
+	    // Ñ
+	    0x7e: 0xf1,
+	    // ñ
+	    0x7f: 0x2588,
+	    // █
+	    0x0130: 0xae,
+	    // ®
+	    0x0131: 0xb0,
+	    // °
+	    0x0132: 0xbd,
+	    // ½
+	    0x0133: 0xbf,
+	    // ¿
+	    0x0134: 0x2122,
+	    // ™
+	    0x0135: 0xa2,
+	    // ¢
+	    0x0136: 0xa3,
+	    // £
+	    0x0137: 0x266a,
+	    // ♪
+	    0x0138: 0xe0,
+	    // à
+	    0x0139: 0xa0,
+	    //
+	    0x013a: 0xe8,
+	    // è
+	    0x013b: 0xe2,
+	    // â
+	    0x013c: 0xea,
+	    // ê
+	    0x013d: 0xee,
+	    // î
+	    0x013e: 0xf4,
+	    // ô
+	    0x013f: 0xfb,
+	    // û
+	    0x0220: 0xc1,
+	    // Á
+	    0x0221: 0xc9,
+	    // É
+	    0x0222: 0xd3,
+	    // Ó
+	    0x0223: 0xda,
+	    // Ú
+	    0x0224: 0xdc,
+	    // Ü
+	    0x0225: 0xfc,
+	    // ü
+	    0x0226: 0x2018,
+	    // ‘
+	    0x0227: 0xa1,
+	    // ¡
+	    0x0228: 0x2a,
+	    // *
+	    0x0229: 0x27,
+	    // '
+	    0x022a: 0x2014,
+	    // —
+	    0x022b: 0xa9,
+	    // ©
+	    0x022c: 0x2120,
+	    // ℠
+	    0x022d: 0x2022,
+	    // •
+	    0x022e: 0x201c,
+	    // “
+	    0x022f: 0x201d,
+	    // ”
+	    0x0230: 0xc0,
+	    // À
+	    0x0231: 0xc2,
+	    // Â
+	    0x0232: 0xc7,
+	    // Ç
+	    0x0233: 0xc8,
+	    // È
+	    0x0234: 0xca,
+	    // Ê
+	    0x0235: 0xcb,
+	    // Ë
+	    0x0236: 0xeb,
+	    // ë
+	    0x0237: 0xce,
+	    // Î
+	    0x0238: 0xcf,
+	    // Ï
+	    0x0239: 0xef,
+	    // ï
+	    0x023a: 0xd4,
+	    // Ô
+	    0x023b: 0xd9,
+	    // Ù
+	    0x023c: 0xf9,
+	    // ù
+	    0x023d: 0xdb,
+	    // Û
+	    0x023e: 0xab,
+	    // «
+	    0x023f: 0xbb,
+	    // »
+	    0x0320: 0xc3,
+	    // Ã
+	    0x0321: 0xe3,
+	    // ã
+	    0x0322: 0xcd,
+	    // Í
+	    0x0323: 0xcc,
+	    // Ì
+	    0x0324: 0xec,
+	    // ì
+	    0x0325: 0xd2,
+	    // Ò
+	    0x0326: 0xf2,
+	    // ò
+	    0x0327: 0xd5,
+	    // Õ
+	    0x0328: 0xf5,
+	    // õ
+	    0x0329: 0x7b,
+	    // {
+	    0x032a: 0x7d,
+	    // }
+	    0x032b: 0x5c,
+	    // \
+	    0x032c: 0x5e,
+	    // ^
+	    0x032d: 0x5f,
+	    // _
+	    0x032e: 0x7c,
+	    // |
+	    0x032f: 0x7e,
+	    // ~
+	    0x0330: 0xc4,
+	    // Ä
+	    0x0331: 0xe4,
+	    // ä
+	    0x0332: 0xd6,
+	    // Ö
+	    0x0333: 0xf6,
+	    // ö
+	    0x0334: 0xdf,
+	    // ß
+	    0x0335: 0xa5,
+	    // ¥
+	    0x0336: 0xa4,
+	    // ¤
+	    0x0337: 0x2502,
+	    // │
+	    0x0338: 0xc5,
+	    // Å
+	    0x0339: 0xe5,
+	    // å
+	    0x033a: 0xd8,
+	    // Ø
+	    0x033b: 0xf8,
+	    // ø
+	    0x033c: 0x250c,
+	    // ┌
+	    0x033d: 0x2510,
+	    // ┐
+	    0x033e: 0x2514,
+	    // └
+	    0x033f: 0x2518 // ┘
+	  };
+
+	  var getCharFromCode = function getCharFromCode(code) {
+	    if (code === null) {
+	      return '';
+	    }
+	    code = CHARACTER_TRANSLATION[code] || code;
+	    return String.fromCharCode(code);
+	  };
+
+	  // the index of the last row in a CEA-608 display buffer
+	  var BOTTOM_ROW = 14;
+
+	  // This array is used for mapping PACs -> row #, since there's no way of
+	  // getting it through bit logic.
+	  var ROWS = [0x1100, 0x1120, 0x1200, 0x1220, 0x1500, 0x1520, 0x1600, 0x1620, 0x1700, 0x1720, 0x1000, 0x1300, 0x1320, 0x1400, 0x1420];
+
+	  // CEA-608 captions are rendered onto a 34x15 matrix of character
+	  // cells. The "bottom" row is the last element in the outer array.
+	  var createDisplayBuffer = function createDisplayBuffer() {
+	    var result = [],
+	      i = BOTTOM_ROW + 1;
+	    while (i--) {
+	      result.push('');
+	    }
+	    return result;
+	  };
+	  var Cea608Stream = function Cea608Stream(field, dataChannel) {
+	    Cea608Stream.prototype.init.call(this);
+	    this.field_ = field || 0;
+	    this.dataChannel_ = dataChannel || 0;
+	    this.name_ = 'CC' + ((this.field_ << 1 | this.dataChannel_) + 1);
+	    this.setConstants();
+	    this.reset();
+	    this.push = function (packet) {
+	      var data, swap, char0, char1, text;
+	      // remove the parity bits
+	      data = packet.ccData & 0x7f7f;
+
+	      // ignore duplicate control codes; the spec demands they're sent twice
+	      if (data === this.lastControlCode_) {
+	        this.lastControlCode_ = null;
+	        return;
+	      }
+
+	      // Store control codes
+	      if ((data & 0xf000) === 0x1000) {
+	        this.lastControlCode_ = data;
+	      } else if (data !== this.PADDING_) {
+	        this.lastControlCode_ = null;
+	      }
+	      char0 = data >>> 8;
+	      char1 = data & 0xff;
+	      if (data === this.PADDING_) {
+	        return;
+	      } else if (data === this.RESUME_CAPTION_LOADING_) {
+	        this.mode_ = 'popOn';
+	      } else if (data === this.END_OF_CAPTION_) {
+	        // If an EOC is received while in paint-on mode, the displayed caption
+	        // text should be swapped to non-displayed memory as if it was a pop-on
+	        // caption. Because of that, we should explicitly switch back to pop-on
+	        // mode
+	        this.mode_ = 'popOn';
+	        this.clearFormatting(packet.pts);
+	        // if a caption was being displayed, it's gone now
+	        this.flushDisplayed(packet.pts);
+
+	        // flip memory
+	        swap = this.displayed_;
+	        this.displayed_ = this.nonDisplayed_;
+	        this.nonDisplayed_ = swap;
+
+	        // start measuring the time to display the caption
+	        this.startPts_ = packet.pts;
+	      } else if (data === this.ROLL_UP_2_ROWS_) {
+	        this.rollUpRows_ = 2;
+	        this.setRollUp(packet.pts);
+	      } else if (data === this.ROLL_UP_3_ROWS_) {
+	        this.rollUpRows_ = 3;
+	        this.setRollUp(packet.pts);
+	      } else if (data === this.ROLL_UP_4_ROWS_) {
+	        this.rollUpRows_ = 4;
+	        this.setRollUp(packet.pts);
+	      } else if (data === this.CARRIAGE_RETURN_) {
+	        this.clearFormatting(packet.pts);
+	        this.flushDisplayed(packet.pts);
+	        this.shiftRowsUp_();
+	        this.startPts_ = packet.pts;
+	      } else if (data === this.BACKSPACE_) {
+	        if (this.mode_ === 'popOn') {
+	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+	        } else {
+	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+	        }
+	      } else if (data === this.ERASE_DISPLAYED_MEMORY_) {
+	        this.flushDisplayed(packet.pts);
+	        this.displayed_ = createDisplayBuffer();
+	      } else if (data === this.ERASE_NON_DISPLAYED_MEMORY_) {
+	        this.nonDisplayed_ = createDisplayBuffer();
+	      } else if (data === this.RESUME_DIRECT_CAPTIONING_) {
+	        if (this.mode_ !== 'paintOn') {
+	          // NOTE: This should be removed when proper caption positioning is
+	          // implemented
+	          this.flushDisplayed(packet.pts);
+	          this.displayed_ = createDisplayBuffer();
+	        }
+	        this.mode_ = 'paintOn';
+	        this.startPts_ = packet.pts;
+
+	        // Append special characters to caption text
+	      } else if (this.isSpecialCharacter(char0, char1)) {
+	        // Bitmask char0 so that we can apply character transformations
+	        // regardless of field and data channel.
+	        // Then byte-shift to the left and OR with char1 so we can pass the
+	        // entire character code to `getCharFromCode`.
+	        char0 = (char0 & 0x03) << 8;
+	        text = getCharFromCode(char0 | char1);
+	        this[this.mode_](packet.pts, text);
+	        this.column_++;
+
+	        // Append extended characters to caption text
+	      } else if (this.isExtCharacter(char0, char1)) {
+	        // Extended characters always follow their "non-extended" equivalents.
+	        // IE if a "è" is desired, you'll always receive "eè"; non-compliant
+	        // decoders are supposed to drop the "è", while compliant decoders
+	        // backspace the "e" and insert "è".
+
+	        // Delete the previous character
+	        if (this.mode_ === 'popOn') {
+	          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+	        } else {
+	          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+	        }
+
+	        // Bitmask char0 so that we can apply character transformations
+	        // regardless of field and data channel.
+	        // Then byte-shift to the left and OR with char1 so we can pass the
+	        // entire character code to `getCharFromCode`.
+	        char0 = (char0 & 0x03) << 8;
+	        text = getCharFromCode(char0 | char1);
+	        this[this.mode_](packet.pts, text);
+	        this.column_++;
+
+	        // Process mid-row codes
+	      } else if (this.isMidRowCode(char0, char1)) {
+	        // Attributes are not additive, so clear all formatting
+	        this.clearFormatting(packet.pts);
+
+	        // According to the standard, mid-row codes
+	        // should be replaced with spaces, so add one now
+	        this[this.mode_](packet.pts, ' ');
+	        this.column_++;
+	        if ((char1 & 0xe) === 0xe) {
+	          this.addFormatting(packet.pts, ['i']);
+	        }
+	        if ((char1 & 0x1) === 0x1) {
+	          this.addFormatting(packet.pts, ['u']);
+	        }
+
+	        // Detect offset control codes and adjust cursor
+	      } else if (this.isOffsetControlCode(char0, char1)) {
+	        // Cursor position is set by indent PAC (see below) in 4-column
+	        // increments, with an additional offset code of 1-3 to reach any
+	        // of the 32 columns specified by CEA-608. So all we need to do
+	        // here is increment the column cursor by the given offset.
+	        this.column_ += char1 & 0x03;
+
+	        // Detect PACs (Preamble Address Codes)
+	      } else if (this.isPAC(char0, char1)) {
+	        // There's no logic for PAC -> row mapping, so we have to just
+	        // find the row code in an array and use its index :(
+	        var row = ROWS.indexOf(data & 0x1f20);
+
+	        // Configure the caption window if we're in roll-up mode
+	        if (this.mode_ === 'rollUp') {
+	          // This implies that the base row is incorrectly set.
+	          // As per the recommendation in CEA-608(Base Row Implementation), defer to the number
+	          // of roll-up rows set.
+	          if (row - this.rollUpRows_ + 1 < 0) {
+	            row = this.rollUpRows_ - 1;
+	          }
+	          this.setRollUp(packet.pts, row);
+	        }
+	        if (row !== this.row_) {
+	          // formatting is only persistent for current row
+	          this.clearFormatting(packet.pts);
+	          this.row_ = row;
+	        }
+	        // All PACs can apply underline, so detect and apply
+	        // (All odd-numbered second bytes set underline)
+	        if (char1 & 0x1 && this.formatting_.indexOf('u') === -1) {
+	          this.addFormatting(packet.pts, ['u']);
+	        }
+	        if ((data & 0x10) === 0x10) {
+	          // We've got an indent level code. Each successive even number
+	          // increments the column cursor by 4, so we can get the desired
+	          // column position by bit-shifting to the right (to get n/2)
+	          // and multiplying by 4.
+	          this.column_ = ((data & 0xe) >> 1) * 4;
+	        }
+	        if (this.isColorPAC(char1)) {
+	          // it's a color code, though we only support white, which
+	          // can be either normal or italicized. white italics can be
+	          // either 0x4e or 0x6e depending on the row, so we just
+	          // bitwise-and with 0xe to see if italics should be turned on
+	          if ((char1 & 0xe) === 0xe) {
+	            this.addFormatting(packet.pts, ['i']);
+	          }
+	        }
+
+	        // We have a normal character in char0, and possibly one in char1
+	      } else if (this.isNormalChar(char0)) {
+	        if (char1 === 0x00) {
+	          char1 = null;
+	        }
+	        text = getCharFromCode(char0);
+	        text += getCharFromCode(char1);
+	        this[this.mode_](packet.pts, text);
+	        this.column_ += text.length;
+	      } // finish data processing
+	    };
+	  };
+
+	  Cea608Stream.prototype = new stream();
+	  // Trigger a cue point that captures the current state of the
+	  // display buffer
+	  Cea608Stream.prototype.flushDisplayed = function (pts) {
+	    var content = this.displayed_
+	    // remove spaces from the start and end of the string
+	    .map(function (row, index) {
+	      try {
+	        return row.trim();
+	      } catch (e) {
+	        // Ordinarily, this shouldn't happen. However, caption
+	        // parsing errors should not throw exceptions and
+	        // break playback.
+	        this.trigger('log', {
+	          level: 'warn',
+	          message: 'Skipping a malformed 608 caption at index ' + index + '.'
+	        });
+	        return '';
+	      }
+	    }, this)
+	    // combine all text rows to display in one cue
+	    .join('\n')
+	    // and remove blank rows from the start and end, but not the middle
+	    .replace(/^\n+|\n+$/g, '');
+	    if (content.length) {
+	      this.trigger('data', {
+	        startPts: this.startPts_,
+	        endPts: pts,
+	        text: content,
+	        stream: this.name_
+	      });
+	    }
+	  };
+
+	  /**
+	   * Zero out the data, used for startup and on seek
+	   */
+	  Cea608Stream.prototype.reset = function () {
+	    this.mode_ = 'popOn';
+	    // When in roll-up mode, the index of the last row that will
+	    // actually display captions. If a caption is shifted to a row
+	    // with a lower index than this, it is cleared from the display
+	    // buffer
+	    this.topRow_ = 0;
+	    this.startPts_ = 0;
+	    this.displayed_ = createDisplayBuffer();
+	    this.nonDisplayed_ = createDisplayBuffer();
+	    this.lastControlCode_ = null;
+
+	    // Track row and column for proper line-breaking and spacing
+	    this.column_ = 0;
+	    this.row_ = BOTTOM_ROW;
+	    this.rollUpRows_ = 2;
+
+	    // This variable holds currently-applied formatting
+	    this.formatting_ = [];
+	  };
+
+	  /**
+	   * Sets up control code and related constants for this instance
+	   */
+	  Cea608Stream.prototype.setConstants = function () {
+	    // The following attributes have these uses:
+	    // ext_ :    char0 for mid-row codes, and the base for extended
+	    //           chars (ext_+0, ext_+1, and ext_+2 are char0s for
+	    //           extended codes)
+	    // control_: char0 for control codes, except byte-shifted to the
+	    //           left so that we can do this.control_ | CONTROL_CODE
+	    // offset_:  char0 for tab offset codes
+	    //
+	    // It's also worth noting that control codes, and _only_ control codes,
+	    // differ between field 1 and field2. Field 2 control codes are always
+	    // their field 1 value plus 1. That's why there's the "| field" on the
+	    // control value.
+	    if (this.dataChannel_ === 0) {
+	      this.BASE_ = 0x10;
+	      this.EXT_ = 0x11;
+	      this.CONTROL_ = (0x14 | this.field_) << 8;
+	      this.OFFSET_ = 0x17;
+	    } else if (this.dataChannel_ === 1) {
+	      this.BASE_ = 0x18;
+	      this.EXT_ = 0x19;
+	      this.CONTROL_ = (0x1c | this.field_) << 8;
+	      this.OFFSET_ = 0x1f;
+	    }
+
+	    // Constants for the LSByte command codes recognized by Cea608Stream. This
+	    // list is not exhaustive. For a more comprehensive listing and semantics see
+	    // http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf
+	    // Padding
+	    this.PADDING_ = 0x0000;
+	    // Pop-on Mode
+	    this.RESUME_CAPTION_LOADING_ = this.CONTROL_ | 0x20;
+	    this.END_OF_CAPTION_ = this.CONTROL_ | 0x2f;
+	    // Roll-up Mode
+	    this.ROLL_UP_2_ROWS_ = this.CONTROL_ | 0x25;
+	    this.ROLL_UP_3_ROWS_ = this.CONTROL_ | 0x26;
+	    this.ROLL_UP_4_ROWS_ = this.CONTROL_ | 0x27;
+	    this.CARRIAGE_RETURN_ = this.CONTROL_ | 0x2d;
+	    // paint-on mode
+	    this.RESUME_DIRECT_CAPTIONING_ = this.CONTROL_ | 0x29;
+	    // Erasure
+	    this.BACKSPACE_ = this.CONTROL_ | 0x21;
+	    this.ERASE_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2c;
+	    this.ERASE_NON_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2e;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet data is a special character
+	   *
+	   * Special characters have a second byte in the range 0x30 to 0x3f,
+	   * with the first byte being 0x11 (for data channel 1) or 0x19 (for
+	   * data channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are an special character
+	   */
+	  Cea608Stream.prototype.isSpecialCharacter = function (char0, char1) {
+	    return char0 === this.EXT_ && char1 >= 0x30 && char1 <= 0x3f;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet data is an extended character
+	   *
+	   * Extended characters have a second byte in the range 0x20 to 0x3f,
+	   * with the first byte being 0x12 or 0x13 (for data channel 1) or
+	   * 0x1a or 0x1b (for data channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are an extended character
+	   */
+	  Cea608Stream.prototype.isExtCharacter = function (char0, char1) {
+	    return (char0 === this.EXT_ + 1 || char0 === this.EXT_ + 2) && char1 >= 0x20 && char1 <= 0x3f;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet is a mid-row code
+	   *
+	   * Mid-row codes have a second byte in the range 0x20 to 0x2f, with
+	   * the first byte being 0x11 (for data channel 1) or 0x19 (for data
+	   * channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are a mid-row code
+	   */
+	  Cea608Stream.prototype.isMidRowCode = function (char0, char1) {
+	    return char0 === this.EXT_ && char1 >= 0x20 && char1 <= 0x2f;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet is an offset control code
+	   *
+	   * Offset control codes have a second byte in the range 0x21 to 0x23,
+	   * with the first byte being 0x17 (for data channel 1) or 0x1f (for
+	   * data channel 2).
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are an offset control code
+	   */
+	  Cea608Stream.prototype.isOffsetControlCode = function (char0, char1) {
+	    return char0 === this.OFFSET_ && char1 >= 0x21 && char1 <= 0x23;
+	  };
+
+	  /**
+	   * Detects if the 2-byte packet is a Preamble Address Code
+	   *
+	   * PACs have a first byte in the range 0x10 to 0x17 (for data channel 1)
+	   * or 0x18 to 0x1f (for data channel 2), with the second byte in the
+	   * range 0x40 to 0x7f.
+	   *
+	   * @param  {Integer} char0 The first byte
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the 2 bytes are a PAC
+	   */
+	  Cea608Stream.prototype.isPAC = function (char0, char1) {
+	    return char0 >= this.BASE_ && char0 < this.BASE_ + 8 && char1 >= 0x40 && char1 <= 0x7f;
+	  };
+
+	  /**
+	   * Detects if a packet's second byte is in the range of a PAC color code
+	   *
+	   * PAC color codes have the second byte be in the range 0x40 to 0x4f, or
+	   * 0x60 to 0x6f.
+	   *
+	   * @param  {Integer} char1 The second byte
+	   * @return {Boolean}       Whether the byte is a color PAC
+	   */
+	  Cea608Stream.prototype.isColorPAC = function (char1) {
+	    return char1 >= 0x40 && char1 <= 0x4f || char1 >= 0x60 && char1 <= 0x7f;
+	  };
+
+	  /**
+	   * Detects if a single byte is in the range of a normal character
+	   *
+	   * Normal text bytes are in the range 0x20 to 0x7f.
+	   *
+	   * @param  {Integer} char  The byte
+	   * @return {Boolean}       Whether the byte is a normal character
+	   */
+	  Cea608Stream.prototype.isNormalChar = function (char) {
+	    return char >= 0x20 && char <= 0x7f;
+	  };
+
+	  /**
+	   * Configures roll-up
+	   *
+	   * @param  {Integer} pts         Current PTS
+	   * @param  {Integer} newBaseRow  Used by PACs to slide the current window to
+	   *                               a new position
+	   */
+	  Cea608Stream.prototype.setRollUp = function (pts, newBaseRow) {
+	    // Reset the base row to the bottom row when switching modes
+	    if (this.mode_ !== 'rollUp') {
+	      this.row_ = BOTTOM_ROW;
+	      this.mode_ = 'rollUp';
+	      // Spec says to wipe memories when switching to roll-up
+	      this.flushDisplayed(pts);
+	      this.nonDisplayed_ = createDisplayBuffer();
+	      this.displayed_ = createDisplayBuffer();
+	    }
+	    if (newBaseRow !== undefined && newBaseRow !== this.row_) {
+	      // move currently displayed captions (up or down) to the new base row
+	      for (var i = 0; i < this.rollUpRows_; i++) {
+	        this.displayed_[newBaseRow - i] = this.displayed_[this.row_ - i];
+	        this.displayed_[this.row_ - i] = '';
+	      }
+	    }
+	    if (newBaseRow === undefined) {
+	      newBaseRow = this.row_;
+	    }
+	    this.topRow_ = newBaseRow - this.rollUpRows_ + 1;
+	  };
+
+	  // Adds the opening HTML tag for the passed character to the caption text,
+	  // and keeps track of it for later closing
+	  Cea608Stream.prototype.addFormatting = function (pts, format) {
+	    this.formatting_ = this.formatting_.concat(format);
+	    var text = format.reduce(function (text, format) {
+	      return text + '<' + format + '>';
+	    }, '');
+	    this[this.mode_](pts, text);
+	  };
+
+	  // Adds HTML closing tags for current formatting to caption text and
+	  // clears remembered formatting
+	  Cea608Stream.prototype.clearFormatting = function (pts) {
+	    if (!this.formatting_.length) {
+	      return;
+	    }
+	    var text = this.formatting_.reverse().reduce(function (text, format) {
+	      return text + '</' + format + '>';
+	    }, '');
+	    this.formatting_ = [];
+	    this[this.mode_](pts, text);
+	  };
+
+	  // Mode Implementations
+	  Cea608Stream.prototype.popOn = function (pts, text) {
+	    var baseRow = this.nonDisplayed_[this.row_];
+
+	    // buffer characters
+	    baseRow += text;
+	    this.nonDisplayed_[this.row_] = baseRow;
+	  };
+	  Cea608Stream.prototype.rollUp = function (pts, text) {
+	    var baseRow = this.displayed_[this.row_];
+	    baseRow += text;
+	    this.displayed_[this.row_] = baseRow;
+	  };
+	  Cea608Stream.prototype.shiftRowsUp_ = function () {
+	    var i;
+	    // clear out inactive rows
+	    for (i = 0; i < this.topRow_; i++) {
+	      this.displayed_[i] = '';
+	    }
+	    for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {
+	      this.displayed_[i] = '';
+	    }
+	    // shift displayed rows up
+	    for (i = this.topRow_; i < this.row_; i++) {
+	      this.displayed_[i] = this.displayed_[i + 1];
+	    }
+	    // clear out the bottom row
+	    this.displayed_[this.row_] = '';
+	  };
+	  Cea608Stream.prototype.paintOn = function (pts, text) {
+	    var baseRow = this.displayed_[this.row_];
+	    baseRow += text;
+	    this.displayed_[this.row_] = baseRow;
+	  };
+
+	  // exports
+	  var captionStream = {
+	    CaptionStream: CaptionStream,
+	    Cea608Stream: Cea608Stream,
+	    Cea708Stream: Cea708Stream
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+
+	  var streamTypes = {
+	    H264_STREAM_TYPE: 0x1B,
+	    ADTS_STREAM_TYPE: 0x0F,
+	    METADATA_STREAM_TYPE: 0x15
+	  };
+
+	  var MAX_TS = 8589934592;
+	  var RO_THRESH = 4294967296;
+	  var TYPE_SHARED = 'shared';
+	  var handleRollover = function handleRollover(value, reference) {
+	    var direction = 1;
+	    if (value > reference) {
+	      // If the current timestamp value is greater than our reference timestamp and we detect a
+	      // timestamp rollover, this means the roll over is happening in the opposite direction.
+	      // Example scenario: Enter a long stream/video just after a rollover occurred. The reference
+	      // point will be set to a small number, e.g. 1. The user then seeks backwards over the
+	      // rollover point. In loading this segment, the timestamp values will be very large,
+	      // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust
+	      // the time stamp to be `value - 2^33`.
+	      direction = -1;
+	    }
+
+	    // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will
+	    // cause an incorrect adjustment.
+	    while (Math.abs(reference - value) > RO_THRESH) {
+	      value += direction * MAX_TS;
+	    }
+	    return value;
+	  };
+	  var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {
+	    var lastDTS, referenceDTS;
+	    TimestampRolloverStream.prototype.init.call(this);
+
+	    // The "shared" type is used in cases where a stream will contain muxed
+	    // video and audio. We could use `undefined` here, but having a string
+	    // makes debugging a little clearer.
+	    this.type_ = type || TYPE_SHARED;
+	    this.push = function (data) {
+	      // Any "shared" rollover streams will accept _all_ data. Otherwise,
+	      // streams will only accept data that matches their type.
+	      if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {
+	        return;
+	      }
+	      if (referenceDTS === undefined) {
+	        referenceDTS = data.dts;
+	      }
+	      data.dts = handleRollover(data.dts, referenceDTS);
+	      data.pts = handleRollover(data.pts, referenceDTS);
+	      lastDTS = data.dts;
+	      this.trigger('data', data);
+	    };
+	    this.flush = function () {
+	      referenceDTS = lastDTS;
+	      this.trigger('done');
+	    };
+	    this.endTimeline = function () {
+	      this.flush();
+	      this.trigger('endedtimeline');
+	    };
+	    this.discontinuity = function () {
+	      referenceDTS = void 0;
+	      lastDTS = void 0;
+	    };
+	    this.reset = function () {
+	      this.discontinuity();
+	      this.trigger('reset');
+	    };
+	  };
+	  TimestampRolloverStream$1.prototype = new stream();
+	  var timestampRolloverStream = {
+	    TimestampRolloverStream: TimestampRolloverStream$1,
+	    handleRollover: handleRollover
+	  };
+
+	  // IE11 doesn't support indexOf for TypedArrays.
+	  // Once IE11 support is dropped, this function should be removed.
+	  var typedArrayIndexOf$1 = function typedArrayIndexOf(typedArray, element, fromIndex) {
+	    if (!typedArray) {
+	      return -1;
+	    }
+	    var currentIndex = fromIndex;
+	    for (; currentIndex < typedArray.length; currentIndex++) {
+	      if (typedArray[currentIndex] === element) {
+	        return currentIndex;
+	      }
+	    }
+	    return -1;
+	  };
+	  var typedArray = {
+	    typedArrayIndexOf: typedArrayIndexOf$1
+	  };
+
+	  var typedArrayIndexOf = typedArray.typedArrayIndexOf,
+	    // Frames that allow different types of text encoding contain a text
+	    // encoding description byte [ID3v2.4.0 section 4.]
+	    textEncodingDescriptionByte = {
+	      Iso88591: 0x00,
+	      // ISO-8859-1, terminated with \0.
+	      Utf16: 0x01,
+	      // UTF-16 encoded Unicode BOM, terminated with \0\0
+	      Utf16be: 0x02,
+	      // UTF-16BE encoded Unicode, without BOM, terminated with \0\0
+	      Utf8: 0x03 // UTF-8 encoded Unicode, terminated with \0
+	    },
+	    // return a percent-encoded representation of the specified byte range
+	    // @see http://en.wikipedia.org/wiki/Percent-encoding 
+	    percentEncode$1 = function percentEncode(bytes, start, end) {
+	      var i,
+	        result = '';
+	      for (i = start; i < end; i++) {
+	        result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+	      }
+	      return result;
+	    },
+	    // return the string representation of the specified byte range,
+	    // interpreted as UTf-8.
+	    parseUtf8 = function parseUtf8(bytes, start, end) {
+	      return decodeURIComponent(percentEncode$1(bytes, start, end));
+	    },
+	    // return the string representation of the specified byte range,
+	    // interpreted as ISO-8859-1.
+	    parseIso88591$1 = function parseIso88591(bytes, start, end) {
+	      return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line
+	    },
+	    parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {
+	      return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+	    },
+	    frameParsers = {
+	      'APIC': function APIC(frame) {
+	        var i = 1,
+	          mimeTypeEndIndex,
+	          descriptionEndIndex,
+	          LINK_MIME_TYPE = '-->';
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+
+	        // parsing fields [ID3v2.4.0 section 4.14.]
+	        mimeTypeEndIndex = typedArrayIndexOf(frame.data, 0, i);
+	        if (mimeTypeEndIndex < 0) {
+	          // malformed frame
+	          return;
+	        }
+
+	        // parsing Mime type field (terminated with \0)
+	        frame.mimeType = parseIso88591$1(frame.data, i, mimeTypeEndIndex);
+	        i = mimeTypeEndIndex + 1;
+
+	        // parsing 1-byte Picture Type field
+	        frame.pictureType = frame.data[i];
+	        i++;
+	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, i);
+	        if (descriptionEndIndex < 0) {
+	          // malformed frame
+	          return;
+	        }
+
+	        // parsing Description field (terminated with \0)
+	        frame.description = parseUtf8(frame.data, i, descriptionEndIndex);
+	        i = descriptionEndIndex + 1;
+	        if (frame.mimeType === LINK_MIME_TYPE) {
+	          // parsing Picture Data field as URL (always represented as ISO-8859-1 [ID3v2.4.0 section 4.])
+	          frame.url = parseIso88591$1(frame.data, i, frame.data.length);
+	        } else {
+	          // parsing Picture Data field as binary data
+	          frame.pictureData = frame.data.subarray(i, frame.data.length);
+	        }
+	      },
+	      'T*': function T(frame) {
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+
+	        // parse text field, do not include null terminator in the frame value
+	        // frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
+	        frame.value = parseUtf8(frame.data, 1, frame.data.length).replace(/\0*$/, '');
+	        // text information frames supports multiple strings, stored as a terminator separated list [ID3v2.4.0 section 4.2.]
+	        frame.values = frame.value.split('\0');
+	      },
+	      'TXXX': function TXXX(frame) {
+	        var descriptionEndIndex;
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+	        if (descriptionEndIndex === -1) {
+	          return;
+	        }
+
+	        // parse the text fields
+	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+	        // do not include the null terminator in the tag value
+	        // frames that allow different types of encoding contain terminated text
+	        // [ID3v2.4.0 section 4.]
+	        frame.value = parseUtf8(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0*$/, '');
+	        frame.data = frame.value;
+	      },
+	      'W*': function W(frame) {
+	        // parse URL field; URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+	        // if the value is followed by a string termination all the following information should be ignored [ID3v2.4.0 section 4.3]
+	        frame.url = parseIso88591$1(frame.data, 0, frame.data.length).replace(/\0.*$/, '');
+	      },
+	      'WXXX': function WXXX(frame) {
+	        var descriptionEndIndex;
+	        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+	          // ignore frames with unrecognized character encodings
+	          return;
+	        }
+	        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+	        if (descriptionEndIndex === -1) {
+	          return;
+	        }
+
+	        // parse the description and URL fields
+	        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+	        // URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+	        // if the value is followed by a string termination all the following information
+	        // should be ignored [ID3v2.4.0 section 4.3]
+	        frame.url = parseIso88591$1(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0.*$/, '');
+	      },
+	      'PRIV': function PRIV(frame) {
+	        var i;
+	        for (i = 0; i < frame.data.length; i++) {
+	          if (frame.data[i] === 0) {
+	            // parse the description and URL fields
+	            frame.owner = parseIso88591$1(frame.data, 0, i);
+	            break;
+	          }
+	        }
+	        frame.privateData = frame.data.subarray(i + 1);
+	        frame.data = frame.privateData;
+	      }
+	    };
+	  var parseId3Frames = function parseId3Frames(data) {
+	    var frameSize,
+	      frameHeader,
+	      frameStart = 10,
+	      tagSize = 0,
+	      frames = [];
+
+	    // If we don't have enough data for a header, 10 bytes, 
+	    // or 'ID3' in the first 3 bytes this is not a valid ID3 tag.
+	    if (data.length < 10 || data[0] !== 'I'.charCodeAt(0) || data[1] !== 'D'.charCodeAt(0) || data[2] !== '3'.charCodeAt(0)) {
+	      return;
+	    }
+	    // the frame size is transmitted as a 28-bit integer in the
+	    // last four bytes of the ID3 header.
+	    // The most significant bit of each byte is dropped and the
+	    // results concatenated to recover the actual value.
+	    tagSize = parseSyncSafeInteger$1(data.subarray(6, 10));
+
+	    // ID3 reports the tag size excluding the header but it's more
+	    // convenient for our comparisons to include it
+	    tagSize += 10;
+	    // check bit 6 of byte 5 for the extended header flag.
+	    var hasExtendedHeader = data[5] & 0x40;
+	    if (hasExtendedHeader) {
+	      // advance the frame start past the extended header
+	      frameStart += 4; // header size field
+	      frameStart += parseSyncSafeInteger$1(data.subarray(10, 14));
+	      tagSize -= parseSyncSafeInteger$1(data.subarray(16, 20)); // clip any padding off the end
+	    }
+
+	    // parse one or more ID3 frames
+	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+	    do {
+	      // determine the number of bytes in this frame
+	      frameSize = parseSyncSafeInteger$1(data.subarray(frameStart + 4, frameStart + 8));
+	      if (frameSize < 1) {
+	        break;
+	      }
+	      frameHeader = String.fromCharCode(data[frameStart], data[frameStart + 1], data[frameStart + 2], data[frameStart + 3]);
+	      var frame = {
+	        id: frameHeader,
+	        data: data.subarray(frameStart + 10, frameStart + frameSize + 10)
+	      };
+	      frame.key = frame.id;
+
+	      // parse frame values
+	      if (frameParsers[frame.id]) {
+	        // use frame specific parser
+	        frameParsers[frame.id](frame);
+	      } else if (frame.id[0] === 'T') {
+	        // use text frame generic parser
+	        frameParsers['T*'](frame);
+	      } else if (frame.id[0] === 'W') {
+	        // use URL link frame generic parser
+	        frameParsers['W*'](frame);
+	      }
+	      frames.push(frame);
+	      frameStart += 10; // advance past the frame header
+	      frameStart += frameSize; // advance past the frame body
+	    } while (frameStart < tagSize);
+	    return frames;
+	  };
+	  var parseId3 = {
+	    parseId3Frames: parseId3Frames,
+	    parseSyncSafeInteger: parseSyncSafeInteger$1,
+	    frameParsers: frameParsers
+	  };
+
+	  var _MetadataStream;
+	  _MetadataStream = function MetadataStream(options) {
+	    var settings = {
+	        // the bytes of the program-level descriptor field in MP2T
+	        // see ISO/IEC 13818-1:2013 (E), section 2.6 "Program and
+	        // program element descriptors"
+	        descriptor: options && options.descriptor
+	      },
+	      // the total size in bytes of the ID3 tag being parsed
+	      tagSize = 0,
+	      // tag data that is not complete enough to be parsed
+	      buffer = [],
+	      // the total number of bytes currently in the buffer
+	      bufferSize = 0,
+	      i;
+	    _MetadataStream.prototype.init.call(this);
+
+	    // calculate the text track in-band metadata track dispatch type
+	    // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
+	    this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);
+	    if (settings.descriptor) {
+	      for (i = 0; i < settings.descriptor.length; i++) {
+	        this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);
+	      }
+	    }
+	    this.push = function (chunk) {
+	      var tag, frameStart, frameSize, frame, i, frameHeader;
+	      if (chunk.type !== 'timed-metadata') {
+	        return;
+	      }
+
+	      // if data_alignment_indicator is set in the PES header,
+	      // we must have the start of a new ID3 tag. Assume anything
+	      // remaining in the buffer was malformed and throw it out
+	      if (chunk.dataAlignmentIndicator) {
+	        bufferSize = 0;
+	        buffer.length = 0;
+	      }
+
+	      // ignore events that don't look like ID3 data
+	      if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {
+	        this.trigger('log', {
+	          level: 'warn',
+	          message: 'Skipping unrecognized metadata packet'
+	        });
+	        return;
+	      }
+
+	      // add this chunk to the data we've collected so far
+
+	      buffer.push(chunk);
+	      bufferSize += chunk.data.byteLength;
+
+	      // grab the size of the entire frame from the ID3 header
+	      if (buffer.length === 1) {
+	        // the frame size is transmitted as a 28-bit integer in the
+	        // last four bytes of the ID3 header.
+	        // The most significant bit of each byte is dropped and the
+	        // results concatenated to recover the actual value.
+	        tagSize = parseId3.parseSyncSafeInteger(chunk.data.subarray(6, 10));
+
+	        // ID3 reports the tag size excluding the header but it's more
+	        // convenient for our comparisons to include it
+	        tagSize += 10;
+	      }
+
+	      // if the entire frame has not arrived, wait for more data
+	      if (bufferSize < tagSize) {
+	        return;
+	      }
+
+	      // collect the entire frame so it can be parsed
+	      tag = {
+	        data: new Uint8Array(tagSize),
+	        frames: [],
+	        pts: buffer[0].pts,
+	        dts: buffer[0].dts
+	      };
+	      for (i = 0; i < tagSize;) {
+	        tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);
+	        i += buffer[0].data.byteLength;
+	        bufferSize -= buffer[0].data.byteLength;
+	        buffer.shift();
+	      }
+
+	      // find the start of the first frame and the end of the tag
+	      frameStart = 10;
+	      if (tag.data[5] & 0x40) {
+	        // advance the frame start past the extended header
+	        frameStart += 4; // header size field
+	        frameStart += parseId3.parseSyncSafeInteger(tag.data.subarray(10, 14));
+
+	        // clip any padding off the end
+	        tagSize -= parseId3.parseSyncSafeInteger(tag.data.subarray(16, 20));
+	      }
+
+	      // parse one or more ID3 frames
+	      // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+	      do {
+	        // determine the number of bytes in this frame
+	        frameSize = parseId3.parseSyncSafeInteger(tag.data.subarray(frameStart + 4, frameStart + 8));
+	        if (frameSize < 1) {
+	          this.trigger('log', {
+	            level: 'warn',
+	            message: 'Malformed ID3 frame encountered. Skipping remaining metadata parsing.'
+	          });
+	          // If the frame is malformed, don't parse any further frames but allow previous valid parsed frames
+	          // to be sent along.
+	          break;
+	        }
+	        frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);
+	        frame = {
+	          id: frameHeader,
+	          data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)
+	        };
+	        frame.key = frame.id;
+
+	        // parse frame values
+	        if (parseId3.frameParsers[frame.id]) {
+	          // use frame specific parser
+	          parseId3.frameParsers[frame.id](frame);
+	        } else if (frame.id[0] === 'T') {
+	          // use text frame generic parser
+	          parseId3.frameParsers['T*'](frame);
+	        } else if (frame.id[0] === 'W') {
+	          // use URL link frame generic parser
+	          parseId3.frameParsers['W*'](frame);
+	        }
+
+	        // handle the special PRIV frame used to indicate the start
+	        // time for raw AAC data
+	        if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {
+	          var d = frame.data,
+	            size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+	          size *= 4;
+	          size += d[7] & 0x03;
+	          frame.timeStamp = size;
+	          // in raw AAC, all subsequent data will be timestamped based
+	          // on the value of this frame
+	          // we couldn't have known the appropriate pts and dts before
+	          // parsing this ID3 tag so set those values now
+	          if (tag.pts === undefined && tag.dts === undefined) {
+	            tag.pts = frame.timeStamp;
+	            tag.dts = frame.timeStamp;
+	          }
+	          this.trigger('timestamp', frame);
+	        }
+	        tag.frames.push(frame);
+	        frameStart += 10; // advance past the frame header
+	        frameStart += frameSize; // advance past the frame body
+	      } while (frameStart < tagSize);
+	      this.trigger('data', tag);
+	    };
+	  };
+	  _MetadataStream.prototype = new stream();
+	  var metadataStream = _MetadataStream;
+
+	  var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream;
+
+	  // object types
+	  var _TransportPacketStream, _TransportParseStream, _ElementaryStream;
+
+	  // constants
+	  var MP2T_PACKET_LENGTH = 188,
+	    // bytes
+	    SYNC_BYTE = 0x47;
+
+	  /**
+	   * Splits an incoming stream of binary data into MPEG-2 Transport
+	   * Stream packets.
+	   */
+	  _TransportPacketStream = function TransportPacketStream() {
+	    var buffer = new Uint8Array(MP2T_PACKET_LENGTH),
+	      bytesInBuffer = 0;
+	    _TransportPacketStream.prototype.init.call(this);
+
+	    // Deliver new bytes to the stream.
+
+	    /**
+	     * Split a stream of data into M2TS packets
+	    **/
+	    this.push = function (bytes) {
+	      var startIndex = 0,
+	        endIndex = MP2T_PACKET_LENGTH,
+	        everything;
+
+	      // If there are bytes remaining from the last segment, prepend them to the
+	      // bytes that were pushed in
+	      if (bytesInBuffer) {
+	        everything = new Uint8Array(bytes.byteLength + bytesInBuffer);
+	        everything.set(buffer.subarray(0, bytesInBuffer));
+	        everything.set(bytes, bytesInBuffer);
+	        bytesInBuffer = 0;
+	      } else {
+	        everything = bytes;
+	      }
+
+	      // While we have enough data for a packet
+	      while (endIndex < everything.byteLength) {
+	        // Look for a pair of start and end sync bytes in the data..
+	        if (everything[startIndex] === SYNC_BYTE && everything[endIndex] === SYNC_BYTE) {
+	          // We found a packet so emit it and jump one whole packet forward in
+	          // the stream
+	          this.trigger('data', everything.subarray(startIndex, endIndex));
+	          startIndex += MP2T_PACKET_LENGTH;
+	          endIndex += MP2T_PACKET_LENGTH;
+	          continue;
+	        }
+	        // If we get here, we have somehow become de-synchronized and we need to step
+	        // forward one byte at a time until we find a pair of sync bytes that denote
+	        // a packet
+	        startIndex++;
+	        endIndex++;
+	      }
+
+	      // If there was some data left over at the end of the segment that couldn't
+	      // possibly be a whole packet, keep it because it might be the start of a packet
+	      // that continues in the next segment
+	      if (startIndex < everything.byteLength) {
+	        buffer.set(everything.subarray(startIndex), 0);
+	        bytesInBuffer = everything.byteLength - startIndex;
+	      }
+	    };
+
+	    /**
+	     * Passes identified M2TS packets to the TransportParseStream to be parsed
+	    **/
+	    this.flush = function () {
+	      // If the buffer contains a whole packet when we are being flushed, emit it
+	      // and empty the buffer. Otherwise hold onto the data because it may be
+	      // important for decoding the next segment
+	      if (bytesInBuffer === MP2T_PACKET_LENGTH && buffer[0] === SYNC_BYTE) {
+	        this.trigger('data', buffer);
+	        bytesInBuffer = 0;
+	      }
+	      this.trigger('done');
+	    };
+	    this.endTimeline = function () {
+	      this.flush();
+	      this.trigger('endedtimeline');
+	    };
+	    this.reset = function () {
+	      bytesInBuffer = 0;
+	      this.trigger('reset');
+	    };
+	  };
+	  _TransportPacketStream.prototype = new stream();
+
+	  /**
+	   * Accepts an MP2T TransportPacketStream and emits data events with parsed
+	   * forms of the individual transport stream packets.
+	   */
+	  _TransportParseStream = function TransportParseStream() {
+	    var parsePsi, parsePat, parsePmt, self;
+	    _TransportParseStream.prototype.init.call(this);
+	    self = this;
+	    this.packetsWaitingForPmt = [];
+	    this.programMapTable = undefined;
+	    parsePsi = function parsePsi(payload, psi) {
+	      var offset = 0;
+
+	      // PSI packets may be split into multiple sections and those
+	      // sections may be split into multiple packets. If a PSI
+	      // section starts in this packet, the payload_unit_start_indicator
+	      // will be true and the first byte of the payload will indicate
+	      // the offset from the current position to the start of the
+	      // section.
+	      if (psi.payloadUnitStartIndicator) {
+	        offset += payload[offset] + 1;
+	      }
+	      if (psi.type === 'pat') {
+	        parsePat(payload.subarray(offset), psi);
+	      } else {
+	        parsePmt(payload.subarray(offset), psi);
+	      }
+	    };
+	    parsePat = function parsePat(payload, pat) {
+	      pat.section_number = payload[7]; // eslint-disable-line camelcase
+	      pat.last_section_number = payload[8]; // eslint-disable-line camelcase
+
+	      // skip the PSI header and parse the first PMT entry
+	      self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];
+	      pat.pmtPid = self.pmtPid;
+	    };
+
+	    /**
+	     * Parse out the relevant fields of a Program Map Table (PMT).
+	     * @param payload {Uint8Array} the PMT-specific portion of an MP2T
+	     * packet. The first byte in this array should be the table_id
+	     * field.
+	     * @param pmt {object} the object that should be decorated with
+	     * fields parsed from the PMT.
+	     */
+	    parsePmt = function parsePmt(payload, pmt) {
+	      var sectionLength, tableEnd, programInfoLength, offset;
+
+	      // PMTs can be sent ahead of the time when they should actually
+	      // take effect. We don't believe this should ever be the case
+	      // for HLS but we'll ignore "forward" PMT declarations if we see
+	      // them. Future PMT declarations have the current_next_indicator
+	      // set to zero.
+	      if (!(payload[5] & 0x01)) {
+	        return;
+	      }
+
+	      // overwrite any existing program map table
+	      self.programMapTable = {
+	        video: null,
+	        audio: null,
+	        'timed-metadata': {}
+	      };
+
+	      // the mapping table ends at the end of the current section
+	      sectionLength = (payload[1] & 0x0f) << 8 | payload[2];
+	      tableEnd = 3 + sectionLength - 4;
+
+	      // to determine where the table is, we have to figure out how
+	      // long the program info descriptors are
+	      programInfoLength = (payload[10] & 0x0f) << 8 | payload[11];
+
+	      // advance the offset to the first entry in the mapping table
+	      offset = 12 + programInfoLength;
+	      while (offset < tableEnd) {
+	        var streamType = payload[offset];
+	        var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2];
+
+	        // only map a single elementary_pid for audio and video stream types
+	        // TODO: should this be done for metadata too? for now maintain behavior of
+	        //       multiple metadata streams
+	        if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {
+	          self.programMapTable.video = pid;
+	        } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {
+	          self.programMapTable.audio = pid;
+	        } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {
+	          // map pid to stream type for metadata streams
+	          self.programMapTable['timed-metadata'][pid] = streamType;
+	        }
+
+	        // move to the next table entry
+	        // skip past the elementary stream descriptors, if present
+	        offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;
+	      }
+
+	      // record the map on the packet as well
+	      pmt.programMapTable = self.programMapTable;
+	    };
+
+	    /**
+	     * Deliver a new MP2T packet to the next stream in the pipeline.
+	     */
+	    this.push = function (packet) {
+	      var result = {},
+	        offset = 4;
+	      result.payloadUnitStartIndicator = !!(packet[1] & 0x40);
+
+	      // pid is a 13-bit field starting at the last bit of packet[1]
+	      result.pid = packet[1] & 0x1f;
+	      result.pid <<= 8;
+	      result.pid |= packet[2];
+
+	      // if an adaption field is present, its length is specified by the
+	      // fifth byte of the TS packet header. The adaptation field is
+	      // used to add stuffing to PES packets that don't fill a complete
+	      // TS packet, and to specify some forms of timing and control data
+	      // that we do not currently use.
+	      if ((packet[3] & 0x30) >>> 4 > 0x01) {
+	        offset += packet[offset] + 1;
+	      }
+
+	      // parse the rest of the packet based on the type
+	      if (result.pid === 0) {
+	        result.type = 'pat';
+	        parsePsi(packet.subarray(offset), result);
+	        this.trigger('data', result);
+	      } else if (result.pid === this.pmtPid) {
+	        result.type = 'pmt';
+	        parsePsi(packet.subarray(offset), result);
+	        this.trigger('data', result);
+
+	        // if there are any packets waiting for a PMT to be found, process them now
+	        while (this.packetsWaitingForPmt.length) {
+	          this.processPes_.apply(this, this.packetsWaitingForPmt.shift());
+	        }
+	      } else if (this.programMapTable === undefined) {
+	        // When we have not seen a PMT yet, defer further processing of
+	        // PES packets until one has been parsed
+	        this.packetsWaitingForPmt.push([packet, offset, result]);
+	      } else {
+	        this.processPes_(packet, offset, result);
+	      }
+	    };
+	    this.processPes_ = function (packet, offset, result) {
+	      // set the appropriate stream type
+	      if (result.pid === this.programMapTable.video) {
+	        result.streamType = streamTypes.H264_STREAM_TYPE;
+	      } else if (result.pid === this.programMapTable.audio) {
+	        result.streamType = streamTypes.ADTS_STREAM_TYPE;
+	      } else {
+	        // if not video or audio, it is timed-metadata or unknown
+	        // if unknown, streamType will be undefined
+	        result.streamType = this.programMapTable['timed-metadata'][result.pid];
+	      }
+	      result.type = 'pes';
+	      result.data = packet.subarray(offset);
+	      this.trigger('data', result);
+	    };
+	  };
+	  _TransportParseStream.prototype = new stream();
+	  _TransportParseStream.STREAM_TYPES = {
+	    h264: 0x1b,
+	    adts: 0x0f
+	  };
+
+	  /**
+	   * Reconsistutes program elementary stream (PES) packets from parsed
+	   * transport stream packets. That is, if you pipe an
+	   * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output
+	   * events will be events which capture the bytes for individual PES
+	   * packets plus relevant metadata that has been extracted from the
+	   * container.
+	   */
+	  _ElementaryStream = function ElementaryStream() {
+	    var self = this,
+	      segmentHadPmt = false,
+	      // PES packet fragments
+	      video = {
+	        data: [],
+	        size: 0
+	      },
+	      audio = {
+	        data: [],
+	        size: 0
+	      },
+	      timedMetadata = {
+	        data: [],
+	        size: 0
+	      },
+	      programMapTable,
+	      parsePes = function parsePes(payload, pes) {
+	        var ptsDtsFlags;
+	        var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2];
+	        // default to an empty array
+	        pes.data = new Uint8Array();
+	        // In certain live streams, the start of a TS fragment has ts packets
+	        // that are frame data that is continuing from the previous fragment. This
+	        // is to check that the pes data is the start of a new pes payload
+	        if (startPrefix !== 1) {
+	          return;
+	        }
+	        // get the packet length, this will be 0 for video
+	        pes.packetLength = 6 + (payload[4] << 8 | payload[5]);
+
+	        // find out if this packets starts a new keyframe
+	        pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0;
+	        // PES packets may be annotated with a PTS value, or a PTS value
+	        // and a DTS value. Determine what combination of values is
+	        // available to work with.
+	        ptsDtsFlags = payload[7];
+
+	        // PTS and DTS are normally stored as a 33-bit number.  Javascript
+	        // performs all bitwise operations on 32-bit integers but javascript
+	        // supports a much greater range (52-bits) of integer using standard
+	        // mathematical operations.
+	        // We construct a 31-bit value using bitwise operators over the 31
+	        // most significant bits and then multiply by 4 (equal to a left-shift
+	        // of 2) before we add the final 2 least significant bits of the
+	        // timestamp (equal to an OR.)
+	        if (ptsDtsFlags & 0xC0) {
+	          // the PTS and DTS are not written out directly. For information
+	          // on how they are encoded, see
+	          // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
+	          pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;
+	          pes.pts *= 4; // Left shift by 2
+	          pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs
+	          pes.dts = pes.pts;
+	          if (ptsDtsFlags & 0x40) {
+	            pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;
+	            pes.dts *= 4; // Left shift by 2
+	            pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs
+	          }
+	        }
+	        // the data section starts immediately after the PES header.
+	        // pes_header_data_length specifies the number of header bytes
+	        // that follow the last byte of the field.
+	        pes.data = payload.subarray(9 + payload[8]);
+	      },
+	      /**
+	        * Pass completely parsed PES packets to the next stream in the pipeline
+	       **/
+	      flushStream = function flushStream(stream, type, forceFlush) {
+	        var packetData = new Uint8Array(stream.size),
+	          event = {
+	            type: type
+	          },
+	          i = 0,
+	          offset = 0,
+	          packetFlushable = false,
+	          fragment;
+
+	        // do nothing if there is not enough buffered data for a complete
+	        // PES header
+	        if (!stream.data.length || stream.size < 9) {
+	          return;
+	        }
+	        event.trackId = stream.data[0].pid;
+
+	        // reassemble the packet
+	        for (i = 0; i < stream.data.length; i++) {
+	          fragment = stream.data[i];
+	          packetData.set(fragment.data, offset);
+	          offset += fragment.data.byteLength;
+	        }
+
+	        // parse assembled packet's PES header
+	        parsePes(packetData, event);
+
+	        // non-video PES packets MUST have a non-zero PES_packet_length
+	        // check that there is enough stream data to fill the packet
+	        packetFlushable = type === 'video' || event.packetLength <= stream.size;
+
+	        // flush pending packets if the conditions are right
+	        if (forceFlush || packetFlushable) {
+	          stream.size = 0;
+	          stream.data.length = 0;
+	        }
+
+	        // only emit packets that are complete. this is to avoid assembling
+	        // incomplete PES packets due to poor segmentation
+	        if (packetFlushable) {
+	          self.trigger('data', event);
+	        }
+	      };
+	    _ElementaryStream.prototype.init.call(this);
+
+	    /**
+	     * Identifies M2TS packet types and parses PES packets using metadata
+	     * parsed from the PMT
+	     **/
+	    this.push = function (data) {
+	      ({
+	        pat: function pat() {
+	          // we have to wait for the PMT to arrive as well before we
+	          // have any meaningful metadata
+	        },
+	        pes: function pes() {
+	          var stream, streamType;
+	          switch (data.streamType) {
+	            case streamTypes.H264_STREAM_TYPE:
+	              stream = video;
+	              streamType = 'video';
+	              break;
+	            case streamTypes.ADTS_STREAM_TYPE:
+	              stream = audio;
+	              streamType = 'audio';
+	              break;
+	            case streamTypes.METADATA_STREAM_TYPE:
+	              stream = timedMetadata;
+	              streamType = 'timed-metadata';
+	              break;
+	            default:
+	              // ignore unknown stream types
+	              return;
+	          }
+
+	          // if a new packet is starting, we can flush the completed
+	          // packet
+	          if (data.payloadUnitStartIndicator) {
+	            flushStream(stream, streamType, true);
+	          }
+
+	          // buffer this fragment until we are sure we've received the
+	          // complete payload
+	          stream.data.push(data);
+	          stream.size += data.data.byteLength;
+	        },
+	        pmt: function pmt() {
+	          var event = {
+	            type: 'metadata',
+	            tracks: []
+	          };
+	          programMapTable = data.programMapTable;
+
+	          // translate audio and video streams to tracks
+	          if (programMapTable.video !== null) {
+	            event.tracks.push({
+	              timelineStartInfo: {
+	                baseMediaDecodeTime: 0
+	              },
+	              id: +programMapTable.video,
+	              codec: 'avc',
+	              type: 'video'
+	            });
+	          }
+	          if (programMapTable.audio !== null) {
+	            event.tracks.push({
+	              timelineStartInfo: {
+	                baseMediaDecodeTime: 0
+	              },
+	              id: +programMapTable.audio,
+	              codec: 'adts',
+	              type: 'audio'
+	            });
+	          }
+	          segmentHadPmt = true;
+	          self.trigger('data', event);
+	        }
+	      })[data.type]();
+	    };
+	    this.reset = function () {
+	      video.size = 0;
+	      video.data.length = 0;
+	      audio.size = 0;
+	      audio.data.length = 0;
+	      this.trigger('reset');
+	    };
+
+	    /**
+	     * Flush any remaining input. Video PES packets may be of variable
+	     * length. Normally, the start of a new video packet can trigger the
+	     * finalization of the previous packet. That is not possible if no
+	     * more video is forthcoming, however. In that case, some other
+	     * mechanism (like the end of the file) has to be employed. When it is
+	     * clear that no additional data is forthcoming, calling this method
+	     * will flush the buffered packets.
+	     */
+	    this.flushStreams_ = function () {
+	      // !!THIS ORDER IS IMPORTANT!!
+	      // video first then audio
+	      flushStream(video, 'video');
+	      flushStream(audio, 'audio');
+	      flushStream(timedMetadata, 'timed-metadata');
+	    };
+	    this.flush = function () {
+	      // if on flush we haven't had a pmt emitted
+	      // and we have a pmt to emit. emit the pmt
+	      // so that we trigger a trackinfo downstream.
+	      if (!segmentHadPmt && programMapTable) {
+	        var pmt = {
+	          type: 'metadata',
+	          tracks: []
+	        };
+	        // translate audio and video streams to tracks
+	        if (programMapTable.video !== null) {
+	          pmt.tracks.push({
+	            timelineStartInfo: {
+	              baseMediaDecodeTime: 0
+	            },
+	            id: +programMapTable.video,
+	            codec: 'avc',
+	            type: 'video'
+	          });
+	        }
+	        if (programMapTable.audio !== null) {
+	          pmt.tracks.push({
+	            timelineStartInfo: {
+	              baseMediaDecodeTime: 0
+	            },
+	            id: +programMapTable.audio,
+	            codec: 'adts',
+	            type: 'audio'
+	          });
+	        }
+	        self.trigger('data', pmt);
+	      }
+	      segmentHadPmt = false;
+	      this.flushStreams_();
+	      this.trigger('done');
+	    };
+	  };
+	  _ElementaryStream.prototype = new stream();
+	  var m2ts = {
+	    PAT_PID: 0x0000,
+	    MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH,
+	    TransportPacketStream: _TransportPacketStream,
+	    TransportParseStream: _TransportParseStream,
+	    ElementaryStream: _ElementaryStream,
+	    TimestampRolloverStream: TimestampRolloverStream,
+	    CaptionStream: captionStream.CaptionStream,
+	    Cea608Stream: captionStream.Cea608Stream,
+	    Cea708Stream: captionStream.Cea708Stream,
+	    MetadataStream: metadataStream
+	  };
+	  for (var type in streamTypes) {
+	    if (streamTypes.hasOwnProperty(type)) {
+	      m2ts[type] = streamTypes[type];
+	    }
+	  }
+	  var m2ts_1 = m2ts;
+
+	  var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;
+	  var _AdtsStream;
+	  var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+
+	  /*
+	   * Accepts a ElementaryStream and emits data events with parsed
+	   * AAC Audio Frames of the individual packets. Input audio in ADTS
+	   * format is unpacked and re-emitted as AAC frames.
+	   *
+	   * @see http://wiki.multimedia.cx/index.php?title=ADTS
+	   * @see http://wiki.multimedia.cx/?title=Understanding_AAC
+	   */
+	  _AdtsStream = function AdtsStream(handlePartialSegments) {
+	    var buffer,
+	      frameNum = 0;
+	    _AdtsStream.prototype.init.call(this);
+	    this.skipWarn_ = function (start, end) {
+	      this.trigger('log', {
+	        level: 'warn',
+	        message: "adts skiping bytes " + start + " to " + end + " in frame " + frameNum + " outside syncword"
+	      });
+	    };
+	    this.push = function (packet) {
+	      var i = 0,
+	        frameLength,
+	        protectionSkipBytes,
+	        oldBuffer,
+	        sampleCount,
+	        adtsFrameDuration;
+	      if (!handlePartialSegments) {
+	        frameNum = 0;
+	      }
+	      if (packet.type !== 'audio') {
+	        // ignore non-audio data
+	        return;
+	      }
+
+	      // Prepend any data in the buffer to the input data so that we can parse
+	      // aac frames the cross a PES packet boundary
+	      if (buffer && buffer.length) {
+	        oldBuffer = buffer;
+	        buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);
+	        buffer.set(oldBuffer);
+	        buffer.set(packet.data, oldBuffer.byteLength);
+	      } else {
+	        buffer = packet.data;
+	      }
+
+	      // unpack any ADTS frames which have been fully received
+	      // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS
+	      var skip;
+
+	      // We use i + 7 here because we want to be able to parse the entire header.
+	      // If we don't have enough bytes to do that, then we definitely won't have a full frame.
+	      while (i + 7 < buffer.length) {
+	        // Look for the start of an ADTS header..
+	        if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {
+	          if (typeof skip !== 'number') {
+	            skip = i;
+	          }
+	          // If a valid header was not found,  jump one forward and attempt to
+	          // find a valid ADTS header starting at the next byte
+	          i++;
+	          continue;
+	        }
+	        if (typeof skip === 'number') {
+	          this.skipWarn_(skip, i);
+	          skip = null;
+	        }
+
+	        // The protection skip bit tells us if we have 2 bytes of CRC data at the
+	        // end of the ADTS header
+	        protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2;
+
+	        // Frame length is a 13 bit integer starting 16 bits from the
+	        // end of the sync sequence
+	        // NOTE: frame length includes the size of the header
+	        frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;
+	        sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;
+	        adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$1 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2];
+
+	        // If we don't have enough data to actually finish this ADTS frame,
+	        // then we have to wait for more data
+	        if (buffer.byteLength - i < frameLength) {
+	          break;
+	        }
+
+	        // Otherwise, deliver the complete AAC frame
+	        this.trigger('data', {
+	          pts: packet.pts + frameNum * adtsFrameDuration,
+	          dts: packet.dts + frameNum * adtsFrameDuration,
+	          sampleCount: sampleCount,
+	          audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,
+	          channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,
+	          samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],
+	          samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,
+	          // assume ISO/IEC 14496-12 AudioSampleEntry default of 16
+	          samplesize: 16,
+	          // data is the frame without it's header
+	          data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)
+	        });
+	        frameNum++;
+	        i += frameLength;
+	      }
+	      if (typeof skip === 'number') {
+	        this.skipWarn_(skip, i);
+	        skip = null;
+	      }
+
+	      // remove processed bytes from the buffer.
+	      buffer = buffer.subarray(i);
+	    };
+	    this.flush = function () {
+	      frameNum = 0;
+	      this.trigger('done');
+	    };
+	    this.reset = function () {
+	      buffer = void 0;
+	      this.trigger('reset');
+	    };
+	    this.endTimeline = function () {
+	      buffer = void 0;
+	      this.trigger('endedtimeline');
+	    };
+	  };
+	  _AdtsStream.prototype = new stream();
+	  var adts = _AdtsStream;
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   */
+
+	  var ExpGolomb;
+
+	  /**
+	   * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+	   * scheme used by h264.
+	   */
+	  ExpGolomb = function ExpGolomb(workingData) {
+	    var
+	      // the number of bytes left to examine in workingData
+	      workingBytesAvailable = workingData.byteLength,
+	      // the current word being examined
+	      workingWord = 0,
+	      // :uint
+
+	      // the number of bits left to examine in the current word
+	      workingBitsAvailable = 0; // :uint;
+
+	    // ():uint
+	    this.length = function () {
+	      return 8 * workingBytesAvailable;
+	    };
+
+	    // ():uint
+	    this.bitsAvailable = function () {
+	      return 8 * workingBytesAvailable + workingBitsAvailable;
+	    };
+
+	    // ():void
+	    this.loadWord = function () {
+	      var position = workingData.byteLength - workingBytesAvailable,
+	        workingBytes = new Uint8Array(4),
+	        availableBytes = Math.min(4, workingBytesAvailable);
+	      if (availableBytes === 0) {
+	        throw new Error('no bytes available');
+	      }
+	      workingBytes.set(workingData.subarray(position, position + availableBytes));
+	      workingWord = new DataView(workingBytes.buffer).getUint32(0);
+
+	      // track the amount of workingData that has been processed
+	      workingBitsAvailable = availableBytes * 8;
+	      workingBytesAvailable -= availableBytes;
+	    };
+
+	    // (count:int):void
+	    this.skipBits = function (count) {
+	      var skipBytes; // :int
+	      if (workingBitsAvailable > count) {
+	        workingWord <<= count;
+	        workingBitsAvailable -= count;
+	      } else {
+	        count -= workingBitsAvailable;
+	        skipBytes = Math.floor(count / 8);
+	        count -= skipBytes * 8;
+	        workingBytesAvailable -= skipBytes;
+	        this.loadWord();
+	        workingWord <<= count;
+	        workingBitsAvailable -= count;
+	      }
+	    };
+
+	    // (size:int):uint
+	    this.readBits = function (size) {
+	      var bits = Math.min(workingBitsAvailable, size),
+	        // :uint
+	        valu = workingWord >>> 32 - bits; // :uint
+	      // if size > 31, handle error
+	      workingBitsAvailable -= bits;
+	      if (workingBitsAvailable > 0) {
+	        workingWord <<= bits;
+	      } else if (workingBytesAvailable > 0) {
+	        this.loadWord();
+	      }
+	      bits = size - bits;
+	      if (bits > 0) {
+	        return valu << bits | this.readBits(bits);
+	      }
+	      return valu;
+	    };
+
+	    // ():uint
+	    this.skipLeadingZeros = function () {
+	      var leadingZeroCount; // :uint
+	      for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {
+	        if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {
+	          // the first bit of working word is 1
+	          workingWord <<= leadingZeroCount;
+	          workingBitsAvailable -= leadingZeroCount;
+	          return leadingZeroCount;
+	        }
+	      }
+
+	      // we exhausted workingWord and still have not found a 1
+	      this.loadWord();
+	      return leadingZeroCount + this.skipLeadingZeros();
+	    };
+
+	    // ():void
+	    this.skipUnsignedExpGolomb = function () {
+	      this.skipBits(1 + this.skipLeadingZeros());
+	    };
+
+	    // ():void
+	    this.skipExpGolomb = function () {
+	      this.skipBits(1 + this.skipLeadingZeros());
+	    };
+
+	    // ():uint
+	    this.readUnsignedExpGolomb = function () {
+	      var clz = this.skipLeadingZeros(); // :uint
+	      return this.readBits(clz + 1) - 1;
+	    };
+
+	    // ():int
+	    this.readExpGolomb = function () {
+	      var valu = this.readUnsignedExpGolomb(); // :int
+	      if (0x01 & valu) {
+	        // the number is odd if the low order bit is set
+	        return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
+	      }
+
+	      return -1 * (valu >>> 1); // divide by two then make it negative
+	    };
+
+	    // Some convenience functions
+	    // :Boolean
+	    this.readBoolean = function () {
+	      return this.readBits(1) === 1;
+	    };
+
+	    // ():int
+	    this.readUnsignedByte = function () {
+	      return this.readBits(8);
+	    };
+	    this.loadWord();
+	  };
+	  var expGolomb = ExpGolomb;
+
+	  var _H264Stream, _NalByteStream;
+	  var PROFILES_WITH_OPTIONAL_SPS_DATA;
+
+	  /**
+	   * Accepts a NAL unit byte stream and unpacks the embedded NAL units.
+	   */
+	  _NalByteStream = function NalByteStream() {
+	    var syncPoint = 0,
+	      i,
+	      buffer;
+	    _NalByteStream.prototype.init.call(this);
+
+	    /*
+	     * Scans a byte stream and triggers a data event with the NAL units found.
+	     * @param {Object} data Event received from H264Stream
+	     * @param {Uint8Array} data.data The h264 byte stream to be scanned
+	     *
+	     * @see H264Stream.push
+	     */
+	    this.push = function (data) {
+	      var swapBuffer;
+	      if (!buffer) {
+	        buffer = data.data;
+	      } else {
+	        swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);
+	        swapBuffer.set(buffer);
+	        swapBuffer.set(data.data, buffer.byteLength);
+	        buffer = swapBuffer;
+	      }
+	      var len = buffer.byteLength;
+
+	      // Rec. ITU-T H.264, Annex B
+	      // scan for NAL unit boundaries
+
+	      // a match looks like this:
+	      // 0 0 1 .. NAL .. 0 0 1
+	      // ^ sync point        ^ i
+	      // or this:
+	      // 0 0 1 .. NAL .. 0 0 0
+	      // ^ sync point        ^ i
+
+	      // advance the sync point to a NAL start, if necessary
+	      for (; syncPoint < len - 3; syncPoint++) {
+	        if (buffer[syncPoint + 2] === 1) {
+	          // the sync point is properly aligned
+	          i = syncPoint + 5;
+	          break;
+	        }
+	      }
+	      while (i < len) {
+	        // look at the current byte to determine if we've hit the end of
+	        // a NAL unit boundary
+	        switch (buffer[i]) {
+	          case 0:
+	            // skip past non-sync sequences
+	            if (buffer[i - 1] !== 0) {
+	              i += 2;
+	              break;
+	            } else if (buffer[i - 2] !== 0) {
+	              i++;
+	              break;
+	            }
+
+	            // deliver the NAL unit if it isn't empty
+	            if (syncPoint + 3 !== i - 2) {
+	              this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+	            }
+
+	            // drop trailing zeroes
+	            do {
+	              i++;
+	            } while (buffer[i] !== 1 && i < len);
+	            syncPoint = i - 2;
+	            i += 3;
+	            break;
+	          case 1:
+	            // skip past non-sync sequences
+	            if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {
+	              i += 3;
+	              break;
+	            }
+
+	            // deliver the NAL unit
+	            this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+	            syncPoint = i - 2;
+	            i += 3;
+	            break;
+	          default:
+	            // the current byte isn't a one or zero, so it cannot be part
+	            // of a sync sequence
+	            i += 3;
+	            break;
+	        }
+	      }
+	      // filter out the NAL units that were delivered
+	      buffer = buffer.subarray(syncPoint);
+	      i -= syncPoint;
+	      syncPoint = 0;
+	    };
+	    this.reset = function () {
+	      buffer = null;
+	      syncPoint = 0;
+	      this.trigger('reset');
+	    };
+	    this.flush = function () {
+	      // deliver the last buffered NAL unit
+	      if (buffer && buffer.byteLength > 3) {
+	        this.trigger('data', buffer.subarray(syncPoint + 3));
+	      }
+	      // reset the stream state
+	      buffer = null;
+	      syncPoint = 0;
+	      this.trigger('done');
+	    };
+	    this.endTimeline = function () {
+	      this.flush();
+	      this.trigger('endedtimeline');
+	    };
+	  };
+	  _NalByteStream.prototype = new stream();
+
+	  // values of profile_idc that indicate additional fields are included in the SPS
+	  // see Recommendation ITU-T H.264 (4/2013),
+	  // 7.3.2.1.1 Sequence parameter set data syntax
+	  PROFILES_WITH_OPTIONAL_SPS_DATA = {
+	    100: true,
+	    110: true,
+	    122: true,
+	    244: true,
+	    44: true,
+	    83: true,
+	    86: true,
+	    118: true,
+	    128: true,
+	    // TODO: the three profiles below don't
+	    // appear to have sps data in the specificiation anymore?
+	    138: true,
+	    139: true,
+	    134: true
+	  };
+
+	  /**
+	   * Accepts input from a ElementaryStream and produces H.264 NAL unit data
+	   * events.
+	   */
+	  _H264Stream = function H264Stream() {
+	    var nalByteStream = new _NalByteStream(),
+	      self,
+	      trackId,
+	      currentPts,
+	      currentDts,
+	      discardEmulationPreventionBytes,
+	      readSequenceParameterSet,
+	      skipScalingList;
+	    _H264Stream.prototype.init.call(this);
+	    self = this;
+
+	    /*
+	     * Pushes a packet from a stream onto the NalByteStream
+	     *
+	     * @param {Object} packet - A packet received from a stream
+	     * @param {Uint8Array} packet.data - The raw bytes of the packet
+	     * @param {Number} packet.dts - Decode timestamp of the packet
+	     * @param {Number} packet.pts - Presentation timestamp of the packet
+	     * @param {Number} packet.trackId - The id of the h264 track this packet came from
+	     * @param {('video'|'audio')} packet.type - The type of packet
+	     *
+	     */
+	    this.push = function (packet) {
+	      if (packet.type !== 'video') {
+	        return;
+	      }
+	      trackId = packet.trackId;
+	      currentPts = packet.pts;
+	      currentDts = packet.dts;
+	      nalByteStream.push(packet);
+	    };
+
+	    /*
+	     * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps
+	     * for the NALUs to the next stream component.
+	     * Also, preprocess caption and sequence parameter NALUs.
+	     *
+	     * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`
+	     * @see NalByteStream.push
+	     */
+	    nalByteStream.on('data', function (data) {
+	      var event = {
+	        trackId: trackId,
+	        pts: currentPts,
+	        dts: currentDts,
+	        data: data,
+	        nalUnitTypeCode: data[0] & 0x1f
+	      };
+	      switch (event.nalUnitTypeCode) {
+	        case 0x05:
+	          event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';
+	          break;
+	        case 0x06:
+	          event.nalUnitType = 'sei_rbsp';
+	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+	          break;
+	        case 0x07:
+	          event.nalUnitType = 'seq_parameter_set_rbsp';
+	          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+	          event.config = readSequenceParameterSet(event.escapedRBSP);
+	          break;
+	        case 0x08:
+	          event.nalUnitType = 'pic_parameter_set_rbsp';
+	          break;
+	        case 0x09:
+	          event.nalUnitType = 'access_unit_delimiter_rbsp';
+	          break;
+	      }
+	      // This triggers data on the H264Stream
+	      self.trigger('data', event);
+	    });
+	    nalByteStream.on('done', function () {
+	      self.trigger('done');
+	    });
+	    nalByteStream.on('partialdone', function () {
+	      self.trigger('partialdone');
+	    });
+	    nalByteStream.on('reset', function () {
+	      self.trigger('reset');
+	    });
+	    nalByteStream.on('endedtimeline', function () {
+	      self.trigger('endedtimeline');
+	    });
+	    this.flush = function () {
+	      nalByteStream.flush();
+	    };
+	    this.partialFlush = function () {
+	      nalByteStream.partialFlush();
+	    };
+	    this.reset = function () {
+	      nalByteStream.reset();
+	    };
+	    this.endTimeline = function () {
+	      nalByteStream.endTimeline();
+	    };
+
+	    /**
+	     * Advance the ExpGolomb decoder past a scaling list. The scaling
+	     * list is optionally transmitted as part of a sequence parameter
+	     * set and is not relevant to transmuxing.
+	     * @param count {number} the number of entries in this scaling list
+	     * @param expGolombDecoder {object} an ExpGolomb pointed to the
+	     * start of a scaling list
+	     * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+	     */
+	    skipScalingList = function skipScalingList(count, expGolombDecoder) {
+	      var lastScale = 8,
+	        nextScale = 8,
+	        j,
+	        deltaScale;
+	      for (j = 0; j < count; j++) {
+	        if (nextScale !== 0) {
+	          deltaScale = expGolombDecoder.readExpGolomb();
+	          nextScale = (lastScale + deltaScale + 256) % 256;
+	        }
+	        lastScale = nextScale === 0 ? lastScale : nextScale;
+	      }
+	    };
+
+	    /**
+	     * Expunge any "Emulation Prevention" bytes from a "Raw Byte
+	     * Sequence Payload"
+	     * @param data {Uint8Array} the bytes of a RBSP from a NAL
+	     * unit
+	     * @return {Uint8Array} the RBSP without any Emulation
+	     * Prevention Bytes
+	     */
+	    discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+	      var length = data.byteLength,
+	        emulationPreventionBytesPositions = [],
+	        i = 1,
+	        newLength,
+	        newData;
+
+	      // Find all `Emulation Prevention Bytes`
+	      while (i < length - 2) {
+	        if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+	          emulationPreventionBytesPositions.push(i + 2);
+	          i += 2;
+	        } else {
+	          i++;
+	        }
+	      }
+
+	      // If no Emulation Prevention Bytes were found just return the original
+	      // array
+	      if (emulationPreventionBytesPositions.length === 0) {
+	        return data;
+	      }
+
+	      // Create a new array to hold the NAL unit data
+	      newLength = length - emulationPreventionBytesPositions.length;
+	      newData = new Uint8Array(newLength);
+	      var sourceIndex = 0;
+	      for (i = 0; i < newLength; sourceIndex++, i++) {
+	        if (sourceIndex === emulationPreventionBytesPositions[0]) {
+	          // Skip this byte
+	          sourceIndex++;
+	          // Remove this position index
+	          emulationPreventionBytesPositions.shift();
+	        }
+	        newData[i] = data[sourceIndex];
+	      }
+	      return newData;
+	    };
+
+	    /**
+	     * Read a sequence parameter set and return some interesting video
+	     * properties. A sequence parameter set is the H264 metadata that
+	     * describes the properties of upcoming video frames.
+	     * @param data {Uint8Array} the bytes of a sequence parameter set
+	     * @return {object} an object with configuration parsed from the
+	     * sequence parameter set, including the dimensions of the
+	     * associated video frames.
+	     */
+	    readSequenceParameterSet = function readSequenceParameterSet(data) {
+	      var frameCropLeftOffset = 0,
+	        frameCropRightOffset = 0,
+	        frameCropTopOffset = 0,
+	        frameCropBottomOffset = 0,
+	        expGolombDecoder,
+	        profileIdc,
+	        levelIdc,
+	        profileCompatibility,
+	        chromaFormatIdc,
+	        picOrderCntType,
+	        numRefFramesInPicOrderCntCycle,
+	        picWidthInMbsMinus1,
+	        picHeightInMapUnitsMinus1,
+	        frameMbsOnlyFlag,
+	        scalingListCount,
+	        sarRatio = [1, 1],
+	        aspectRatioIdc,
+	        i;
+	      expGolombDecoder = new expGolomb(data);
+	      profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc
+	      profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag
+	      levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)
+	      expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id
+
+	      // some profiles have more optional data we don't need
+	      if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {
+	        chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
+	        if (chromaFormatIdc === 3) {
+	          expGolombDecoder.skipBits(1); // separate_colour_plane_flag
+	        }
+
+	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8
+	        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8
+	        expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
+	        if (expGolombDecoder.readBoolean()) {
+	          // seq_scaling_matrix_present_flag
+	          scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+	          for (i = 0; i < scalingListCount; i++) {
+	            if (expGolombDecoder.readBoolean()) {
+	              // seq_scaling_list_present_flag[ i ]
+	              if (i < 6) {
+	                skipScalingList(16, expGolombDecoder);
+	              } else {
+	                skipScalingList(64, expGolombDecoder);
+	              }
+	            }
+	          }
+	        }
+	      }
+	      expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4
+	      picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
+	      if (picOrderCntType === 0) {
+	        expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4
+	      } else if (picOrderCntType === 1) {
+	        expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag
+	        expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic
+	        expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field
+	        numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();
+	        for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+	          expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]
+	        }
+	      }
+
+	      expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames
+	      expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
+
+	      picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+	      picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+	      frameMbsOnlyFlag = expGolombDecoder.readBits(1);
+	      if (frameMbsOnlyFlag === 0) {
+	        expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag
+	      }
+
+	      expGolombDecoder.skipBits(1); // direct_8x8_inference_flag
+	      if (expGolombDecoder.readBoolean()) {
+	        // frame_cropping_flag
+	        frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
+	        frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
+	        frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
+	        frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
+	      }
+	      if (expGolombDecoder.readBoolean()) {
+	        // vui_parameters_present_flag
+	        if (expGolombDecoder.readBoolean()) {
+	          // aspect_ratio_info_present_flag
+	          aspectRatioIdc = expGolombDecoder.readUnsignedByte();
+	          switch (aspectRatioIdc) {
+	            case 1:
+	              sarRatio = [1, 1];
+	              break;
+	            case 2:
+	              sarRatio = [12, 11];
+	              break;
+	            case 3:
+	              sarRatio = [10, 11];
+	              break;
+	            case 4:
+	              sarRatio = [16, 11];
+	              break;
+	            case 5:
+	              sarRatio = [40, 33];
+	              break;
+	            case 6:
+	              sarRatio = [24, 11];
+	              break;
+	            case 7:
+	              sarRatio = [20, 11];
+	              break;
+	            case 8:
+	              sarRatio = [32, 11];
+	              break;
+	            case 9:
+	              sarRatio = [80, 33];
+	              break;
+	            case 10:
+	              sarRatio = [18, 11];
+	              break;
+	            case 11:
+	              sarRatio = [15, 11];
+	              break;
+	            case 12:
+	              sarRatio = [64, 33];
+	              break;
+	            case 13:
+	              sarRatio = [160, 99];
+	              break;
+	            case 14:
+	              sarRatio = [4, 3];
+	              break;
+	            case 15:
+	              sarRatio = [3, 2];
+	              break;
+	            case 16:
+	              sarRatio = [2, 1];
+	              break;
+	            case 255:
+	              {
+	                sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];
+	                break;
+	              }
+	          }
+	          if (sarRatio) {
+	            sarRatio[0] / sarRatio[1];
+	          }
+	        }
+	      }
+	      return {
+	        profileIdc: profileIdc,
+	        levelIdc: levelIdc,
+	        profileCompatibility: profileCompatibility,
+	        width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,
+	        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,
+	        // sar is sample aspect ratio
+	        sarRatio: sarRatio
+	      };
+	    };
+	  };
+	  _H264Stream.prototype = new stream();
+	  var h264 = {
+	    H264Stream: _H264Stream,
+	    NalByteStream: _NalByteStream
+	  };
+
+	  /**
+	   * mux.js
+	   *
+	   * Copyright (c) Brightcove
+	   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	   *
+	   * Utilities to detect basic properties and metadata about Aac data.
+	   */
+
+	  var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+	  var parseId3TagSize = function parseId3TagSize(header, byteIndex) {
+	    var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],
+	      flags = header[byteIndex + 5],
+	      footerPresent = (flags & 16) >> 4;
+
+	    // if we get a negative returnSize clamp it to 0
+	    returnSize = returnSize >= 0 ? returnSize : 0;
+	    if (footerPresent) {
+	      return returnSize + 20;
+	    }
+	    return returnSize + 10;
+	  };
+	  var getId3Offset = function getId3Offset(data, offset) {
+	    if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {
+	      return offset;
+	    }
+	    offset += parseId3TagSize(data, offset);
+	    return getId3Offset(data, offset);
+	  };
+
+	  // TODO: use vhs-utils
+	  var isLikelyAacData$1 = function isLikelyAacData(data) {
+	    var offset = getId3Offset(data, 0);
+	    return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 &&
+	    // verify that the 2 layer bits are 0, aka this
+	    // is not mp3 data but aac data.
+	    (data[offset + 1] & 0x16) === 0x10;
+	  };
+	  var parseSyncSafeInteger = function parseSyncSafeInteger(data) {
+	    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+	  };
+
+	  // return a percent-encoded representation of the specified byte range
+	  // @see http://en.wikipedia.org/wiki/Percent-encoding
+	  var percentEncode = function percentEncode(bytes, start, end) {
+	    var i,
+	      result = '';
+	    for (i = start; i < end; i++) {
+	      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+	    }
+	    return result;
+	  };
+
+	  // return the string representation of the specified byte range,
+	  // interpreted as ISO-8859-1.
+	  var parseIso88591 = function parseIso88591(bytes, start, end) {
+	    return unescape(percentEncode(bytes, start, end)); // jshint ignore:line
+	  };
+
+	  var parseAdtsSize = function parseAdtsSize(header, byteIndex) {
+	    var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,
+	      middle = header[byteIndex + 4] << 3,
+	      highTwo = header[byteIndex + 3] & 0x3 << 11;
+	    return highTwo | middle | lowThree;
+	  };
+	  var parseType = function parseType(header, byteIndex) {
+	    if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {
+	      return 'timed-metadata';
+	    } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {
+	      return 'audio';
+	    }
+	    return null;
+	  };
+	  var parseSampleRate = function parseSampleRate(packet) {
+	    var i = 0;
+	    while (i + 5 < packet.length) {
+	      if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {
+	        // If a valid header was not found,  jump one forward and attempt to
+	        // find a valid ADTS header starting at the next byte
+	        i++;
+	        continue;
+	      }
+	      return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];
+	    }
+	    return null;
+	  };
+	  var parseAacTimestamp = function parseAacTimestamp(packet) {
+	    var frameStart, frameSize, frame, frameHeader;
+
+	    // find the start of the first frame and the end of the tag
+	    frameStart = 10;
+	    if (packet[5] & 0x40) {
+	      // advance the frame start past the extended header
+	      frameStart += 4; // header size field
+	      frameStart += parseSyncSafeInteger(packet.subarray(10, 14));
+	    }
+
+	    // parse one or more ID3 frames
+	    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+	    do {
+	      // determine the number of bytes in this frame
+	      frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));
+	      if (frameSize < 1) {
+	        return null;
+	      }
+	      frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);
+	      if (frameHeader === 'PRIV') {
+	        frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);
+	        for (var i = 0; i < frame.byteLength; i++) {
+	          if (frame[i] === 0) {
+	            var owner = parseIso88591(frame, 0, i);
+	            if (owner === 'com.apple.streaming.transportStreamTimestamp') {
+	              var d = frame.subarray(i + 1);
+	              var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+	              size *= 4;
+	              size += d[7] & 0x03;
+	              return size;
+	            }
+	            break;
+	          }
+	        }
+	      }
+	      frameStart += 10; // advance past the frame header
+	      frameStart += frameSize; // advance past the frame body
+	    } while (frameStart < packet.byteLength);
+	    return null;
+	  };
+	  var utils = {
+	    isLikelyAacData: isLikelyAacData$1,
+	    parseId3TagSize: parseId3TagSize,
+	    parseAdtsSize: parseAdtsSize,
+	    parseType: parseType,
+	    parseSampleRate: parseSampleRate,
+	    parseAacTimestamp: parseAacTimestamp
+	  };
+
+	  // Constants
+	  var _AacStream;
+
+	  /**
+	   * Splits an incoming stream of binary data into ADTS and ID3 Frames.
+	   */
+
+	  _AacStream = function AacStream() {
+	    var everything = new Uint8Array(),
+	      timeStamp = 0;
+	    _AacStream.prototype.init.call(this);
+	    this.setTimestamp = function (timestamp) {
+	      timeStamp = timestamp;
+	    };
+	    this.push = function (bytes) {
+	      var frameSize = 0,
+	        byteIndex = 0,
+	        bytesLeft,
+	        chunk,
+	        packet,
+	        tempLength;
+
+	      // If there are bytes remaining from the last segment, prepend them to the
+	      // bytes that were pushed in
+	      if (everything.length) {
+	        tempLength = everything.length;
+	        everything = new Uint8Array(bytes.byteLength + tempLength);
+	        everything.set(everything.subarray(0, tempLength));
+	        everything.set(bytes, tempLength);
+	      } else {
+	        everything = bytes;
+	      }
+	      while (everything.length - byteIndex >= 3) {
+	        if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {
+	          // Exit early because we don't have enough to parse
+	          // the ID3 tag header
+	          if (everything.length - byteIndex < 10) {
+	            break;
+	          }
+
+	          // check framesize
+	          frameSize = utils.parseId3TagSize(everything, byteIndex);
+
+	          // Exit early if we don't have enough in the buffer
+	          // to emit a full packet
+	          // Add to byteIndex to support multiple ID3 tags in sequence
+	          if (byteIndex + frameSize > everything.length) {
+	            break;
+	          }
+	          chunk = {
+	            type: 'timed-metadata',
+	            data: everything.subarray(byteIndex, byteIndex + frameSize)
+	          };
+	          this.trigger('data', chunk);
+	          byteIndex += frameSize;
+	          continue;
+	        } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {
+	          // Exit early because we don't have enough to parse
+	          // the ADTS frame header
+	          if (everything.length - byteIndex < 7) {
+	            break;
+	          }
+	          frameSize = utils.parseAdtsSize(everything, byteIndex);
+
+	          // Exit early if we don't have enough in the buffer
+	          // to emit a full packet
+	          if (byteIndex + frameSize > everything.length) {
+	            break;
+	          }
+	          packet = {
+	            type: 'audio',
+	            data: everything.subarray(byteIndex, byteIndex + frameSize),
+	            pts: timeStamp,
+	            dts: timeStamp
+	          };
+	          this.trigger('data', packet);
+	          byteIndex += frameSize;
+	          continue;
+	        }
+	        byteIndex++;
+	      }
+	      bytesLeft = everything.length - byteIndex;
+	      if (bytesLeft > 0) {
+	        everything = everything.subarray(byteIndex);
+	      } else {
+	        everything = new Uint8Array();
+	      }
+	    };
+	    this.reset = function () {
+	      everything = new Uint8Array();
+	      this.trigger('reset');
+	    };
+	    this.endTimeline = function () {
+	      everything = new Uint8Array();
+	      this.trigger('endedtimeline');
+	    };
+	  };
+	  _AacStream.prototype = new stream();
+	  var aac = _AacStream;
+
+	  // constants
+	  var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];
+	  var audioProperties = AUDIO_PROPERTIES;
+
+	  var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];
+	  var videoProperties = VIDEO_PROPERTIES;
+
+	  var H264Stream = h264.H264Stream;
+	  var isLikelyAacData = utils.isLikelyAacData;
+	  var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;
+
+	  // object types
+	  var _VideoSegmentStream, _AudioSegmentStream, _Transmuxer, _CoalesceStream;
+	  var retriggerForStream = function retriggerForStream(key, event) {
+	    event.stream = key;
+	    this.trigger('log', event);
+	  };
+	  var addPipelineLogRetriggers = function addPipelineLogRetriggers(transmuxer, pipeline) {
+	    var keys = Object.keys(pipeline);
+	    for (var i = 0; i < keys.length; i++) {
+	      var key = keys[i];
+
+	      // skip non-stream keys and headOfPipeline
+	      // which is just a duplicate
+	      if (key === 'headOfPipeline' || !pipeline[key].on) {
+	        continue;
+	      }
+	      pipeline[key].on('log', retriggerForStream.bind(transmuxer, key));
+	    }
+	  };
+
+	  /**
+	   * Compare two arrays (even typed) for same-ness
+	   */
+	  var arrayEquals = function arrayEquals(a, b) {
+	    var i;
+	    if (a.length !== b.length) {
+	      return false;
+	    }
+
+	    // compare the value of each element in the array
+	    for (i = 0; i < a.length; i++) {
+	      if (a[i] !== b[i]) {
+	        return false;
+	      }
+	    }
+	    return true;
+	  };
+	  var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {
+	    var ptsOffsetFromDts = startPts - startDts,
+	      decodeDuration = endDts - startDts,
+	      presentationDuration = endPts - startPts;
+
+	    // The PTS and DTS values are based on the actual stream times from the segment,
+	    // however, the player time values will reflect a start from the baseMediaDecodeTime.
+	    // In order to provide relevant values for the player times, base timing info on the
+	    // baseMediaDecodeTime and the DTS and PTS durations of the segment.
+	    return {
+	      start: {
+	        dts: baseMediaDecodeTime,
+	        pts: baseMediaDecodeTime + ptsOffsetFromDts
+	      },
+	      end: {
+	        dts: baseMediaDecodeTime + decodeDuration,
+	        pts: baseMediaDecodeTime + presentationDuration
+	      },
+	      prependedContentDuration: prependedContentDuration,
+	      baseMediaDecodeTime: baseMediaDecodeTime
+	    };
+	  };
+
+	  /**
+	   * Constructs a single-track, ISO BMFF media segment from AAC data
+	   * events. The output of this stream can be fed to a SourceBuffer
+	   * configured with a suitable initialization segment.
+	   * @param track {object} track metadata configuration
+	   * @param options {object} transmuxer options object
+	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at 0.
+	   */
+	  _AudioSegmentStream = function AudioSegmentStream(track, options) {
+	    var adtsFrames = [],
+	      sequenceNumber,
+	      earliestAllowedDts = 0,
+	      audioAppendStartTs = 0,
+	      videoBaseMediaDecodeTime = Infinity;
+	    options = options || {};
+	    sequenceNumber = options.firstSequenceNumber || 0;
+	    _AudioSegmentStream.prototype.init.call(this);
+	    this.push = function (data) {
+	      trackDecodeInfo.collectDtsInfo(track, data);
+	      if (track) {
+	        audioProperties.forEach(function (prop) {
+	          track[prop] = data[prop];
+	        });
+	      }
+
+	      // buffer audio data until end() is called
+	      adtsFrames.push(data);
+	    };
+	    this.setEarliestDts = function (earliestDts) {
+	      earliestAllowedDts = earliestDts;
+	    };
+	    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+	      videoBaseMediaDecodeTime = baseMediaDecodeTime;
+	    };
+	    this.setAudioAppendStart = function (timestamp) {
+	      audioAppendStartTs = timestamp;
+	    };
+	    this.flush = function () {
+	      var frames, moof, mdat, boxes, frameDuration, segmentDuration, videoClockCyclesOfSilencePrefixed;
+
+	      // return early if no audio data has been observed
+	      if (adtsFrames.length === 0) {
+	        this.trigger('done', 'AudioSegmentStream');
+	        return;
+	      }
+	      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);
+	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+
+	      // amount of audio filled but the value is in video clock rather than audio clock
+	      videoClockCyclesOfSilencePrefixed = audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime);
+
+	      // we have to build the index from byte locations to
+	      // samples (that is, adts frames) in the audio data
+	      track.samples = audioFrameUtils.generateSampleTable(frames);
+
+	      // concatenate the audio data to constuct the mdat
+	      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));
+	      adtsFrames = [];
+	      moof = mp4Generator.moof(sequenceNumber, [track]);
+	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+	      // bump the sequence number for next time
+	      sequenceNumber++;
+	      boxes.set(moof);
+	      boxes.set(mdat, moof.byteLength);
+	      trackDecodeInfo.clearDtsInfo(track);
+	      frameDuration = Math.ceil(ONE_SECOND_IN_TS * 1024 / track.samplerate);
+
+	      // TODO this check was added to maintain backwards compatibility (particularly with
+	      // tests) on adding the timingInfo event. However, it seems unlikely that there's a
+	      // valid use-case where an init segment/data should be triggered without associated
+	      // frames. Leaving for now, but should be looked into.
+	      if (frames.length) {
+	        segmentDuration = frames.length * frameDuration;
+	        this.trigger('segmentTimingInfo', generateSegmentTimingInfo(
+	        // The audio track's baseMediaDecodeTime is in audio clock cycles, but the
+	        // frame info is in video clock cycles. Convert to match expectation of
+	        // listeners (that all timestamps will be based on video clock cycles).
+	        clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate),
+	        // frame times are already in video clock, as is segment duration
+	        frames[0].dts, frames[0].pts, frames[0].dts + segmentDuration, frames[0].pts + segmentDuration, videoClockCyclesOfSilencePrefixed || 0));
+	        this.trigger('timingInfo', {
+	          start: frames[0].pts,
+	          end: frames[0].pts + segmentDuration
+	        });
+	      }
+	      this.trigger('data', {
+	        track: track,
+	        boxes: boxes
+	      });
+	      this.trigger('done', 'AudioSegmentStream');
+	    };
+	    this.reset = function () {
+	      trackDecodeInfo.clearDtsInfo(track);
+	      adtsFrames = [];
+	      this.trigger('reset');
+	    };
+	  };
+	  _AudioSegmentStream.prototype = new stream();
+
+	  /**
+	   * Constructs a single-track, ISO BMFF media segment from H264 data
+	   * events. The output of this stream can be fed to a SourceBuffer
+	   * configured with a suitable initialization segment.
+	   * @param track {object} track metadata configuration
+	   * @param options {object} transmuxer options object
+	   * @param options.alignGopsAtEnd {boolean} If true, start from the end of the
+	   *        gopsToAlignWith list when attempting to align gop pts
+	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at 0.
+	   */
+	  _VideoSegmentStream = function VideoSegmentStream(track, options) {
+	    var sequenceNumber,
+	      nalUnits = [],
+	      gopsToAlignWith = [],
+	      config,
+	      pps;
+	    options = options || {};
+	    sequenceNumber = options.firstSequenceNumber || 0;
+	    _VideoSegmentStream.prototype.init.call(this);
+	    delete track.minPTS;
+	    this.gopCache_ = [];
+
+	    /**
+	      * Constructs a ISO BMFF segment given H264 nalUnits
+	      * @param {Object} nalUnit A data event representing a nalUnit
+	      * @param {String} nalUnit.nalUnitType
+	      * @param {Object} nalUnit.config Properties for a mp4 track
+	      * @param {Uint8Array} nalUnit.data The nalUnit bytes
+	      * @see lib/codecs/h264.js
+	     **/
+	    this.push = function (nalUnit) {
+	      trackDecodeInfo.collectDtsInfo(track, nalUnit);
+
+	      // record the track config
+	      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {
+	        config = nalUnit.config;
+	        track.sps = [nalUnit.data];
+	        videoProperties.forEach(function (prop) {
+	          track[prop] = config[prop];
+	        }, this);
+	      }
+	      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {
+	        pps = nalUnit.data;
+	        track.pps = [nalUnit.data];
+	      }
+
+	      // buffer video until flush() is called
+	      nalUnits.push(nalUnit);
+	    };
+
+	    /**
+	      * Pass constructed ISO BMFF track and boxes on to the
+	      * next stream in the pipeline
+	     **/
+	    this.flush = function () {
+	      var frames,
+	        gopForFusion,
+	        gops,
+	        moof,
+	        mdat,
+	        boxes,
+	        prependedContentDuration = 0,
+	        firstGop,
+	        lastGop;
+
+	      // Throw away nalUnits at the start of the byte stream until
+	      // we find the first AUD
+	      while (nalUnits.length) {
+	        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
+	          break;
+	        }
+	        nalUnits.shift();
+	      }
+
+	      // Return early if no video data has been observed
+	      if (nalUnits.length === 0) {
+	        this.resetStream_();
+	        this.trigger('done', 'VideoSegmentStream');
+	        return;
+	      }
+
+	      // Organize the raw nal-units into arrays that represent
+	      // higher-level constructs such as frames and gops
+	      // (group-of-pictures)
+	      frames = frameUtils.groupNalsIntoFrames(nalUnits);
+	      gops = frameUtils.groupFramesIntoGops(frames);
+
+	      // If the first frame of this fragment is not a keyframe we have
+	      // a problem since MSE (on Chrome) requires a leading keyframe.
+	      //
+	      // We have two approaches to repairing this situation:
+	      // 1) GOP-FUSION:
+	      //    This is where we keep track of the GOPS (group-of-pictures)
+	      //    from previous fragments and attempt to find one that we can
+	      //    prepend to the current fragment in order to create a valid
+	      //    fragment.
+	      // 2) KEYFRAME-PULLING:
+	      //    Here we search for the first keyframe in the fragment and
+	      //    throw away all the frames between the start of the fragment
+	      //    and that keyframe. We then extend the duration and pull the
+	      //    PTS of the keyframe forward so that it covers the time range
+	      //    of the frames that were disposed of.
+	      //
+	      // #1 is far prefereable over #2 which can cause "stuttering" but
+	      // requires more things to be just right.
+	      if (!gops[0][0].keyFrame) {
+	        // Search for a gop for fusion from our gopCache
+	        gopForFusion = this.getGopForFusion_(nalUnits[0], track);
+	        if (gopForFusion) {
+	          // in order to provide more accurate timing information about the segment, save
+	          // the number of seconds prepended to the original segment due to GOP fusion
+	          prependedContentDuration = gopForFusion.duration;
+	          gops.unshift(gopForFusion);
+	          // Adjust Gops' metadata to account for the inclusion of the
+	          // new gop at the beginning
+	          gops.byteLength += gopForFusion.byteLength;
+	          gops.nalCount += gopForFusion.nalCount;
+	          gops.pts = gopForFusion.pts;
+	          gops.dts = gopForFusion.dts;
+	          gops.duration += gopForFusion.duration;
+	        } else {
+	          // If we didn't find a candidate gop fall back to keyframe-pulling
+	          gops = frameUtils.extendFirstKeyFrame(gops);
+	        }
+	      }
+
+	      // Trim gops to align with gopsToAlignWith
+	      if (gopsToAlignWith.length) {
+	        var alignedGops;
+	        if (options.alignGopsAtEnd) {
+	          alignedGops = this.alignGopsAtEnd_(gops);
+	        } else {
+	          alignedGops = this.alignGopsAtStart_(gops);
+	        }
+	        if (!alignedGops) {
+	          // save all the nals in the last GOP into the gop cache
+	          this.gopCache_.unshift({
+	            gop: gops.pop(),
+	            pps: track.pps,
+	            sps: track.sps
+	          });
+
+	          // Keep a maximum of 6 GOPs in the cache
+	          this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+	          // Clear nalUnits
+	          nalUnits = [];
+
+	          // return early no gops can be aligned with desired gopsToAlignWith
+	          this.resetStream_();
+	          this.trigger('done', 'VideoSegmentStream');
+	          return;
+	        }
+
+	        // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct
+	        // when recalculated before sending off to CoalesceStream
+	        trackDecodeInfo.clearDtsInfo(track);
+	        gops = alignedGops;
+	      }
+	      trackDecodeInfo.collectDtsInfo(track, gops);
+
+	      // First, we have to build the index from byte locations to
+	      // samples (that is, frames) in the video data
+	      track.samples = frameUtils.generateSampleTable(gops);
+
+	      // Concatenate the video data and construct the mdat
+	      mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));
+	      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+	      this.trigger('processedGopsInfo', gops.map(function (gop) {
+	        return {
+	          pts: gop.pts,
+	          dts: gop.dts,
+	          byteLength: gop.byteLength
+	        };
+	      }));
+	      firstGop = gops[0];
+	      lastGop = gops[gops.length - 1];
+	      this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));
+	      this.trigger('timingInfo', {
+	        start: gops[0].pts,
+	        end: gops[gops.length - 1].pts + gops[gops.length - 1].duration
+	      });
+
+	      // save all the nals in the last GOP into the gop cache
+	      this.gopCache_.unshift({
+	        gop: gops.pop(),
+	        pps: track.pps,
+	        sps: track.sps
+	      });
+
+	      // Keep a maximum of 6 GOPs in the cache
+	      this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+	      // Clear nalUnits
+	      nalUnits = [];
+	      this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);
+	      this.trigger('timelineStartInfo', track.timelineStartInfo);
+	      moof = mp4Generator.moof(sequenceNumber, [track]);
+
+	      // it would be great to allocate this array up front instead of
+	      // throwing away hundreds of media segment fragments
+	      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+	      // Bump the sequence number for next time
+	      sequenceNumber++;
+	      boxes.set(moof);
+	      boxes.set(mdat, moof.byteLength);
+	      this.trigger('data', {
+	        track: track,
+	        boxes: boxes
+	      });
+	      this.resetStream_();
+
+	      // Continue with the flush process now
+	      this.trigger('done', 'VideoSegmentStream');
+	    };
+	    this.reset = function () {
+	      this.resetStream_();
+	      nalUnits = [];
+	      this.gopCache_.length = 0;
+	      gopsToAlignWith.length = 0;
+	      this.trigger('reset');
+	    };
+	    this.resetStream_ = function () {
+	      trackDecodeInfo.clearDtsInfo(track);
+
+	      // reset config and pps because they may differ across segments
+	      // for instance, when we are rendition switching
+	      config = undefined;
+	      pps = undefined;
+	    };
+
+	    // Search for a candidate Gop for gop-fusion from the gop cache and
+	    // return it or return null if no good candidate was found
+	    this.getGopForFusion_ = function (nalUnit) {
+	      var halfSecond = 45000,
+	        // Half-a-second in a 90khz clock
+	        allowableOverlap = 10000,
+	        // About 3 frames @ 30fps
+	        nearestDistance = Infinity,
+	        dtsDistance,
+	        nearestGopObj,
+	        currentGop,
+	        currentGopObj,
+	        i;
+
+	      // Search for the GOP nearest to the beginning of this nal unit
+	      for (i = 0; i < this.gopCache_.length; i++) {
+	        currentGopObj = this.gopCache_[i];
+	        currentGop = currentGopObj.gop;
+
+	        // Reject Gops with different SPS or PPS
+	        if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {
+	          continue;
+	        }
+
+	        // Reject Gops that would require a negative baseMediaDecodeTime
+	        if (currentGop.dts < track.timelineStartInfo.dts) {
+	          continue;
+	        }
+
+	        // The distance between the end of the gop and the start of the nalUnit
+	        dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration;
+
+	        // Only consider GOPS that start before the nal unit and end within
+	        // a half-second of the nal unit
+	        if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {
+	          // Always use the closest GOP we found if there is more than
+	          // one candidate
+	          if (!nearestGopObj || nearestDistance > dtsDistance) {
+	            nearestGopObj = currentGopObj;
+	            nearestDistance = dtsDistance;
+	          }
+	        }
+	      }
+	      if (nearestGopObj) {
+	        return nearestGopObj.gop;
+	      }
+	      return null;
+	    };
+
+	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+	    // of gopsToAlignWith starting from the START of the list
+	    this.alignGopsAtStart_ = function (gops) {
+	      var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;
+	      byteLength = gops.byteLength;
+	      nalCount = gops.nalCount;
+	      duration = gops.duration;
+	      alignIndex = gopIndex = 0;
+	      while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {
+	        align = gopsToAlignWith[alignIndex];
+	        gop = gops[gopIndex];
+	        if (align.pts === gop.pts) {
+	          break;
+	        }
+	        if (gop.pts > align.pts) {
+	          // this current gop starts after the current gop we want to align on, so increment
+	          // align index
+	          alignIndex++;
+	          continue;
+	        }
+
+	        // current gop starts before the current gop we want to align on. so increment gop
+	        // index
+	        gopIndex++;
+	        byteLength -= gop.byteLength;
+	        nalCount -= gop.nalCount;
+	        duration -= gop.duration;
+	      }
+	      if (gopIndex === 0) {
+	        // no gops to trim
+	        return gops;
+	      }
+	      if (gopIndex === gops.length) {
+	        // all gops trimmed, skip appending all gops
+	        return null;
+	      }
+	      alignedGops = gops.slice(gopIndex);
+	      alignedGops.byteLength = byteLength;
+	      alignedGops.duration = duration;
+	      alignedGops.nalCount = nalCount;
+	      alignedGops.pts = alignedGops[0].pts;
+	      alignedGops.dts = alignedGops[0].dts;
+	      return alignedGops;
+	    };
+
+	    // trim gop list to the first gop found that has a matching pts with a gop in the list
+	    // of gopsToAlignWith starting from the END of the list
+	    this.alignGopsAtEnd_ = function (gops) {
+	      var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;
+	      alignIndex = gopsToAlignWith.length - 1;
+	      gopIndex = gops.length - 1;
+	      alignEndIndex = null;
+	      matchFound = false;
+	      while (alignIndex >= 0 && gopIndex >= 0) {
+	        align = gopsToAlignWith[alignIndex];
+	        gop = gops[gopIndex];
+	        if (align.pts === gop.pts) {
+	          matchFound = true;
+	          break;
+	        }
+	        if (align.pts > gop.pts) {
+	          alignIndex--;
+	          continue;
+	        }
+	        if (alignIndex === gopsToAlignWith.length - 1) {
+	          // gop.pts is greater than the last alignment candidate. If no match is found
+	          // by the end of this loop, we still want to append gops that come after this
+	          // point
+	          alignEndIndex = gopIndex;
+	        }
+	        gopIndex--;
+	      }
+	      if (!matchFound && alignEndIndex === null) {
+	        return null;
+	      }
+	      var trimIndex;
+	      if (matchFound) {
+	        trimIndex = gopIndex;
+	      } else {
+	        trimIndex = alignEndIndex;
+	      }
+	      if (trimIndex === 0) {
+	        return gops;
+	      }
+	      var alignedGops = gops.slice(trimIndex);
+	      var metadata = alignedGops.reduce(function (total, gop) {
+	        total.byteLength += gop.byteLength;
+	        total.duration += gop.duration;
+	        total.nalCount += gop.nalCount;
+	        return total;
+	      }, {
+	        byteLength: 0,
+	        duration: 0,
+	        nalCount: 0
+	      });
+	      alignedGops.byteLength = metadata.byteLength;
+	      alignedGops.duration = metadata.duration;
+	      alignedGops.nalCount = metadata.nalCount;
+	      alignedGops.pts = alignedGops[0].pts;
+	      alignedGops.dts = alignedGops[0].dts;
+	      return alignedGops;
+	    };
+	    this.alignGopsWith = function (newGopsToAlignWith) {
+	      gopsToAlignWith = newGopsToAlignWith;
+	    };
+	  };
+	  _VideoSegmentStream.prototype = new stream();
+
+	  /**
+	   * A Stream that can combine multiple streams (ie. audio & video)
+	   * into a single output segment for MSE. Also supports audio-only
+	   * and video-only streams.
+	   * @param options {object} transmuxer options object
+	   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+	   *        in the source; false to adjust the first segment to start at media timeline start.
+	   */
+	  _CoalesceStream = function CoalesceStream(options, metadataStream) {
+	    // Number of Tracks per output segment
+	    // If greater than 1, we combine multiple
+	    // tracks into a single segment
+	    this.numberOfTracks = 0;
+	    this.metadataStream = metadataStream;
+	    options = options || {};
+	    if (typeof options.remux !== 'undefined') {
+	      this.remuxTracks = !!options.remux;
+	    } else {
+	      this.remuxTracks = true;
+	    }
+	    if (typeof options.keepOriginalTimestamps === 'boolean') {
+	      this.keepOriginalTimestamps = options.keepOriginalTimestamps;
+	    } else {
+	      this.keepOriginalTimestamps = false;
+	    }
+	    this.pendingTracks = [];
+	    this.videoTrack = null;
+	    this.pendingBoxes = [];
+	    this.pendingCaptions = [];
+	    this.pendingMetadata = [];
+	    this.pendingBytes = 0;
+	    this.emittedTracks = 0;
+	    _CoalesceStream.prototype.init.call(this);
+
+	    // Take output from multiple
+	    this.push = function (output) {
+	      // buffer incoming captions until the associated video segment
+	      // finishes
+	      if (output.text) {
+	        return this.pendingCaptions.push(output);
+	      }
+	      // buffer incoming id3 tags until the final flush
+	      if (output.frames) {
+	        return this.pendingMetadata.push(output);
+	      }
+
+	      // Add this track to the list of pending tracks and store
+	      // important information required for the construction of
+	      // the final segment
+	      this.pendingTracks.push(output.track);
+	      this.pendingBytes += output.boxes.byteLength;
+
+	      // TODO: is there an issue for this against chrome?
+	      // We unshift audio and push video because
+	      // as of Chrome 75 when switching from
+	      // one init segment to another if the video
+	      // mdat does not appear after the audio mdat
+	      // only audio will play for the duration of our transmux.
+	      if (output.track.type === 'video') {
+	        this.videoTrack = output.track;
+	        this.pendingBoxes.push(output.boxes);
+	      }
+	      if (output.track.type === 'audio') {
+	        this.audioTrack = output.track;
+	        this.pendingBoxes.unshift(output.boxes);
+	      }
+	    };
+	  };
+	  _CoalesceStream.prototype = new stream();
+	  _CoalesceStream.prototype.flush = function (flushSource) {
+	    var offset = 0,
+	      event = {
+	        captions: [],
+	        captionStreams: {},
+	        metadata: [],
+	        info: {}
+	      },
+	      caption,
+	      id3,
+	      initSegment,
+	      timelineStartPts = 0,
+	      i;
+	    if (this.pendingTracks.length < this.numberOfTracks) {
+	      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {
+	        // Return because we haven't received a flush from a data-generating
+	        // portion of the segment (meaning that we have only recieved meta-data
+	        // or captions.)
+	        return;
+	      } else if (this.remuxTracks) {
+	        // Return until we have enough tracks from the pipeline to remux (if we
+	        // are remuxing audio and video into a single MP4)
+	        return;
+	      } else if (this.pendingTracks.length === 0) {
+	        // In the case where we receive a flush without any data having been
+	        // received we consider it an emitted track for the purposes of coalescing
+	        // `done` events.
+	        // We do this for the case where there is an audio and video track in the
+	        // segment but no audio data. (seen in several playlists with alternate
+	        // audio tracks and no audio present in the main TS segments.)
+	        this.emittedTracks++;
+	        if (this.emittedTracks >= this.numberOfTracks) {
+	          this.trigger('done');
+	          this.emittedTracks = 0;
+	        }
+	        return;
+	      }
+	    }
+	    if (this.videoTrack) {
+	      timelineStartPts = this.videoTrack.timelineStartInfo.pts;
+	      videoProperties.forEach(function (prop) {
+	        event.info[prop] = this.videoTrack[prop];
+	      }, this);
+	    } else if (this.audioTrack) {
+	      timelineStartPts = this.audioTrack.timelineStartInfo.pts;
+	      audioProperties.forEach(function (prop) {
+	        event.info[prop] = this.audioTrack[prop];
+	      }, this);
+	    }
+	    if (this.videoTrack || this.audioTrack) {
+	      if (this.pendingTracks.length === 1) {
+	        event.type = this.pendingTracks[0].type;
+	      } else {
+	        event.type = 'combined';
+	      }
+	      this.emittedTracks += this.pendingTracks.length;
+	      initSegment = mp4Generator.initSegment(this.pendingTracks);
+
+	      // Create a new typed array to hold the init segment
+	      event.initSegment = new Uint8Array(initSegment.byteLength);
+
+	      // Create an init segment containing a moov
+	      // and track definitions
+	      event.initSegment.set(initSegment);
+
+	      // Create a new typed array to hold the moof+mdats
+	      event.data = new Uint8Array(this.pendingBytes);
+
+	      // Append each moof+mdat (one per track) together
+	      for (i = 0; i < this.pendingBoxes.length; i++) {
+	        event.data.set(this.pendingBoxes[i], offset);
+	        offset += this.pendingBoxes[i].byteLength;
+	      }
+
+	      // Translate caption PTS times into second offsets to match the
+	      // video timeline for the segment, and add track info
+	      for (i = 0; i < this.pendingCaptions.length; i++) {
+	        caption = this.pendingCaptions[i];
+	        caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);
+	        caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);
+	        event.captionStreams[caption.stream] = true;
+	        event.captions.push(caption);
+	      }
+
+	      // Translate ID3 frame PTS times into second offsets to match the
+	      // video timeline for the segment
+	      for (i = 0; i < this.pendingMetadata.length; i++) {
+	        id3 = this.pendingMetadata[i];
+	        id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);
+	        event.metadata.push(id3);
+	      }
+
+	      // We add this to every single emitted segment even though we only need
+	      // it for the first
+	      event.metadata.dispatchType = this.metadataStream.dispatchType;
+
+	      // Reset stream state
+	      this.pendingTracks.length = 0;
+	      this.videoTrack = null;
+	      this.pendingBoxes.length = 0;
+	      this.pendingCaptions.length = 0;
+	      this.pendingBytes = 0;
+	      this.pendingMetadata.length = 0;
+
+	      // Emit the built segment
+	      // We include captions and ID3 tags for backwards compatibility,
+	      // ideally we should send only video and audio in the data event
+	      this.trigger('data', event);
+	      // Emit each caption to the outside world
+	      // Ideally, this would happen immediately on parsing captions,
+	      // but we need to ensure that video data is sent back first
+	      // so that caption timing can be adjusted to match video timing
+	      for (i = 0; i < event.captions.length; i++) {
+	        caption = event.captions[i];
+	        this.trigger('caption', caption);
+	      }
+	      // Emit each id3 tag to the outside world
+	      // Ideally, this would happen immediately on parsing the tag,
+	      // but we need to ensure that video data is sent back first
+	      // so that ID3 frame timing can be adjusted to match video timing
+	      for (i = 0; i < event.metadata.length; i++) {
+	        id3 = event.metadata[i];
+	        this.trigger('id3Frame', id3);
+	      }
+	    }
+
+	    // Only emit `done` if all tracks have been flushed and emitted
+	    if (this.emittedTracks >= this.numberOfTracks) {
+	      this.trigger('done');
+	      this.emittedTracks = 0;
+	    }
+	  };
+	  _CoalesceStream.prototype.setRemux = function (val) {
+	    this.remuxTracks = val;
+	  };
+	  /**
+	   * A Stream that expects MP2T binary data as input and produces
+	   * corresponding media segments, suitable for use with Media Source
+	   * Extension (MSE) implementations that support the ISO BMFF byte
+	   * stream format, like Chrome.
+	   */
+	  _Transmuxer = function Transmuxer(options) {
+	    var self = this,
+	      hasFlushed = true,
+	      videoTrack,
+	      audioTrack;
+	    _Transmuxer.prototype.init.call(this);
+	    options = options || {};
+	    var duration = this.duration = options.duration || 0xffffffff;
+	    this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;
+	    this.transmuxPipeline_ = {};
+	    this.setupAacPipeline = function () {
+	      var pipeline = {};
+	      this.transmuxPipeline_ = pipeline;
+	      pipeline.type = 'aac';
+	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+	      // set up the parsing pipeline
+	      pipeline.aacStream = new aac();
+	      pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');
+	      pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');
+	      pipeline.adtsStream = new adts();
+	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+	      pipeline.headOfPipeline = pipeline.aacStream;
+	      pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);
+	      pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+	      pipeline.metadataStream.on('timestamp', function (frame) {
+	        pipeline.aacStream.setTimestamp(frame.timeStamp);
+	      });
+	      pipeline.aacStream.on('data', function (data) {
+	        if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {
+	          return;
+	        }
+	        audioTrack = audioTrack || {
+	          timelineStartInfo: {
+	            baseMediaDecodeTime: self.baseMediaDecodeTime
+	          },
+	          codec: 'adts',
+	          type: 'audio'
+	        };
+	        // hook up the audio segment stream to the first track with aac data
+	        pipeline.coalesceStream.numberOfTracks++;
+	        pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+	        pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+	        pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+
+	        // Set up the final part of the audio pipeline
+	        pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+
+	        // emit pmt info
+	        self.trigger('trackinfo', {
+	          hasAudio: !!audioTrack,
+	          hasVideo: !!videoTrack
+	        });
+	      });
+
+	      // Re-emit any data coming from the coalesce stream to the outside world
+	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+	      // Let the consumer know we have finished flushing the entire pipeline
+	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+	      addPipelineLogRetriggers(this, pipeline);
+	    };
+	    this.setupTsPipeline = function () {
+	      var pipeline = {};
+	      this.transmuxPipeline_ = pipeline;
+	      pipeline.type = 'ts';
+	      pipeline.duration = duration * 9e4;
+	      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+	      // set up the parsing pipeline
+	      pipeline.packetStream = new m2ts_1.TransportPacketStream();
+	      pipeline.parseStream = new m2ts_1.TransportParseStream();
+	      pipeline.elementaryStream = new m2ts_1.ElementaryStream();
+	      pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();
+	      pipeline.adtsStream = new adts();
+	      pipeline.h264Stream = new H264Stream();
+	      pipeline.captionStream = new m2ts_1.CaptionStream(options);
+	      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+	      pipeline.headOfPipeline = pipeline.packetStream;
+
+	      // disassemble MPEG2-TS packets into elementary streams
+	      pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream);
+
+	      // !!THIS ORDER IS IMPORTANT!!
+	      // demux the streams
+	      pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);
+	      pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);
+	      pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+
+	      // Hook up CEA-608/708 caption stream
+	      pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);
+	      pipeline.elementaryStream.on('data', function (data) {
+	        var i;
+	        if (data.type === 'metadata') {
+	          i = data.tracks.length;
+
+	          // scan the tracks listed in the metadata
+	          while (i--) {
+	            if (!videoTrack && data.tracks[i].type === 'video') {
+	              videoTrack = data.tracks[i];
+	              videoTrack.duration = pipeline.duration / 2;
+	              videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+	            } else if (!audioTrack && data.tracks[i].type === 'audio') {
+	              audioTrack = data.tracks[i];
+	              audioTrack.duration = pipeline.duration / 2;
+	              audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+	            }
+	          }
+
+	          // hook up the video segment stream to the first track with h264 data
+	          if (videoTrack && !pipeline.videoSegmentStream) {
+	            pipeline.coalesceStream.numberOfTracks++;
+	            pipeline.videoSegmentStream = new _VideoSegmentStream(videoTrack, options);
+	            pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));
+	            pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {
+	              // When video emits timelineStartInfo data after a flush, we forward that
+	              // info to the AudioSegmentStream, if it exists, because video timeline
+	              // data takes precedence.  Do not do this if keepOriginalTimestamps is set,
+	              // because this is a particularly subtle form of timestamp alteration.
+	              if (audioTrack && !options.keepOriginalTimestamps) {
+	                audioTrack.timelineStartInfo = timelineStartInfo;
+	                // On the first segment we trim AAC frames that exist before the
+	                // very earliest DTS we have seen in video because Chrome will
+	                // interpret any video track with a baseMediaDecodeTime that is
+	                // non-zero as a gap.
+	                pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);
+	              }
+	            });
+	            pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));
+	            pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));
+	            pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {
+	              if (audioTrack) {
+	                pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);
+	              }
+	            });
+	            pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo'));
+
+	            // Set up the final part of the video pipeline
+	            pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);
+	          }
+	          if (audioTrack && !pipeline.audioSegmentStream) {
+	            // hook up the audio segment stream to the first track with aac data
+	            pipeline.coalesceStream.numberOfTracks++;
+	            pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+	            pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+	            pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+	            pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo'));
+
+	            // Set up the final part of the audio pipeline
+	            pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+	          }
+
+	          // emit pmt info
+	          self.trigger('trackinfo', {
+	            hasAudio: !!audioTrack,
+	            hasVideo: !!videoTrack
+	          });
+	        }
+	      });
+
+	      // Re-emit any data coming from the coalesce stream to the outside world
+	      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+	      pipeline.coalesceStream.on('id3Frame', function (id3Frame) {
+	        id3Frame.dispatchType = pipeline.metadataStream.dispatchType;
+	        self.trigger('id3Frame', id3Frame);
+	      });
+	      pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption'));
+	      // Let the consumer know we have finished flushing the entire pipeline
+	      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+	      addPipelineLogRetriggers(this, pipeline);
+	    };
+
+	    // hook up the segment streams once track metadata is delivered
+	    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+	      var pipeline = this.transmuxPipeline_;
+	      if (!options.keepOriginalTimestamps) {
+	        this.baseMediaDecodeTime = baseMediaDecodeTime;
+	      }
+	      if (audioTrack) {
+	        audioTrack.timelineStartInfo.dts = undefined;
+	        audioTrack.timelineStartInfo.pts = undefined;
+	        trackDecodeInfo.clearDtsInfo(audioTrack);
+	        if (pipeline.audioTimestampRolloverStream) {
+	          pipeline.audioTimestampRolloverStream.discontinuity();
+	        }
+	      }
+	      if (videoTrack) {
+	        if (pipeline.videoSegmentStream) {
+	          pipeline.videoSegmentStream.gopCache_ = [];
+	        }
+	        videoTrack.timelineStartInfo.dts = undefined;
+	        videoTrack.timelineStartInfo.pts = undefined;
+	        trackDecodeInfo.clearDtsInfo(videoTrack);
+	        pipeline.captionStream.reset();
+	      }
+	      if (pipeline.timestampRolloverStream) {
+	        pipeline.timestampRolloverStream.discontinuity();
+	      }
+	    };
+	    this.setAudioAppendStart = function (timestamp) {
+	      if (audioTrack) {
+	        this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);
+	      }
+	    };
+	    this.setRemux = function (val) {
+	      var pipeline = this.transmuxPipeline_;
+	      options.remux = val;
+	      if (pipeline && pipeline.coalesceStream) {
+	        pipeline.coalesceStream.setRemux(val);
+	      }
+	    };
+	    this.alignGopsWith = function (gopsToAlignWith) {
+	      if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {
+	        this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);
+	      }
+	    };
+	    this.getLogTrigger_ = function (key) {
+	      var self = this;
+	      return function (event) {
+	        event.stream = key;
+	        self.trigger('log', event);
+	      };
+	    };
+	    // feed incoming data to the front of the parsing pipeline
+	    this.push = function (data) {
+	      if (hasFlushed) {
+	        var isAac = isLikelyAacData(data);
+	        if (isAac && this.transmuxPipeline_.type !== 'aac') {
+	          this.setupAacPipeline();
+	        } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {
+	          this.setupTsPipeline();
+	        }
+	        hasFlushed = false;
+	      }
+	      this.transmuxPipeline_.headOfPipeline.push(data);
+	    };
+
+	    // flush any buffered data
+	    this.flush = function () {
+	      hasFlushed = true;
+	      // Start at the top of the pipeline and flush all pending work
+	      this.transmuxPipeline_.headOfPipeline.flush();
+	    };
+	    this.endTimeline = function () {
+	      this.transmuxPipeline_.headOfPipeline.endTimeline();
+	    };
+	    this.reset = function () {
+	      if (this.transmuxPipeline_.headOfPipeline) {
+	        this.transmuxPipeline_.headOfPipeline.reset();
+	      }
+	    };
+
+	    // Caption data has to be reset when seeking outside buffered range
+	    this.resetCaptions = function () {
+	      if (this.transmuxPipeline_.captionStream) {
+	        this.transmuxPipeline_.captionStream.reset();
+	      }
+	    };
+	  };
+	  _Transmuxer.prototype = new stream();
+	  var transmuxer = _Transmuxer;
+
+	  return transmuxer;
+
+	})); 
+} (mp4Transmuxer));
+
+var mp4TransmuxerExports = mp4Transmuxer.exports;
+var Transmuxer = /*@__PURE__*/getDefaultExportFromCjs(mp4TransmuxerExports);
+
 var aesJs = {exports: {}};
 
 /*! MIT License. Copyright 2015-2018 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */
@@ -882,7 +7322,23 @@ var aesJs = {exports: {}};
 var aesJsExports = aesJs.exports;
 var aesjs = /*@__PURE__*/getDefaultExportFromCjs(aesJsExports);
 
-var createFFmpeg = FFmpeg.createFFmpeg, fetchFile = FFmpeg.fetchFile;
+function fetchFile(url) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, arrayBuffer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch(url)];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    arrayBuffer = _a.sent();
+                    return [2 /*return*/, new Uint8Array(arrayBuffer)];
+            }
+        });
+    });
+}
+
 var TaskType;
 (function (TaskType) {
     TaskType[TaskType["loadFFmeg"] = 0] = "loadFFmeg";
@@ -901,11 +7357,11 @@ function parseUrl(url, path) {
 }
 var Hls2Mp4 = /** @class */ (function () {
     function Hls2Mp4(_a, onProgress) {
-        var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c, options = __rest(_a, ["maxRetry", "tsDownloadConcurrency"]);
+        var _b = _a.maxRetry, maxRetry = _b === void 0 ? 3 : _b, _c = _a.tsDownloadConcurrency, tsDownloadConcurrency = _c === void 0 ? 10 : _c;
         this.loadRetryTime = 0;
         this.totalSegments = 0;
-        this.savedSegments = 0;
-        this.instance = createFFmpeg(options);
+        this.duration = 0;
+        this.savedSegments = new Map();
         this.maxRetry = maxRetry;
         this.onProgress = onProgress;
         this.tsDownloadConcurrency = tsDownloadConcurrency;
@@ -1011,7 +7467,7 @@ var Hls2Mp4 = /** @class */ (function () {
             var _this = this;
             return __generator(this, function (_a) {
                 return [2 /*return*/, Promise.all(segs.map(function (_a) {
-                        var name = _a.name, url = _a.url, source = _a.source;
+                        var index = _a.index, url = _a.url;
                         return __awaiter(_this, void 0, void 0, function () {
                             var tsData, buffer;
                             var _b;
@@ -1021,14 +7477,9 @@ var Hls2Mp4 = /** @class */ (function () {
                                     case 1:
                                         tsData = _c.sent();
                                         buffer = key ? this.aesDecrypt(tsData, key, iv) : this.transformBuffer(tsData);
-                                        this.instance.FS('writeFile', name, buffer);
-                                        this.savedSegments += 1;
-                                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments / this.totalSegments);
-                                        return [2 /*return*/, {
-                                                source: source,
-                                                url: url,
-                                                name: name
-                                            }];
+                                        this.savedSegments.set(index, buffer);
+                                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.downloadTs, this.savedSegments.size / this.totalSegments);
+                                        return [2 /*return*/];
                                 }
                             });
                         });
@@ -1036,9 +7487,20 @@ var Hls2Mp4 = /** @class */ (function () {
             });
         });
     };
+    Hls2Mp4.prototype.computeTotalDuration = function (content) {
+        var duration = 0;
+        var tags = content.match(/#EXTINF:\d+(.\d+)?/gi);
+        tags === null || tags === void 0 ? void 0 : tags.forEach(function (tag) {
+            var dur = tag.match(/\d+(.\d+)?/);
+            if (dur) {
+                duration += Number(dur[0]);
+            }
+        });
+        return duration;
+    };
     Hls2Mp4.prototype.downloadM3u8 = function (url) {
         return __awaiter(this, void 0, void 0, function () {
-            var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1, m3u8;
+            var m3u8Parsed, _a, content, parsedUrl, keyMatchRegExp, keyTagMatchRegExp, matchReg, matches, segments, i, matched, matchedKey, matchedIV, batch, treatedSegments, segments_1, segments_1_1, group, total, keyBuffer, keyUrl, _loop_1, this_1, i, e_1_1;
             var e_1, _b;
             return __generator(this, function (_c) {
                 switch (_c.label) {
@@ -1053,31 +7515,29 @@ var Hls2Mp4 = /** @class */ (function () {
                         if (!matches) {
                             throw new Error('Invalid m3u8 file, no ts file found');
                         }
+                        this.duration = this.computeTotalDuration(content);
                         segments = [];
-                        if (matches) {
-                            for (i = 0; i < matches.length; i++) {
-                                matched = matches[i];
-                                if (matched.match(/#EXT-X-KEY/)) {
-                                    matchedKey = matched.match(keyMatchRegExp);
-                                    matchedIV = matched.match(/(?<=IV=)\w+$/);
-                                    segments.push({
-                                        key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
-                                        iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
-                                        segments: []
-                                    });
-                                }
-                                else if (i === 0) {
-                                    segments.push({
-                                        segments: [matched]
-                                    });
-                                }
-                                else {
-                                    segments[segments.length - 1].segments.push(matched);
-                                }
+                        for (i = 0; i < matches.length; i++) {
+                            matched = matches[i];
+                            if (matched.match(/#EXT-X-KEY/)) {
+                                matchedKey = matched.match(keyMatchRegExp);
+                                matchedIV = matched.match(/(?<=IV=)\w+$/);
+                                segments.push({
+                                    key: matchedKey === null || matchedKey === void 0 ? void 0 : matchedKey[0],
+                                    iv: matchedIV === null || matchedIV === void 0 ? void 0 : matchedIV[0],
+                                    segments: []
+                                });
+                            }
+                            else if (i === 0) {
+                                segments.push({
+                                    segments: [matched]
+                                });
+                            }
+                            else {
+                                segments[segments.length - 1].segments.push(matched);
                             }
                         }
                         this.totalSegments = segments.reduce(function (prev, current) { return prev + current.segments.length; }, 0);
-                        this.savedSegments = 0;
                         batch = this.tsDownloadConcurrency;
                         treatedSegments = 0;
                         _c.label = 2;
@@ -1098,34 +7558,17 @@ var Hls2Mp4 = /** @class */ (function () {
                         _c.label = 5;
                     case 5:
                         _loop_1 = function (i) {
-                            var downloadSegs, downloadSegs_1, downloadSegs_1_1, _d, source, name_1;
-                            var e_2, _e;
-                            return __generator(this, function (_f) {
-                                switch (_f.label) {
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
                                     case 0: return [4 /*yield*/, this_1.downloadSegments(group.segments.slice(i * batch, Math.min(total, (i + 1) * batch)).map(function (seg, j) {
                                             var url = parseUrl(parsedUrl, seg);
-                                            var name = "seg-".concat(treatedSegments + i * batch + j, ".ts");
                                             return {
-                                                source: seg,
-                                                url: url,
-                                                name: name
+                                                index: treatedSegments + i * batch + j,
+                                                url: url
                                             };
                                         }), keyBuffer, group.iv)];
                                     case 1:
-                                        downloadSegs = _f.sent();
-                                        try {
-                                            for (downloadSegs_1 = (e_2 = void 0, __values(downloadSegs)), downloadSegs_1_1 = downloadSegs_1.next(); !downloadSegs_1_1.done; downloadSegs_1_1 = downloadSegs_1.next()) {
-                                                _d = downloadSegs_1_1.value, source = _d.source, name_1 = _d.name;
-                                                content = content.replace(source, name_1);
-                                            }
-                                        }
-                                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                                        finally {
-                                            try {
-                                                if (downloadSegs_1_1 && !downloadSegs_1_1.done && (_e = downloadSegs_1.return)) _e.call(downloadSegs_1);
-                                            }
-                                            finally { if (e_2) throw e_2.error; }
-                                        }
+                                        _d.sent();
                                         return [2 /*return*/];
                                 }
                             });
@@ -1159,11 +7602,7 @@ var Hls2Mp4 = /** @class */ (function () {
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 14:
-                        content = content.replace(keyTagMatchRegExp, '');
-                        m3u8 = 'temp.m3u8';
-                        this.instance.FS('writeFile', m3u8, content);
-                        return [2 /*return*/, m3u8];
+                    case 14: return [2 /*return*/];
                 }
             });
         });
@@ -1198,49 +7637,100 @@ var Hls2Mp4 = /** @class */ (function () {
             });
         });
     };
-    Hls2Mp4.prototype.loadFFmpeg = function () {
+    Hls2Mp4.prototype.mergeDataArray = function (data) {
+        var e_2, _a;
+        var totalByteLength = data.reduce(function (prev, current) { return prev + current.byteLength; }, 0);
+        var dataArray = new Uint8Array(totalByteLength);
+        var byteOffset = 0;
+        try {
+            for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                var part = data_1_1.value;
+                dataArray.set(part, byteOffset);
+                byteOffset += part.byteLength;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return dataArray;
+    };
+    Hls2Mp4.prototype.transmuxerSegments = function () {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var done;
-            var _this = this;
+            var transmuxer, transmuxerFirstSegment, transmuxerSegment, chunks, i, segment, chunk, data;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.loadFFmeg, 0);
-                        return [4 /*yield*/, this.loopLoadFile(function () { return _this.instance.load(); })];
+                        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
+                        transmuxer = new Transmuxer({
+                            duration: this.duration
+                        });
+                        transmuxerFirstSegment = function (data) {
+                            return new Promise(function (resolve) {
+                                transmuxer.on('data', function (segment) {
+                                    var data = new Uint8Array(segment.initSegment.byteLength + segment.data.byteLength);
+                                    data.set(segment.initSegment, 0);
+                                    data.set(segment.data, segment.initSegment.byteLength);
+                                    resolve(data);
+                                });
+                                transmuxer.push(data);
+                                transmuxer.flush();
+                            });
+                        };
+                        transmuxerSegment = function (buffer) {
+                            return new Promise(function (resolve) {
+                                transmuxer.off('data');
+                                transmuxer.on('data', function (segment) { return resolve(segment.data); });
+                                transmuxer.push(buffer);
+                                transmuxer.flush();
+                            });
+                        };
+                        chunks = [];
+                        i = 0;
+                        _c.label = 1;
                     case 1:
-                        done = (_c.sent()).done;
-                        if (done) {
-                            (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.loadFFmeg, done ? 1 : -1);
-                        }
-                        else {
-                            throw new Error('FFmpeg load failed');
-                        }
-                        return [2 /*return*/];
+                        if (!(i < this.savedSegments.size)) return [3 /*break*/, 7];
+                        segment = this.savedSegments.get(i);
+                        chunk = void 0;
+                        if (!(i === 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, transmuxerFirstSegment(segment)];
+                    case 2:
+                        chunk = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, transmuxerSegment(segment)];
+                    case 4:
+                        chunk = _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        chunks.push(chunk);
+                        _c.label = 6;
+                    case 6:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 7:
+                        data = this.mergeDataArray(chunks);
+                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
+                        return [2 /*return*/, data];
                 }
             });
         });
     };
     Hls2Mp4.prototype.download = function (url) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var m3u8, data;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.loadFFmpeg()];
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.downloadM3u8(url)];
                     case 1:
-                        _c.sent();
-                        return [4 /*yield*/, this.downloadM3u8(url)];
+                        _a.sent();
+                        return [4 /*yield*/, this.transmuxerSegments()];
                     case 2:
-                        m3u8 = _c.sent();
-                        (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, TaskType.mergeTs, 0);
-                        return [4 /*yield*/, this.instance.run('-i', m3u8, '-c', 'copy', 'temp.mp4', '-loglevel', 'debug')];
-                    case 3:
-                        _c.sent();
-                        data = this.instance.FS('readFile', 'temp.mp4');
-                        this.instance.exit();
-                        (_b = this.onProgress) === null || _b === void 0 ? void 0 : _b.call(this, TaskType.mergeTs, 1);
-                        return [2 /*return*/, data.buffer];
+                        data = _a.sent();
+                        return [2 /*return*/, data];
                 }
             });
         });
@@ -1253,7 +7743,7 @@ var Hls2Mp4 = /** @class */ (function () {
         anchor.click();
         setTimeout(function () { return URL.revokeObjectURL(objectUrl); }, 100);
     };
-    Hls2Mp4.version = '1.1.8';
+    Hls2Mp4.version = '2.0';
     Hls2Mp4.TaskType = TaskType;
     return Hls2Mp4;
 }());
diff --git a/dist/util/http.d.ts b/dist/util/http.d.ts
new file mode 100644
index 0000000..3c435b6
--- /dev/null
+++ b/dist/util/http.d.ts
@@ -0,0 +1 @@
+export declare function fetchFile(url: string): Promise<Uint8Array>;
diff --git a/package.json b/package.json
index 681764e..ee53f04 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "hls2mp4",
-  "version": "1.1.8",
+  "version": "2.0.0",
   "description": "a tool for download hls/m3u8 to mp4",
   "main": "index.js",
   "types": "index.d.ts",
@@ -19,12 +19,11 @@
     "aes-js": "^3.1.2"
   },
   "devDependencies": {
-    "@ffmpeg/core": "^0.11.0",
-    "@ffmpeg/ffmpeg": "^0.11.6",
-    "@rollup/plugin-node-resolve": "^15.0.2",
     "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.2",
     "@rollup/plugin-typescript": "^11.1.0",
     "@types/aes-js": "^3.1.1",
+    "@types/node": "^20.2.5",
     "rollup": "^3.21.4",
     "tslib": "^2.0.0",
     "typescript": "^4.7.4"
@@ -43,4 +42,4 @@
       "last 1 safari version"
     ]
   }
-}
\ No newline at end of file
+}
diff --git a/rollup.config.mjs b/rollup.config.mjs
index 880f86e..ebbfc24 100644
--- a/rollup.config.mjs
+++ b/rollup.config.mjs
@@ -16,10 +16,7 @@ export default {
         {
             name: 'Hls2Mp4',
             format: 'umd',
-            file: './dist/hls2mp4.umd.js',
-            globals: {
-                '@ffmpeg/ffmpeg': 'FFmpeg'
-            }
+            file: './dist/hls2mp4.umd.js'
         },
         {
             format: 'cjs',
@@ -28,19 +25,12 @@ export default {
         {
             name: 'Hls2Mp4',
             format: 'iife',
-            file: './dist/hls2mp4.js',
-            globals: {
-                '@ffmpeg/ffmpeg': 'FFmpeg'
-            }
+            file: './dist/hls2mp4.js'
         }
     ],
     plugins: [
         typescript(),
         commonjs(),
         nodeResolve()
-    ],
-    external: [
-        '@ffmpeg/core',
-        '@ffmpeg/ffmpeg'
     ]
 }
diff --git a/src/index.ts b/src/index.ts
index efde3dd..bce10c6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,6 @@
-import FFmpeg, { type CreateFFmpegOptions, type FFmpeg as FFmpegInstance } from '@ffmpeg/ffmpeg';
+import Transmuxer from './muxer/mp4-transmuxer';
 import aesjs, { type ByteSource } from 'aes-js';
-
-const { createFFmpeg, fetchFile } = FFmpeg;
+import { fetchFile } from './util/http'
 
 enum TaskType {
     loadFFmeg = 0,
@@ -32,9 +31,8 @@ type Hls2Mp4Options = {
 }
 
 type Segment = {
-    source: string;
+    index: number;
     url: string;
-    name: string;
 }
 
 export interface M3u8Parsed {
@@ -61,18 +59,17 @@ function parseUrl(url: string, path: string) {
 
 class Hls2Mp4 {
 
-    private instance: FFmpegInstance;
     private maxRetry: number;
     private loadRetryTime = 0;
     private onProgress?: ProgressCallback;
     private tsDownloadConcurrency: number;
     private totalSegments = 0;
-    private savedSegments = 0;
-    public static version = '1.1.8';
+    private duration = 0;
+    private savedSegments = new Map<number, Uint8Array>()
+    public static version = '2.0';
     public static TaskType = TaskType;
 
-    constructor({ maxRetry = 3, tsDownloadConcurrency = 10, ...options }: CreateFFmpegOptions & Hls2Mp4Options, onProgress?: ProgressCallback) {
-        this.instance = createFFmpeg(options);
+    constructor({ maxRetry = 3, tsDownloadConcurrency = 10 }: Hls2Mp4Options, onProgress?: ProgressCallback) {
         this.maxRetry = maxRetry;
         this.onProgress = onProgress;
         this.tsDownloadConcurrency = tsDownloadConcurrency;
@@ -162,21 +159,29 @@ class Hls2Mp4 {
 
     private async downloadSegments(segs: Segment[], key?: Uint8Array, iv?: string) {
         return Promise.all(
-            segs.map(async ({ name, url, source }) => {
+            segs.map(async ({ index, url }) => {
                 const tsData = await this.downloadFile(url)
                 const buffer = key ? this.aesDecrypt(tsData!, key, iv) : this.transformBuffer(tsData!)
-                this.instance.FS('writeFile', name, buffer)
-                this.savedSegments += 1
-                this.onProgress?.(TaskType.downloadTs, this.savedSegments / this.totalSegments)
-                return {
-                    source,
-                    url,
-                    name
-                }
+                this.savedSegments.set(index, buffer)
+                this.onProgress?.(TaskType.downloadTs, this.savedSegments.size / this.totalSegments)
             })
         )
     }
 
+    private computeTotalDuration(content: string) {
+        let duration = 0;
+        const tags = content.match(/#EXTINF:\d+(.\d+)?/gi)
+        tags?.forEach(
+            tag => {
+                const dur = tag.match(/\d+(.\d+)?/)
+                if (dur) {
+                    duration += Number(dur[0]);
+                }
+            }
+        )
+        return duration;
+    }
+
     private async downloadM3u8(url: string) {
         const m3u8Parsed = await this.parseM3u8(url)
         let { content, url: parsedUrl } = m3u8Parsed!;
@@ -193,6 +198,9 @@ class Hls2Mp4 {
         if (!matches) {
             throw new Error('Invalid m3u8 file, no ts file found')
         }
+
+        this.duration = this.computeTotalDuration(content)
+
         const segments: SegmentGroup[] = []
         for (let i = 0; i < matches.length; i++) {
             const matched = matches[i]
@@ -216,7 +224,6 @@ class Hls2Mp4 {
         }
 
         this.totalSegments = segments.reduce((prev, current) => prev + current.segments.length, 0);
-        this.savedSegments = 0;
         const batch = this.tsDownloadConcurrency;
         let treatedSegments = 0;
 
@@ -231,34 +238,25 @@ class Hls2Mp4 {
 
             for (let i = 0; i <= Math.floor((total / batch)); i++) {
 
-                const downloadSegs = await this.downloadSegments(
+                await this.downloadSegments(
                     group.segments.slice(
                         i * batch,
                         Math.min(total, (i + 1) * batch)
                     ).map<Segment>(
                         (seg, j) => {
                             const url = parseUrl(parsedUrl, seg)
-                            const name = `seg-${treatedSegments + i * batch + j}.ts`
                             return {
-                                source: seg,
-                                url,
-                                name
+                                index: treatedSegments + i * batch + j,
+                                url
                             }
                         }
                     ),
                     keyBuffer,
                     group.iv
                 )
-                for (const { source, name } of downloadSegs) {
-                    content = content.replace(source, name)
-                }
             }
             treatedSegments += total;
         }
-        content = content.replace(keyTagMatchRegExp, '')
-        const m3u8 = 'temp.m3u8'
-        this.instance.FS('writeFile', m3u8, content)
-        return m3u8
     }
 
     private async loopLoadFile<T = undefined>(startLoad: () => PromiseLike<T | undefined>): Promise<LoadResult<T>> {
@@ -282,28 +280,84 @@ class Hls2Mp4 {
         }
     }
 
-    private async loadFFmpeg() {
-        this.onProgress?.(TaskType.loadFFmeg, 0)
-        const { done } = await this.loopLoadFile(
-            () => this.instance.load()
+    private mergeDataArray(data: Uint8Array[]) {
+
+        const totalByteLength = data.reduce(
+            (prev, current) => prev + current.byteLength,
+            0
         )
-        if (done) {
-            this.onProgress?.(TaskType.loadFFmeg, done ? 1 : -1);
-        }
-        else {
-            throw new Error('FFmpeg load failed')
+        const dataArray = new Uint8Array(totalByteLength)
+        let byteOffset = 0;
+
+        for (const part of data) {
+            dataArray.set(part, byteOffset)
+            byteOffset += part.byteLength
         }
+
+        return dataArray
     }
 
-    public async download(url: string) {
-        await this.loadFFmpeg();
-        const m3u8 = await this.downloadM3u8(url);
+    private async transmuxerSegments() {
+
         this.onProgress?.(TaskType.mergeTs, 0);
-        await this.instance.run('-i', m3u8, '-c', 'copy', 'temp.mp4', '-loglevel', 'debug');
-        const data = this.instance.FS('readFile', 'temp.mp4');
-        this.instance.exit();
+
+        const transmuxer = new Transmuxer({
+            duration: this.duration
+        })
+
+        const transmuxerFirstSegment = (data: Uint8Array) => {
+            return new Promise<Uint8Array>(
+                (resolve) => {
+                    transmuxer.on('data', (segment) => {
+                        const data = new Uint8Array(segment.initSegment.byteLength + segment.data.byteLength);
+                        data.set(segment.initSegment, 0);
+                        data.set(segment.data, segment.initSegment.byteLength);
+                        resolve(data);
+                    })
+                    transmuxer.push(data)
+                    transmuxer.flush()
+                }
+            )
+        }
+
+        const transmuxerSegment = (buffer: Uint8Array) => {
+            return new Promise<Uint8Array>(
+                (resolve) => {
+                    transmuxer.off('data')
+                    transmuxer.on('data', (segment) => resolve(segment.data))
+                    transmuxer.push(buffer)
+                    transmuxer.flush()
+                }
+            )
+        }
+
+        let chunks: Uint8Array[] = []
+
+        for (let i = 0; i < this.savedSegments.size; i++) {
+
+            const segment = this.savedSegments.get(i)
+            let chunk: Uint8Array;
+
+            if (i === 0) {
+                chunk = await transmuxerFirstSegment(segment!)
+            }
+            else {
+                chunk = await transmuxerSegment(segment!)
+            }
+            chunks.push(chunk);
+        }
+
+        const data = this.mergeDataArray(chunks)
+
         this.onProgress?.(TaskType.mergeTs, 1);
-        return data.buffer;
+
+        return data;
+    }
+
+    public async download(url: string) {
+        await this.downloadM3u8(url);
+        const data = await this.transmuxerSegments()
+        return data;
     }
 
     public saveToFile(buffer: ArrayBufferLike, filename: string) {
diff --git a/src/muxer/mp4-transmuxer.d.ts b/src/muxer/mp4-transmuxer.d.ts
new file mode 100644
index 0000000..faadc8a
--- /dev/null
+++ b/src/muxer/mp4-transmuxer.d.ts
@@ -0,0 +1,25 @@
+
+interface TransmuxerOptions {
+    duration: number;
+}
+
+interface TransmuxeSegment {
+    initSegment: Uint8Array;
+    data: Uint8Array;
+}
+
+interface transmuxerDataListener {
+    (data: TransmuxeSegment): void;
+}
+
+export default class Transmuxer {
+
+    constructor(options: TransmuxerOptions) { }
+
+    on(event: 'data', listener: transmuxerDataListener): void;
+    off(event: string): void;
+
+    push(data: Uint8Array): void;
+    flush(): void;
+}
+
diff --git a/src/muxer/mp4-transmuxer.js b/src/muxer/mp4-transmuxer.js
new file mode 100644
index 0000000..cb572d3
--- /dev/null
+++ b/src/muxer/mp4-transmuxer.js
@@ -0,0 +1,6446 @@
+/*! @name mux.js @version 6.3.0 @license Apache-2.0 */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.muxjs = factory());
+})(this, (function () { 'use strict';
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   *
+   * A lightweight readable stream implemention that handles event dispatching.
+   * Objects that inherit from streams should call init in their constructors.
+   */
+
+  var Stream = function Stream() {
+    this.init = function () {
+      var listeners = {};
+      /**
+       * Add a listener for a specified event type.
+       * @param type {string} the event name
+       * @param listener {function} the callback to be invoked when an event of
+       * the specified type occurs
+       */
+      this.on = function (type, listener) {
+        if (!listeners[type]) {
+          listeners[type] = [];
+        }
+        listeners[type] = listeners[type].concat(listener);
+      };
+      /**
+       * Remove a listener for a specified event type.
+       * @param type {string} the event name
+       * @param listener {function} a function previously registered for this
+       * type of event through `on`
+       */
+      this.off = function (type, listener) {
+        var index;
+        if (!listeners[type]) {
+          return false;
+        }
+        index = listeners[type].indexOf(listener);
+        listeners[type] = listeners[type].slice();
+        listeners[type].splice(index, 1);
+        return index > -1;
+      };
+      /**
+       * Trigger an event of the specified type on this stream. Any additional
+       * arguments to this function are passed as parameters to event listeners.
+       * @param type {string} the event name
+       */
+      this.trigger = function (type) {
+        var callbacks, i, length, args;
+        callbacks = listeners[type];
+        if (!callbacks) {
+          return;
+        }
+        // Slicing the arguments on every invocation of this method
+        // can add a significant amount of overhead. Avoid the
+        // intermediate object creation for the common case of a
+        // single callback argument
+        if (arguments.length === 2) {
+          length = callbacks.length;
+          for (i = 0; i < length; ++i) {
+            callbacks[i].call(this, arguments[1]);
+          }
+        } else {
+          args = [];
+          i = arguments.length;
+          for (i = 1; i < arguments.length; ++i) {
+            args.push(arguments[i]);
+          }
+          length = callbacks.length;
+          for (i = 0; i < length; ++i) {
+            callbacks[i].apply(this, args);
+          }
+        }
+      };
+      /**
+       * Destroys the stream and cleans up.
+       */
+      this.dispose = function () {
+        listeners = {};
+      };
+    };
+  };
+
+  /**
+   * Forwards all `data` events on this stream to the destination stream. The
+   * destination stream should provide a method `push` to receive the data
+   * events as they arrive.
+   * @param destination {stream} the stream that will receive all `data` events
+   * @param autoFlush {boolean} if false, we will not call `flush` on the destination
+   *                            when the current stream emits a 'done' event
+   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
+   */
+  Stream.prototype.pipe = function (destination) {
+    this.on('data', function (data) {
+      destination.push(data);
+    });
+    this.on('done', function (flushSource) {
+      destination.flush(flushSource);
+    });
+    this.on('partialdone', function (flushSource) {
+      destination.partialFlush(flushSource);
+    });
+    this.on('endedtimeline', function (flushSource) {
+      destination.endTimeline(flushSource);
+    });
+    this.on('reset', function (flushSource) {
+      destination.reset(flushSource);
+    });
+    return destination;
+  };
+
+  // Default stream functions that are expected to be overridden to perform
+  // actual work. These are provided by the prototype as a sort of no-op
+  // implementation so that we don't have to check for their existence in the
+  // `pipe` function above.
+  Stream.prototype.push = function (data) {
+    this.trigger('data', data);
+  };
+  Stream.prototype.flush = function (flushSource) {
+    this.trigger('done', flushSource);
+  };
+  Stream.prototype.partialFlush = function (flushSource) {
+    this.trigger('partialdone', flushSource);
+  };
+  Stream.prototype.endTimeline = function (flushSource) {
+    this.trigger('endedtimeline', flushSource);
+  };
+  Stream.prototype.reset = function (flushSource) {
+    this.trigger('reset', flushSource);
+  };
+  var stream = Stream;
+
+  var MAX_UINT32$1 = Math.pow(2, 32);
+  var getUint64 = function getUint64(uint8) {
+    var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+    var value;
+    if (dv.getBigUint64) {
+      value = dv.getBigUint64(0);
+      if (value < Number.MAX_SAFE_INTEGER) {
+        return Number(value);
+      }
+      return value;
+    }
+    return dv.getUint32(0) * MAX_UINT32$1 + dv.getUint32(4);
+  };
+  var numbers = {
+    getUint64: getUint64,
+    MAX_UINT32: MAX_UINT32$1
+  };
+
+  var MAX_UINT32 = numbers.MAX_UINT32;
+  var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS;
+
+  // pre-calculate constants
+  (function () {
+    var i;
+    types = {
+      avc1: [],
+      // codingname
+      avcC: [],
+      btrt: [],
+      dinf: [],
+      dref: [],
+      esds: [],
+      ftyp: [],
+      hdlr: [],
+      mdat: [],
+      mdhd: [],
+      mdia: [],
+      mfhd: [],
+      minf: [],
+      moof: [],
+      moov: [],
+      mp4a: [],
+      // codingname
+      mvex: [],
+      mvhd: [],
+      pasp: [],
+      sdtp: [],
+      smhd: [],
+      stbl: [],
+      stco: [],
+      stsc: [],
+      stsd: [],
+      stsz: [],
+      stts: [],
+      styp: [],
+      tfdt: [],
+      tfhd: [],
+      traf: [],
+      trak: [],
+      trun: [],
+      trex: [],
+      tkhd: [],
+      vmhd: []
+    };
+
+    // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we
+    // don't throw an error
+    if (typeof Uint8Array === 'undefined') {
+      return;
+    }
+    for (i in types) {
+      if (types.hasOwnProperty(i)) {
+        types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
+      }
+    }
+    MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);
+    AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);
+    MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);
+    VIDEO_HDLR = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x00,
+    // pre_defined
+    0x76, 0x69, 0x64, 0x65,
+    // handler_type: 'vide'
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
+    ]);
+
+    AUDIO_HDLR = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x00,
+    // pre_defined
+    0x73, 0x6f, 0x75, 0x6e,
+    // handler_type: 'soun'
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
+    ]);
+
+    HDLR_TYPES = {
+      video: VIDEO_HDLR,
+      audio: AUDIO_HDLR
+    };
+    DREF = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x01,
+    // entry_count
+    0x00, 0x00, 0x00, 0x0c,
+    // entry_size
+    0x75, 0x72, 0x6c, 0x20,
+    // 'url' type
+    0x00,
+    // version 0
+    0x00, 0x00, 0x01 // entry_flags
+    ]);
+
+    SMHD = new Uint8Array([0x00,
+    // version
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00,
+    // balance, 0 means centered
+    0x00, 0x00 // reserved
+    ]);
+
+    STCO = new Uint8Array([0x00,
+    // version
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x00 // entry_count
+    ]);
+
+    STSC = STCO;
+    STSZ = new Uint8Array([0x00,
+    // version
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x00,
+    // sample_size
+    0x00, 0x00, 0x00, 0x00 // sample_count
+    ]);
+
+    STTS = STCO;
+    VMHD = new Uint8Array([0x00,
+    // version
+    0x00, 0x00, 0x01,
+    // flags
+    0x00, 0x00,
+    // graphicsmode
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
+    ]);
+  })();
+
+  box = function box(type) {
+    var payload = [],
+      size = 0,
+      i,
+      result,
+      view;
+    for (i = 1; i < arguments.length; i++) {
+      payload.push(arguments[i]);
+    }
+    i = payload.length;
+
+    // calculate the total size we need to allocate
+    while (i--) {
+      size += payload[i].byteLength;
+    }
+    result = new Uint8Array(size + 8);
+    view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+    view.setUint32(0, result.byteLength);
+    result.set(type, 4);
+
+    // copy the payload into the result
+    for (i = 0, size = 8; i < payload.length; i++) {
+      result.set(payload[i], size);
+      size += payload[i].byteLength;
+    }
+    return result;
+  };
+  dinf = function dinf() {
+    return box(types.dinf, box(types.dref, DREF));
+  };
+  esds = function esds(track) {
+    return box(types.esds, new Uint8Array([0x00,
+    // version
+    0x00, 0x00, 0x00,
+    // flags
+
+    // ES_Descriptor
+    0x03,
+    // tag, ES_DescrTag
+    0x19,
+    // length
+    0x00, 0x00,
+    // ES_ID
+    0x00,
+    // streamDependenceFlag, URL_flag, reserved, streamPriority
+
+    // DecoderConfigDescriptor
+    0x04,
+    // tag, DecoderConfigDescrTag
+    0x11,
+    // length
+    0x40,
+    // object type
+    0x15,
+    // streamType
+    0x00, 0x06, 0x00,
+    // bufferSizeDB
+    0x00, 0x00, 0xda, 0xc0,
+    // maxBitrate
+    0x00, 0x00, 0xda, 0xc0,
+    // avgBitrate
+
+    // DecoderSpecificInfo
+    0x05,
+    // tag, DecoderSpecificInfoTag
+    0x02,
+    // length
+    // ISO/IEC 14496-3, AudioSpecificConfig
+    // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
+    track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig
+    ]));
+  };
+
+  ftyp = function ftyp() {
+    return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);
+  };
+  hdlr = function hdlr(type) {
+    return box(types.hdlr, HDLR_TYPES[type]);
+  };
+  mdat = function mdat(data) {
+    return box(types.mdat, data);
+  };
+  mdhd = function mdhd(track) {
+    var result = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x02,
+    // creation_time
+    0x00, 0x00, 0x00, 0x03,
+    // modification_time
+    0x00, 0x01, 0x5f, 0x90,
+    // timescale, 90,000 "ticks" per second
+
+    track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF,
+    // duration
+    0x55, 0xc4,
+    // 'und' language (undetermined)
+    0x00, 0x00]);
+
+    // Use the sample rate from the track metadata, when it is
+    // defined. The sample rate can be parsed out of an ADTS header, for
+    // instance.
+    if (track.samplerate) {
+      result[12] = track.samplerate >>> 24 & 0xFF;
+      result[13] = track.samplerate >>> 16 & 0xFF;
+      result[14] = track.samplerate >>> 8 & 0xFF;
+      result[15] = track.samplerate & 0xFF;
+    }
+    return box(types.mdhd, result);
+  };
+  mdia = function mdia(track) {
+    return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));
+  };
+  mfhd = function mfhd(sequenceNumber) {
+    return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
+    // flags
+    (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number
+    ]));
+  };
+
+  minf = function minf(track) {
+    return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));
+  };
+  moof = function moof(sequenceNumber, tracks) {
+    var trackFragments = [],
+      i = tracks.length;
+    // build traf boxes for each track fragment
+    while (i--) {
+      trackFragments[i] = traf(tracks[i]);
+    }
+    return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));
+  };
+  /**
+   * Returns a movie box.
+   * @param tracks {array} the tracks associated with this movie
+   * @see ISO/IEC 14496-12:2012(E), section 8.2.1
+   */
+  moov = function moov(tracks, duration) {
+    var i = tracks.length,
+      boxes = [];
+    while (i--) {
+      boxes[i] = trak(tracks[i]);
+    }
+    return box.apply(null, [types.moov, mvhd(duration || 0xffffffff)].concat(boxes).concat(mvex(tracks)));
+  };
+  mvex = function mvex(tracks) {
+    var i = tracks.length,
+      boxes = [];
+    while (i--) {
+      boxes[i] = trex(tracks[i]);
+    }
+    return box.apply(null, [types.mvex].concat(boxes));
+  };
+  mvhd = function mvhd(duration) {
+    var bytes = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x00,
+    // flags
+    0x00, 0x00, 0x00, 0x01,
+    // creation_time
+    0x00, 0x00, 0x00, 0x02,
+    // modification_time
+    0x00, 0x01, 0x5f, 0x90,
+    // timescale, 90,000 "ticks" per second
+    (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF,
+    // duration
+    0x00, 0x01, 0x00, 0x00,
+    // 1.0 rate
+    0x01, 0x00,
+    // 1.0 volume
+    0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    // transformation: unity matrix
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    // pre_defined
+    0xff, 0xff, 0xff, 0xff // next_track_ID
+    ]);
+
+    return box(types.mvhd, bytes);
+  };
+  sdtp = function sdtp(track) {
+    var samples = track.samples || [],
+      bytes = new Uint8Array(4 + samples.length),
+      flags,
+      i;
+
+    // leave the full box header (4 bytes) all zero
+
+    // write the sample table
+    for (i = 0; i < samples.length; i++) {
+      flags = samples[i].flags;
+      bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
+    }
+    return box(types.sdtp, bytes);
+  };
+  stbl = function stbl(track) {
+    return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));
+  };
+  (function () {
+    var videoSample, audioSample;
+    stsd = function stsd(track) {
+      return box(types.stsd, new Uint8Array([0x00,
+      // version 0
+      0x00, 0x00, 0x00,
+      // flags
+      0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));
+    };
+    videoSample = function videoSample(track) {
+      var sps = track.sps || [],
+        pps = track.pps || [],
+        sequenceParameterSets = [],
+        pictureParameterSets = [],
+        i,
+        avc1Box;
+
+      // assemble the SPSs
+      for (i = 0; i < sps.length; i++) {
+        sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);
+        sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength
+        sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS
+      }
+
+      // assemble the PPSs
+      for (i = 0; i < pps.length; i++) {
+        pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);
+        pictureParameterSets.push(pps[i].byteLength & 0xFF);
+        pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));
+      }
+      avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      // reserved
+      0x00, 0x01,
+      // data_reference_index
+      0x00, 0x00,
+      // pre_defined
+      0x00, 0x00,
+      // reserved
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      // pre_defined
+      (track.width & 0xff00) >> 8, track.width & 0xff,
+      // width
+      (track.height & 0xff00) >> 8, track.height & 0xff,
+      // height
+      0x00, 0x48, 0x00, 0x00,
+      // horizresolution
+      0x00, 0x48, 0x00, 0x00,
+      // vertresolution
+      0x00, 0x00, 0x00, 0x00,
+      // reserved
+      0x00, 0x01,
+      // frame_count
+      0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      // compressorname
+      0x00, 0x18,
+      // depth = 24
+      0x11, 0x11 // pre_defined = -1
+      ]), box(types.avcC, new Uint8Array([0x01,
+      // configurationVersion
+      track.profileIdc,
+      // AVCProfileIndication
+      track.profileCompatibility,
+      // profile_compatibility
+      track.levelIdc,
+      // AVCLevelIndication
+      0xff // lengthSizeMinusOne, hard-coded to 4 bytes
+      ].concat([sps.length],
+      // numOfSequenceParameterSets
+      sequenceParameterSets,
+      // "SPS"
+      [pps.length],
+      // numOfPictureParameterSets
+      pictureParameterSets // "PPS"
+      ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
+      // bufferSizeDB
+      0x00, 0x2d, 0xc6, 0xc0,
+      // maxBitrate
+      0x00, 0x2d, 0xc6, 0xc0 // avgBitrate
+      ]))];
+
+      if (track.sarRatio) {
+        var hSpacing = track.sarRatio[0],
+          vSpacing = track.sarRatio[1];
+        avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));
+      }
+      return box.apply(null, avc1Box);
+    };
+    audioSample = function audioSample(track) {
+      return box(types.mp4a, new Uint8Array([
+      // SampleEntry, ISO/IEC 14496-12
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      // reserved
+      0x00, 0x01,
+      // data_reference_index
+
+      // AudioSampleEntry, ISO/IEC 14496-12
+      0x00, 0x00, 0x00, 0x00,
+      // reserved
+      0x00, 0x00, 0x00, 0x00,
+      // reserved
+      (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff,
+      // channelcount
+
+      (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff,
+      // samplesize
+      0x00, 0x00,
+      // pre_defined
+      0x00, 0x00,
+      // reserved
+
+      (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16
+
+      // MP4AudioSampleEntry, ISO/IEC 14496-14
+      ]), esds(track));
+    };
+  })();
+  tkhd = function tkhd(track) {
+    var result = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x07,
+    // flags
+    0x00, 0x00, 0x00, 0x00,
+    // creation_time
+    0x00, 0x00, 0x00, 0x00,
+    // modification_time
+    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    // track_ID
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF,
+    // duration
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00,
+    // layer
+    0x00, 0x00,
+    // alternate_group
+    0x01, 0x00,
+    // non-audio track volume
+    0x00, 0x00,
+    // reserved
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    // transformation: unity matrix
+    (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00,
+    // width
+    (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height
+    ]);
+
+    return box(types.tkhd, result);
+  };
+
+  /**
+   * Generate a track fragment (traf) box. A traf box collects metadata
+   * about tracks in a movie fragment (moof) box.
+   */
+  traf = function traf(track) {
+    var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;
+    trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x3a,
+    // flags
+    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    // track_ID
+    0x00, 0x00, 0x00, 0x01,
+    // sample_description_index
+    0x00, 0x00, 0x00, 0x00,
+    // default_sample_duration
+    0x00, 0x00, 0x00, 0x00,
+    // default_sample_size
+    0x00, 0x00, 0x00, 0x00 // default_sample_flags
+    ]));
+
+    upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / MAX_UINT32);
+    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % MAX_UINT32);
+    trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01,
+    // version 1
+    0x00, 0x00, 0x00,
+    // flags
+    // baseMediaDecodeTime
+    upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF]));
+
+    // the data offset specifies the number of bytes from the start of
+    // the containing moof to the first payload byte of the associated
+    // mdat
+    dataOffset = 32 +
+    // tfhd
+    20 +
+    // tfdt
+    8 +
+    // traf header
+    16 +
+    // mfhd
+    8 +
+    // moof header
+    8; // mdat header
+
+    // audio tracks require less metadata
+    if (track.type === 'audio') {
+      trackFragmentRun = trun(track, dataOffset);
+      return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);
+    }
+
+    // video tracks should contain an independent and disposable samples
+    // box (sdtp)
+    // generate one and adjust offsets to match
+    sampleDependencyTable = sdtp(track);
+    trackFragmentRun = trun(track, sampleDependencyTable.length + dataOffset);
+    return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);
+  };
+
+  /**
+   * Generate a track box.
+   * @param track {object} a track definition
+   * @return {Uint8Array} the track box
+   */
+  trak = function trak(track) {
+    track.duration = track.duration || 0xffffffff;
+    return box(types.trak, tkhd(track), mdia(track));
+  };
+  trex = function trex(track) {
+    var result = new Uint8Array([0x00,
+    // version 0
+    0x00, 0x00, 0x00,
+    // flags
+    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF,
+    // track_ID
+    0x00, 0x00, 0x00, 0x01,
+    // default_sample_description_index
+    0x00, 0x00, 0x00, 0x00,
+    // default_sample_duration
+    0x00, 0x00, 0x00, 0x00,
+    // default_sample_size
+    0x00, 0x01, 0x00, 0x01 // default_sample_flags
+    ]);
+    // the last two bytes of default_sample_flags is the sample
+    // degradation priority, a hint about the importance of this sample
+    // relative to others. Lower the degradation priority for all sample
+    // types other than video.
+    if (track.type !== 'video') {
+      result[result.length - 1] = 0x00;
+    }
+    return box(types.trex, result);
+  };
+  (function () {
+    var audioTrun, videoTrun, trunHeader;
+
+    // This method assumes all samples are uniform. That is, if a
+    // duration is present for the first sample, it will be present for
+    // all subsequent samples.
+    // see ISO/IEC 14496-12:2012, Section 8.8.8.1
+    trunHeader = function trunHeader(samples, offset) {
+      var durationPresent = 0,
+        sizePresent = 0,
+        flagsPresent = 0,
+        compositionTimeOffset = 0;
+
+      // trun flag constants
+      if (samples.length) {
+        if (samples[0].duration !== undefined) {
+          durationPresent = 0x1;
+        }
+        if (samples[0].size !== undefined) {
+          sizePresent = 0x2;
+        }
+        if (samples[0].flags !== undefined) {
+          flagsPresent = 0x4;
+        }
+        if (samples[0].compositionTimeOffset !== undefined) {
+          compositionTimeOffset = 0x8;
+        }
+      }
+      return [0x00,
+      // version 0
+      0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01,
+      // flags
+      (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF,
+      // sample_count
+      (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset
+      ];
+    };
+
+    videoTrun = function videoTrun(track, offset) {
+      var bytesOffest, bytes, header, samples, sample, i;
+      samples = track.samples || [];
+      offset += 8 + 12 + 16 * samples.length;
+      header = trunHeader(samples, offset);
+      bytes = new Uint8Array(header.length + samples.length * 16);
+      bytes.set(header);
+      bytesOffest = header.length;
+      for (i = 0; i < samples.length; i++) {
+        sample = samples[i];
+        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+        bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;
+        bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;
+        bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;
+        bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags
+        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;
+        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;
+        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;
+        bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset
+      }
+
+      return box(types.trun, bytes);
+    };
+    audioTrun = function audioTrun(track, offset) {
+      var bytes, bytesOffest, header, samples, sample, i;
+      samples = track.samples || [];
+      offset += 8 + 12 + 8 * samples.length;
+      header = trunHeader(samples, offset);
+      bytes = new Uint8Array(header.length + samples.length * 8);
+      bytes.set(header);
+      bytesOffest = header.length;
+      for (i = 0; i < samples.length; i++) {
+        sample = samples[i];
+        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;
+        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;
+        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;
+        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration
+        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;
+        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;
+        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;
+        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size
+      }
+
+      return box(types.trun, bytes);
+    };
+    trun = function trun(track, offset) {
+      if (track.type === 'audio') {
+        return audioTrun(track, offset);
+      }
+      return videoTrun(track, offset);
+    };
+  })();
+  var mp4Generator = {
+    ftyp: ftyp,
+    mdat: mdat,
+    moof: moof,
+    moov: moov,
+    initSegment: function initSegment(tracks) {
+      var duration = tracks.reduce(function (p, n) {
+        return p + n.duration;
+      }, 0);
+      var fileType = ftyp(),
+        movie = moov(tracks, duration),
+        result;
+      result = new Uint8Array(fileType.byteLength + movie.byteLength);
+      result.set(fileType);
+      result.set(movie, fileType.byteLength);
+      return result;
+    }
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+  // Convert an array of nal units into an array of frames with each frame being
+  // composed of the nal units that make up that frame
+  // Also keep track of cummulative data about the frame from the nal units such
+  // as the frame duration, starting pts, etc.
+  var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {
+    var i,
+      currentNal,
+      currentFrame = [],
+      frames = [];
+
+    // TODO added for LHLS, make sure this is OK
+    frames.byteLength = 0;
+    frames.nalCount = 0;
+    frames.duration = 0;
+    currentFrame.byteLength = 0;
+    for (i = 0; i < nalUnits.length; i++) {
+      currentNal = nalUnits[i];
+
+      // Split on 'aud'-type nal units
+      if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
+        // Since the very first nal unit is expected to be an AUD
+        // only push to the frames array when currentFrame is not empty
+        if (currentFrame.length) {
+          currentFrame.duration = currentNal.dts - currentFrame.dts;
+          // TODO added for LHLS, make sure this is OK
+          frames.byteLength += currentFrame.byteLength;
+          frames.nalCount += currentFrame.length;
+          frames.duration += currentFrame.duration;
+          frames.push(currentFrame);
+        }
+        currentFrame = [currentNal];
+        currentFrame.byteLength = currentNal.data.byteLength;
+        currentFrame.pts = currentNal.pts;
+        currentFrame.dts = currentNal.dts;
+      } else {
+        // Specifically flag key frames for ease of use later
+        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
+          currentFrame.keyFrame = true;
+        }
+        currentFrame.duration = currentNal.dts - currentFrame.dts;
+        currentFrame.byteLength += currentNal.data.byteLength;
+        currentFrame.push(currentNal);
+      }
+    }
+
+    // For the last frame, use the duration of the previous frame if we
+    // have nothing better to go on
+    if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {
+      currentFrame.duration = frames[frames.length - 1].duration;
+    }
+
+    // Push the final frame
+    // TODO added for LHLS, make sure this is OK
+    frames.byteLength += currentFrame.byteLength;
+    frames.nalCount += currentFrame.length;
+    frames.duration += currentFrame.duration;
+    frames.push(currentFrame);
+    return frames;
+  };
+
+  // Convert an array of frames into an array of Gop with each Gop being composed
+  // of the frames that make up that Gop
+  // Also keep track of cummulative data about the Gop from the frames such as the
+  // Gop duration, starting pts, etc.
+  var groupFramesIntoGops = function groupFramesIntoGops(frames) {
+    var i,
+      currentFrame,
+      currentGop = [],
+      gops = [];
+
+    // We must pre-set some of the values on the Gop since we
+    // keep running totals of these values
+    currentGop.byteLength = 0;
+    currentGop.nalCount = 0;
+    currentGop.duration = 0;
+    currentGop.pts = frames[0].pts;
+    currentGop.dts = frames[0].dts;
+
+    // store some metadata about all the Gops
+    gops.byteLength = 0;
+    gops.nalCount = 0;
+    gops.duration = 0;
+    gops.pts = frames[0].pts;
+    gops.dts = frames[0].dts;
+    for (i = 0; i < frames.length; i++) {
+      currentFrame = frames[i];
+      if (currentFrame.keyFrame) {
+        // Since the very first frame is expected to be an keyframe
+        // only push to the gops array when currentGop is not empty
+        if (currentGop.length) {
+          gops.push(currentGop);
+          gops.byteLength += currentGop.byteLength;
+          gops.nalCount += currentGop.nalCount;
+          gops.duration += currentGop.duration;
+        }
+        currentGop = [currentFrame];
+        currentGop.nalCount = currentFrame.length;
+        currentGop.byteLength = currentFrame.byteLength;
+        currentGop.pts = currentFrame.pts;
+        currentGop.dts = currentFrame.dts;
+        currentGop.duration = currentFrame.duration;
+      } else {
+        currentGop.duration += currentFrame.duration;
+        currentGop.nalCount += currentFrame.length;
+        currentGop.byteLength += currentFrame.byteLength;
+        currentGop.push(currentFrame);
+      }
+    }
+    if (gops.length && currentGop.duration <= 0) {
+      currentGop.duration = gops[gops.length - 1].duration;
+    }
+    gops.byteLength += currentGop.byteLength;
+    gops.nalCount += currentGop.nalCount;
+    gops.duration += currentGop.duration;
+
+    // push the final Gop
+    gops.push(currentGop);
+    return gops;
+  };
+
+  /*
+   * Search for the first keyframe in the GOPs and throw away all frames
+   * until that keyframe. Then extend the duration of the pulled keyframe
+   * and pull the PTS and DTS of the keyframe so that it covers the time
+   * range of the frames that were disposed.
+   *
+   * @param {Array} gops video GOPs
+   * @returns {Array} modified video GOPs
+   */
+  var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {
+    var currentGop;
+    if (!gops[0][0].keyFrame && gops.length > 1) {
+      // Remove the first GOP
+      currentGop = gops.shift();
+      gops.byteLength -= currentGop.byteLength;
+      gops.nalCount -= currentGop.nalCount;
+
+      // Extend the first frame of what is now the
+      // first gop to cover the time period of the
+      // frames we just removed
+      gops[0][0].dts = currentGop.dts;
+      gops[0][0].pts = currentGop.pts;
+      gops[0][0].duration += currentGop.duration;
+    }
+    return gops;
+  };
+
+  /**
+   * Default sample object
+   * see ISO/IEC 14496-12:2012, section 8.6.4.3
+   */
+  var createDefaultSample = function createDefaultSample() {
+    return {
+      size: 0,
+      flags: {
+        isLeading: 0,
+        dependsOn: 1,
+        isDependedOn: 0,
+        hasRedundancy: 0,
+        degradationPriority: 0,
+        isNonSyncSample: 1
+      }
+    };
+  };
+
+  /*
+   * Collates information from a video frame into an object for eventual
+   * entry into an MP4 sample table.
+   *
+   * @param {Object} frame the video frame
+   * @param {Number} dataOffset the byte offset to position the sample
+   * @return {Object} object containing sample table info for a frame
+   */
+  var sampleForFrame = function sampleForFrame(frame, dataOffset) {
+    var sample = createDefaultSample();
+    sample.dataOffset = dataOffset;
+    sample.compositionTimeOffset = frame.pts - frame.dts;
+    sample.duration = frame.duration;
+    sample.size = 4 * frame.length; // Space for nal unit size
+    sample.size += frame.byteLength;
+    if (frame.keyFrame) {
+      sample.flags.dependsOn = 2;
+      sample.flags.isNonSyncSample = 0;
+    }
+    return sample;
+  };
+
+  // generate the track's sample table from an array of gops
+  var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {
+    var h,
+      i,
+      sample,
+      currentGop,
+      currentFrame,
+      dataOffset = baseDataOffset || 0,
+      samples = [];
+    for (h = 0; h < gops.length; h++) {
+      currentGop = gops[h];
+      for (i = 0; i < currentGop.length; i++) {
+        currentFrame = currentGop[i];
+        sample = sampleForFrame(currentFrame, dataOffset);
+        dataOffset += sample.size;
+        samples.push(sample);
+      }
+    }
+    return samples;
+  };
+
+  // generate the track's raw mdat data from an array of gops
+  var concatenateNalData = function concatenateNalData(gops) {
+    var h,
+      i,
+      j,
+      currentGop,
+      currentFrame,
+      currentNal,
+      dataOffset = 0,
+      nalsByteLength = gops.byteLength,
+      numberOfNals = gops.nalCount,
+      totalByteLength = nalsByteLength + 4 * numberOfNals,
+      data = new Uint8Array(totalByteLength),
+      view = new DataView(data.buffer);
+
+    // For each Gop..
+    for (h = 0; h < gops.length; h++) {
+      currentGop = gops[h];
+
+      // For each Frame..
+      for (i = 0; i < currentGop.length; i++) {
+        currentFrame = currentGop[i];
+
+        // For each NAL..
+        for (j = 0; j < currentFrame.length; j++) {
+          currentNal = currentFrame[j];
+          view.setUint32(dataOffset, currentNal.data.byteLength);
+          dataOffset += 4;
+          data.set(currentNal.data, dataOffset);
+          dataOffset += currentNal.data.byteLength;
+        }
+      }
+    }
+    return data;
+  };
+
+  // generate the track's sample table from a frame
+  var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {
+    var sample,
+      dataOffset = baseDataOffset || 0,
+      samples = [];
+    sample = sampleForFrame(frame, dataOffset);
+    samples.push(sample);
+    return samples;
+  };
+
+  // generate the track's raw mdat data from a frame
+  var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {
+    var i,
+      currentNal,
+      dataOffset = 0,
+      nalsByteLength = frame.byteLength,
+      numberOfNals = frame.length,
+      totalByteLength = nalsByteLength + 4 * numberOfNals,
+      data = new Uint8Array(totalByteLength),
+      view = new DataView(data.buffer);
+
+    // For each NAL..
+    for (i = 0; i < frame.length; i++) {
+      currentNal = frame[i];
+      view.setUint32(dataOffset, currentNal.data.byteLength);
+      dataOffset += 4;
+      data.set(currentNal.data, dataOffset);
+      dataOffset += currentNal.data.byteLength;
+    }
+    return data;
+  };
+  var frameUtils = {
+    groupNalsIntoFrames: groupNalsIntoFrames,
+    groupFramesIntoGops: groupFramesIntoGops,
+    extendFirstKeyFrame: extendFirstKeyFrame,
+    generateSampleTable: generateSampleTable$1,
+    concatenateNalData: concatenateNalData,
+    generateSampleTableForFrame: generateSampleTableForFrame,
+    concatenateNalDataForFrame: concatenateNalDataForFrame
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+  var highPrefix = [33, 16, 5, 32, 164, 27];
+  var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];
+  var zeroFill = function zeroFill(count) {
+    var a = [];
+    while (count--) {
+      a.push(0);
+    }
+    return a;
+  };
+  var makeTable = function makeTable(metaTable) {
+    return Object.keys(metaTable).reduce(function (obj, key) {
+      obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {
+        return arr.concat(part);
+      }, []));
+      return obj;
+    }, {});
+  };
+  var silence;
+  var silence_1 = function silence_1() {
+    if (!silence) {
+      // Frames-of-silence to use for filling in missing AAC frames
+      var coneOfSilence = {
+        96000: [highPrefix, [227, 64], zeroFill(154), [56]],
+        88200: [highPrefix, [231], zeroFill(170), [56]],
+        64000: [highPrefix, [248, 192], zeroFill(240), [56]],
+        48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],
+        44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],
+        32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],
+        24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],
+        16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],
+        12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],
+        11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],
+        8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]
+      };
+      silence = makeTable(coneOfSilence);
+    }
+    return silence;
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+  var ONE_SECOND_IN_TS$3 = 90000,
+    // 90kHz clock
+    secondsToVideoTs,
+    secondsToAudioTs,
+    videoTsToSeconds,
+    audioTsToSeconds,
+    audioTsToVideoTs,
+    videoTsToAudioTs,
+    metadataTsToSeconds;
+  secondsToVideoTs = function secondsToVideoTs(seconds) {
+    return seconds * ONE_SECOND_IN_TS$3;
+  };
+  secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {
+    return seconds * sampleRate;
+  };
+  videoTsToSeconds = function videoTsToSeconds(timestamp) {
+    return timestamp / ONE_SECOND_IN_TS$3;
+  };
+  audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {
+    return timestamp / sampleRate;
+  };
+  audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {
+    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
+  };
+  videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {
+    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
+  };
+
+  /**
+   * Adjust ID3 tag or caption timing information by the timeline pts values
+   * (if keepOriginalTimestamps is false) and convert to seconds
+   */
+  metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {
+    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
+  };
+  var clock = {
+    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$3,
+    secondsToVideoTs: secondsToVideoTs,
+    secondsToAudioTs: secondsToAudioTs,
+    videoTsToSeconds: videoTsToSeconds,
+    audioTsToSeconds: audioTsToSeconds,
+    audioTsToVideoTs: audioTsToVideoTs,
+    videoTsToAudioTs: videoTsToAudioTs,
+    metadataTsToSeconds: metadataTsToSeconds
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+
+  /**
+   * Sum the `byteLength` properties of the data in each AAC frame
+   */
+  var sumFrameByteLengths = function sumFrameByteLengths(array) {
+    var i,
+      currentObj,
+      sum = 0;
+
+    // sum the byteLength's all each nal unit in the frame
+    for (i = 0; i < array.length; i++) {
+      currentObj = array[i];
+      sum += currentObj.data.byteLength;
+    }
+    return sum;
+  };
+
+  // Possibly pad (prefix) the audio track with silence if appending this track
+  // would lead to the introduction of a gap in the audio buffer
+  var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {
+    var baseMediaDecodeTimeTs,
+      frameDuration = 0,
+      audioGapDuration = 0,
+      audioFillFrameCount = 0,
+      audioFillDuration = 0,
+      silentFrame,
+      i,
+      firstFrame;
+    if (!frames.length) {
+      return;
+    }
+    baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate);
+    // determine frame clock duration based on sample rate, round up to avoid overfills
+    frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));
+    if (audioAppendStartTs && videoBaseMediaDecodeTime) {
+      // insert the shortest possible amount (audio gap or audio to video gap)
+      audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime);
+      // number of full frames in the audio gap
+      audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);
+      audioFillDuration = audioFillFrameCount * frameDuration;
+    }
+
+    // don't attempt to fill gaps smaller than a single frame or larger
+    // than a half second
+    if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {
+      return;
+    }
+    silentFrame = silence_1()[track.samplerate];
+    if (!silentFrame) {
+      // we don't have a silent frame pregenerated for the sample rate, so use a frame
+      // from the content instead
+      silentFrame = frames[0].data;
+    }
+    for (i = 0; i < audioFillFrameCount; i++) {
+      firstFrame = frames[0];
+      frames.splice(0, 0, {
+        data: silentFrame,
+        dts: firstFrame.dts - frameDuration,
+        pts: firstFrame.pts - frameDuration
+      });
+    }
+    track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));
+    return audioFillDuration;
+  };
+
+  // If the audio segment extends before the earliest allowed dts
+  // value, remove AAC frames until starts at or after the earliest
+  // allowed DTS so that we don't end up with a negative baseMedia-
+  // DecodeTime for the audio track
+  var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {
+    if (track.minSegmentDts >= earliestAllowedDts) {
+      return adtsFrames;
+    }
+
+    // We will need to recalculate the earliest segment Dts
+    track.minSegmentDts = Infinity;
+    return adtsFrames.filter(function (currentFrame) {
+      // If this is an allowed frame, keep it and record it's Dts
+      if (currentFrame.dts >= earliestAllowedDts) {
+        track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);
+        track.minSegmentPts = track.minSegmentDts;
+        return true;
+      }
+      // Otherwise, discard it
+      return false;
+    });
+  };
+
+  // generate the track's raw mdat data from an array of frames
+  var generateSampleTable = function generateSampleTable(frames) {
+    var i,
+      currentFrame,
+      samples = [];
+    for (i = 0; i < frames.length; i++) {
+      currentFrame = frames[i];
+      samples.push({
+        size: currentFrame.data.byteLength,
+        duration: 1024 // For AAC audio, all samples contain 1024 samples
+      });
+    }
+
+    return samples;
+  };
+
+  // generate the track's sample table from an array of frames
+  var concatenateFrameData = function concatenateFrameData(frames) {
+    var i,
+      currentFrame,
+      dataOffset = 0,
+      data = new Uint8Array(sumFrameByteLengths(frames));
+    for (i = 0; i < frames.length; i++) {
+      currentFrame = frames[i];
+      data.set(currentFrame.data, dataOffset);
+      dataOffset += currentFrame.data.byteLength;
+    }
+    return data;
+  };
+  var audioFrameUtils = {
+    prefixWithSilence: prefixWithSilence,
+    trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,
+    generateSampleTable: generateSampleTable,
+    concatenateFrameData: concatenateFrameData
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+  var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS;
+
+  /**
+   * Store information about the start and end of the track and the
+   * duration for each frame/sample we process in order to calculate
+   * the baseMediaDecodeTime
+   */
+  var collectDtsInfo = function collectDtsInfo(track, data) {
+    if (typeof data.pts === 'number') {
+      if (track.timelineStartInfo.pts === undefined) {
+        track.timelineStartInfo.pts = data.pts;
+      }
+      if (track.minSegmentPts === undefined) {
+        track.minSegmentPts = data.pts;
+      } else {
+        track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);
+      }
+      if (track.maxSegmentPts === undefined) {
+        track.maxSegmentPts = data.pts;
+      } else {
+        track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);
+      }
+    }
+    if (typeof data.dts === 'number') {
+      if (track.timelineStartInfo.dts === undefined) {
+        track.timelineStartInfo.dts = data.dts;
+      }
+      if (track.minSegmentDts === undefined) {
+        track.minSegmentDts = data.dts;
+      } else {
+        track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);
+      }
+      if (track.maxSegmentDts === undefined) {
+        track.maxSegmentDts = data.dts;
+      } else {
+        track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);
+      }
+    }
+  };
+
+  /**
+   * Clear values used to calculate the baseMediaDecodeTime between
+   * tracks
+   */
+  var clearDtsInfo = function clearDtsInfo(track) {
+    delete track.minSegmentDts;
+    delete track.maxSegmentDts;
+    delete track.minSegmentPts;
+    delete track.maxSegmentPts;
+  };
+
+  /**
+   * Calculate the track's baseMediaDecodeTime based on the earliest
+   * DTS the transmuxer has ever seen and the minimum DTS for the
+   * current track
+   * @param track {object} track metadata configuration
+   * @param keepOriginalTimestamps {boolean} If true, keep the timestamps
+   *        in the source; false to adjust the first segment to start at 0.
+   */
+  var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {
+    var baseMediaDecodeTime,
+      scale,
+      minSegmentDts = track.minSegmentDts;
+
+    // Optionally adjust the time so the first segment starts at zero.
+    if (!keepOriginalTimestamps) {
+      minSegmentDts -= track.timelineStartInfo.dts;
+    }
+
+    // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where
+    // we want the start of the first segment to be placed
+    baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime;
+
+    // Add to that the distance this segment is from the very first
+    baseMediaDecodeTime += minSegmentDts;
+
+    // baseMediaDecodeTime must not become negative
+    baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);
+    if (track.type === 'audio') {
+      // Audio has a different clock equal to the sampling_rate so we need to
+      // scale the PTS values into the clock rate of the track
+      scale = track.samplerate / ONE_SECOND_IN_TS$2;
+      baseMediaDecodeTime *= scale;
+      baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);
+    }
+    return baseMediaDecodeTime;
+  };
+  var trackDecodeInfo = {
+    clearDtsInfo: clearDtsInfo,
+    calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,
+    collectDtsInfo: collectDtsInfo
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   *
+   * Reads in-band caption information from a video elementary
+   * stream. Captions must follow the CEA-708 standard for injection
+   * into an MPEG-2 transport streams.
+   * @see https://en.wikipedia.org/wiki/CEA-708
+   * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf
+   */
+
+  // Supplemental enhancement information (SEI) NAL units have a
+  // payload type field to indicate how they are to be
+  // interpreted. CEAS-708 caption content is always transmitted with
+  // payload type 0x04.
+  var USER_DATA_REGISTERED_ITU_T_T35 = 4,
+    RBSP_TRAILING_BITS = 128;
+
+  /**
+    * Parse a supplemental enhancement information (SEI) NAL unit.
+    * Stops parsing once a message of type ITU T T35 has been found.
+    *
+    * @param bytes {Uint8Array} the bytes of a SEI NAL unit
+    * @return {object} the parsed SEI payload
+    * @see Rec. ITU-T H.264, 7.3.2.3.1
+    */
+  var parseSei = function parseSei(bytes) {
+    var i = 0,
+      result = {
+        payloadType: -1,
+        payloadSize: 0
+      },
+      payloadType = 0,
+      payloadSize = 0;
+
+    // go through the sei_rbsp parsing each each individual sei_message
+    while (i < bytes.byteLength) {
+      // stop once we have hit the end of the sei_rbsp
+      if (bytes[i] === RBSP_TRAILING_BITS) {
+        break;
+      }
+
+      // Parse payload type
+      while (bytes[i] === 0xFF) {
+        payloadType += 255;
+        i++;
+      }
+      payloadType += bytes[i++];
+
+      // Parse payload size
+      while (bytes[i] === 0xFF) {
+        payloadSize += 255;
+        i++;
+      }
+      payloadSize += bytes[i++];
+
+      // this sei_message is a 608/708 caption so save it and break
+      // there can only ever be one caption message in a frame's sei
+      if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {
+        var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);
+        if (userIdentifier === 'GA94') {
+          result.payloadType = payloadType;
+          result.payloadSize = payloadSize;
+          result.payload = bytes.subarray(i, i + payloadSize);
+          break;
+        } else {
+          result.payload = void 0;
+        }
+      }
+
+      // skip the payload and parse the next message
+      i += payloadSize;
+      payloadType = 0;
+      payloadSize = 0;
+    }
+    return result;
+  };
+
+  // see ANSI/SCTE 128-1 (2013), section 8.1
+  var parseUserData = function parseUserData(sei) {
+    // itu_t_t35_contry_code must be 181 (United States) for
+    // captions
+    if (sei.payload[0] !== 181) {
+      return null;
+    }
+
+    // itu_t_t35_provider_code should be 49 (ATSC) for captions
+    if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {
+      return null;
+    }
+
+    // the user_identifier should be "GA94" to indicate ATSC1 data
+    if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {
+      return null;
+    }
+
+    // finally, user_data_type_code should be 0x03 for caption data
+    if (sei.payload[7] !== 0x03) {
+      return null;
+    }
+
+    // return the user_data_type_structure and strip the trailing
+    // marker bits
+    return sei.payload.subarray(8, sei.payload.length - 1);
+  };
+
+  // see CEA-708-D, section 4.4
+  var parseCaptionPackets = function parseCaptionPackets(pts, userData) {
+    var results = [],
+      i,
+      count,
+      offset,
+      data;
+
+    // if this is just filler, return immediately
+    if (!(userData[0] & 0x40)) {
+      return results;
+    }
+
+    // parse out the cc_data_1 and cc_data_2 fields
+    count = userData[0] & 0x1f;
+    for (i = 0; i < count; i++) {
+      offset = i * 3;
+      data = {
+        type: userData[offset + 2] & 0x03,
+        pts: pts
+      };
+
+      // capture cc data when cc_valid is 1
+      if (userData[offset + 2] & 0x04) {
+        data.ccData = userData[offset + 3] << 8 | userData[offset + 4];
+        results.push(data);
+      }
+    }
+    return results;
+  };
+  var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+    var length = data.byteLength,
+      emulationPreventionBytesPositions = [],
+      i = 1,
+      newLength,
+      newData;
+
+    // Find all `Emulation Prevention Bytes`
+    while (i < length - 2) {
+      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+        emulationPreventionBytesPositions.push(i + 2);
+        i += 2;
+      } else {
+        i++;
+      }
+    }
+
+    // If no Emulation Prevention Bytes were found just return the original
+    // array
+    if (emulationPreventionBytesPositions.length === 0) {
+      return data;
+    }
+
+    // Create a new array to hold the NAL unit data
+    newLength = length - emulationPreventionBytesPositions.length;
+    newData = new Uint8Array(newLength);
+    var sourceIndex = 0;
+    for (i = 0; i < newLength; sourceIndex++, i++) {
+      if (sourceIndex === emulationPreventionBytesPositions[0]) {
+        // Skip this byte
+        sourceIndex++;
+        // Remove this position index
+        emulationPreventionBytesPositions.shift();
+      }
+      newData[i] = data[sourceIndex];
+    }
+    return newData;
+  };
+
+  // exports
+  var captionPacketParser = {
+    parseSei: parseSei,
+    parseUserData: parseUserData,
+    parseCaptionPackets: parseCaptionPackets,
+    discardEmulationPreventionBytes: discardEmulationPreventionBytes,
+    USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35
+  };
+
+  // -----------------
+  // Link To Transport
+  // -----------------
+
+  var CaptionStream = function CaptionStream(options) {
+    options = options || {};
+    CaptionStream.prototype.init.call(this);
+
+    // parse708captions flag, default to true
+    this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;
+    this.captionPackets_ = [];
+    this.ccStreams_ = [new Cea608Stream(0, 0),
+    // eslint-disable-line no-use-before-define
+    new Cea608Stream(0, 1),
+    // eslint-disable-line no-use-before-define
+    new Cea608Stream(1, 0),
+    // eslint-disable-line no-use-before-define
+    new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define
+    ];
+
+    if (this.parse708captions_) {
+      this.cc708Stream_ = new Cea708Stream({
+        captionServices: options.captionServices
+      }); // eslint-disable-line no-use-before-define
+    }
+
+    this.reset();
+
+    // forward data and done events from CCs to this CaptionStream
+    this.ccStreams_.forEach(function (cc) {
+      cc.on('data', this.trigger.bind(this, 'data'));
+      cc.on('partialdone', this.trigger.bind(this, 'partialdone'));
+      cc.on('done', this.trigger.bind(this, 'done'));
+    }, this);
+    if (this.parse708captions_) {
+      this.cc708Stream_.on('data', this.trigger.bind(this, 'data'));
+      this.cc708Stream_.on('partialdone', this.trigger.bind(this, 'partialdone'));
+      this.cc708Stream_.on('done', this.trigger.bind(this, 'done'));
+    }
+  };
+  CaptionStream.prototype = new stream();
+  CaptionStream.prototype.push = function (event) {
+    var sei, userData, newCaptionPackets;
+
+    // only examine SEI NALs
+    if (event.nalUnitType !== 'sei_rbsp') {
+      return;
+    }
+
+    // parse the sei
+    sei = captionPacketParser.parseSei(event.escapedRBSP);
+
+    // no payload data, skip
+    if (!sei.payload) {
+      return;
+    }
+
+    // ignore everything but user_data_registered_itu_t_t35
+    if (sei.payloadType !== captionPacketParser.USER_DATA_REGISTERED_ITU_T_T35) {
+      return;
+    }
+
+    // parse out the user data payload
+    userData = captionPacketParser.parseUserData(sei);
+
+    // ignore unrecognized userData
+    if (!userData) {
+      return;
+    }
+
+    // Sometimes, the same segment # will be downloaded twice. To stop the
+    // caption data from being processed twice, we track the latest dts we've
+    // received and ignore everything with a dts before that. However, since
+    // data for a specific dts can be split across packets on either side of
+    // a segment boundary, we need to make sure we *don't* ignore the packets
+    // from the *next* segment that have dts === this.latestDts_. By constantly
+    // tracking the number of packets received with dts === this.latestDts_, we
+    // know how many should be ignored once we start receiving duplicates.
+    if (event.dts < this.latestDts_) {
+      // We've started getting older data, so set the flag.
+      this.ignoreNextEqualDts_ = true;
+      return;
+    } else if (event.dts === this.latestDts_ && this.ignoreNextEqualDts_) {
+      this.numSameDts_--;
+      if (!this.numSameDts_) {
+        // We've received the last duplicate packet, time to start processing again
+        this.ignoreNextEqualDts_ = false;
+      }
+      return;
+    }
+
+    // parse out CC data packets and save them for later
+    newCaptionPackets = captionPacketParser.parseCaptionPackets(event.pts, userData);
+    this.captionPackets_ = this.captionPackets_.concat(newCaptionPackets);
+    if (this.latestDts_ !== event.dts) {
+      this.numSameDts_ = 0;
+    }
+    this.numSameDts_++;
+    this.latestDts_ = event.dts;
+  };
+  CaptionStream.prototype.flushCCStreams = function (flushType) {
+    this.ccStreams_.forEach(function (cc) {
+      return flushType === 'flush' ? cc.flush() : cc.partialFlush();
+    }, this);
+  };
+  CaptionStream.prototype.flushStream = function (flushType) {
+    // make sure we actually parsed captions before proceeding
+    if (!this.captionPackets_.length) {
+      this.flushCCStreams(flushType);
+      return;
+    }
+
+    // In Chrome, the Array#sort function is not stable so add a
+    // presortIndex that we can use to ensure we get a stable-sort
+    this.captionPackets_.forEach(function (elem, idx) {
+      elem.presortIndex = idx;
+    });
+
+    // sort caption byte-pairs based on their PTS values
+    this.captionPackets_.sort(function (a, b) {
+      if (a.pts === b.pts) {
+        return a.presortIndex - b.presortIndex;
+      }
+      return a.pts - b.pts;
+    });
+    this.captionPackets_.forEach(function (packet) {
+      if (packet.type < 2) {
+        // Dispatch packet to the right Cea608Stream
+        this.dispatchCea608Packet(packet);
+      } else {
+        // Dispatch packet to the Cea708Stream
+        this.dispatchCea708Packet(packet);
+      }
+    }, this);
+    this.captionPackets_.length = 0;
+    this.flushCCStreams(flushType);
+  };
+  CaptionStream.prototype.flush = function () {
+    return this.flushStream('flush');
+  };
+
+  // Only called if handling partial data
+  CaptionStream.prototype.partialFlush = function () {
+    return this.flushStream('partialFlush');
+  };
+  CaptionStream.prototype.reset = function () {
+    this.latestDts_ = null;
+    this.ignoreNextEqualDts_ = false;
+    this.numSameDts_ = 0;
+    this.activeCea608Channel_ = [null, null];
+    this.ccStreams_.forEach(function (ccStream) {
+      ccStream.reset();
+    });
+  };
+
+  // From the CEA-608 spec:
+  /*
+   * When XDS sub-packets are interleaved with other services, the end of each sub-packet shall be followed
+   * by a control pair to change to a different service. When any of the control codes from 0x10 to 0x1F is
+   * used to begin a control code pair, it indicates the return to captioning or Text data. The control code pair
+   * and subsequent data should then be processed according to the FCC rules. It may be necessary for the
+   * line 21 data encoder to automatically insert a control code pair (i.e. RCL, RU2, RU3, RU4, RDC, or RTD)
+   * to switch to captioning or Text.
+  */
+  // With that in mind, we ignore any data between an XDS control code and a
+  // subsequent closed-captioning control code.
+  CaptionStream.prototype.dispatchCea608Packet = function (packet) {
+    // NOTE: packet.type is the CEA608 field
+    if (this.setsTextOrXDSActive(packet)) {
+      this.activeCea608Channel_[packet.type] = null;
+    } else if (this.setsChannel1Active(packet)) {
+      this.activeCea608Channel_[packet.type] = 0;
+    } else if (this.setsChannel2Active(packet)) {
+      this.activeCea608Channel_[packet.type] = 1;
+    }
+    if (this.activeCea608Channel_[packet.type] === null) {
+      // If we haven't received anything to set the active channel, or the
+      // packets are Text/XDS data, discard the data; we don't want jumbled
+      // captions
+      return;
+    }
+    this.ccStreams_[(packet.type << 1) + this.activeCea608Channel_[packet.type]].push(packet);
+  };
+  CaptionStream.prototype.setsChannel1Active = function (packet) {
+    return (packet.ccData & 0x7800) === 0x1000;
+  };
+  CaptionStream.prototype.setsChannel2Active = function (packet) {
+    return (packet.ccData & 0x7800) === 0x1800;
+  };
+  CaptionStream.prototype.setsTextOrXDSActive = function (packet) {
+    return (packet.ccData & 0x7100) === 0x0100 || (packet.ccData & 0x78fe) === 0x102a || (packet.ccData & 0x78fe) === 0x182a;
+  };
+  CaptionStream.prototype.dispatchCea708Packet = function (packet) {
+    if (this.parse708captions_) {
+      this.cc708Stream_.push(packet);
+    }
+  };
+
+  // ----------------------
+  // Session to Application
+  // ----------------------
+
+  // This hash maps special and extended character codes to their
+  // proper Unicode equivalent. The first one-byte key is just a
+  // non-standard character code. The two-byte keys that follow are
+  // the extended CEA708 character codes, along with the preceding
+  // 0x10 extended character byte to distinguish these codes from
+  // non-extended character codes. Every CEA708 character code that
+  // is not in this object maps directly to a standard unicode
+  // character code.
+  // The transparent space and non-breaking transparent space are
+  // technically not fully supported since there is no code to
+  // make them transparent, so they have normal non-transparent
+  // stand-ins.
+  // The special closed caption (CC) character isn't a standard
+  // unicode character, so a fairly similar unicode character was
+  // chosen in it's place.
+  var CHARACTER_TRANSLATION_708 = {
+    0x7f: 0x266a,
+    // ♪
+    0x1020: 0x20,
+    // Transparent Space
+    0x1021: 0xa0,
+    // Nob-breaking Transparent Space
+    0x1025: 0x2026,
+    // …
+    0x102a: 0x0160,
+    // Š
+    0x102c: 0x0152,
+    // Œ
+    0x1030: 0x2588,
+    // █
+    0x1031: 0x2018,
+    // ‘
+    0x1032: 0x2019,
+    // ’
+    0x1033: 0x201c,
+    // “
+    0x1034: 0x201d,
+    // ”
+    0x1035: 0x2022,
+    // •
+    0x1039: 0x2122,
+    // ™
+    0x103a: 0x0161,
+    // š
+    0x103c: 0x0153,
+    // œ
+    0x103d: 0x2120,
+    // ℠
+    0x103f: 0x0178,
+    // Ÿ
+    0x1076: 0x215b,
+    // ⅛
+    0x1077: 0x215c,
+    // ⅜
+    0x1078: 0x215d,
+    // ⅝
+    0x1079: 0x215e,
+    // ⅞
+    0x107a: 0x23d0,
+    // ⏐
+    0x107b: 0x23a4,
+    // ⎤
+    0x107c: 0x23a3,
+    // ⎣
+    0x107d: 0x23af,
+    // ⎯
+    0x107e: 0x23a6,
+    // ⎦
+    0x107f: 0x23a1,
+    // ⎡
+    0x10a0: 0x3138 // ㄸ (CC char)
+  };
+
+  var get708CharFromCode = function get708CharFromCode(code) {
+    var newCode = CHARACTER_TRANSLATION_708[code] || code;
+    if (code & 0x1000 && code === newCode) {
+      // Invalid extended code
+      return '';
+    }
+    return String.fromCharCode(newCode);
+  };
+  var within708TextBlock = function within708TextBlock(b) {
+    return 0x20 <= b && b <= 0x7f || 0xa0 <= b && b <= 0xff;
+  };
+  var Cea708Window = function Cea708Window(windowNum) {
+    this.windowNum = windowNum;
+    this.reset();
+  };
+  Cea708Window.prototype.reset = function () {
+    this.clearText();
+    this.pendingNewLine = false;
+    this.winAttr = {};
+    this.penAttr = {};
+    this.penLoc = {};
+    this.penColor = {};
+
+    // These default values are arbitrary,
+    // defineWindow will usually override them
+    this.visible = 0;
+    this.rowLock = 0;
+    this.columnLock = 0;
+    this.priority = 0;
+    this.relativePositioning = 0;
+    this.anchorVertical = 0;
+    this.anchorHorizontal = 0;
+    this.anchorPoint = 0;
+    this.rowCount = 1;
+    this.virtualRowCount = this.rowCount + 1;
+    this.columnCount = 41;
+    this.windowStyle = 0;
+    this.penStyle = 0;
+  };
+  Cea708Window.prototype.getText = function () {
+    return this.rows.join('\n');
+  };
+  Cea708Window.prototype.clearText = function () {
+    this.rows = [''];
+    this.rowIdx = 0;
+  };
+  Cea708Window.prototype.newLine = function (pts) {
+    if (this.rows.length >= this.virtualRowCount && typeof this.beforeRowOverflow === 'function') {
+      this.beforeRowOverflow(pts);
+    }
+    if (this.rows.length > 0) {
+      this.rows.push('');
+      this.rowIdx++;
+    }
+
+    // Show all virtual rows since there's no visible scrolling
+    while (this.rows.length > this.virtualRowCount) {
+      this.rows.shift();
+      this.rowIdx--;
+    }
+  };
+  Cea708Window.prototype.isEmpty = function () {
+    if (this.rows.length === 0) {
+      return true;
+    } else if (this.rows.length === 1) {
+      return this.rows[0] === '';
+    }
+    return false;
+  };
+  Cea708Window.prototype.addText = function (text) {
+    this.rows[this.rowIdx] += text;
+  };
+  Cea708Window.prototype.backspace = function () {
+    if (!this.isEmpty()) {
+      var row = this.rows[this.rowIdx];
+      this.rows[this.rowIdx] = row.substr(0, row.length - 1);
+    }
+  };
+  var Cea708Service = function Cea708Service(serviceNum, encoding, stream) {
+    this.serviceNum = serviceNum;
+    this.text = '';
+    this.currentWindow = new Cea708Window(-1);
+    this.windows = [];
+    this.stream = stream;
+
+    // Try to setup a TextDecoder if an `encoding` value was provided
+    if (typeof encoding === 'string') {
+      this.createTextDecoder(encoding);
+    }
+  };
+
+  /**
+   * Initialize service windows
+   * Must be run before service use
+   *
+   * @param  {Integer}  pts               PTS value
+   * @param  {Function} beforeRowOverflow Function to execute before row overflow of a window
+   */
+  Cea708Service.prototype.init = function (pts, beforeRowOverflow) {
+    this.startPts = pts;
+    for (var win = 0; win < 8; win++) {
+      this.windows[win] = new Cea708Window(win);
+      if (typeof beforeRowOverflow === 'function') {
+        this.windows[win].beforeRowOverflow = beforeRowOverflow;
+      }
+    }
+  };
+
+  /**
+   * Set current window of service to be affected by commands
+   *
+   * @param  {Integer} windowNum Window number
+   */
+  Cea708Service.prototype.setCurrentWindow = function (windowNum) {
+    this.currentWindow = this.windows[windowNum];
+  };
+
+  /**
+   * Try to create a TextDecoder if it is natively supported
+   */
+  Cea708Service.prototype.createTextDecoder = function (encoding) {
+    if (typeof TextDecoder === 'undefined') {
+      this.stream.trigger('log', {
+        level: 'warn',
+        message: 'The `encoding` option is unsupported without TextDecoder support'
+      });
+    } else {
+      try {
+        this.textDecoder_ = new TextDecoder(encoding);
+      } catch (error) {
+        this.stream.trigger('log', {
+          level: 'warn',
+          message: 'TextDecoder could not be created with ' + encoding + ' encoding. ' + error
+        });
+      }
+    }
+  };
+  var Cea708Stream = function Cea708Stream(options) {
+    options = options || {};
+    Cea708Stream.prototype.init.call(this);
+    var self = this;
+    var captionServices = options.captionServices || {};
+    var captionServiceEncodings = {};
+    var serviceProps;
+
+    // Get service encodings from captionServices option block
+    Object.keys(captionServices).forEach(function (serviceName) {
+      serviceProps = captionServices[serviceName];
+      if (/^SERVICE/.test(serviceName)) {
+        captionServiceEncodings[serviceName] = serviceProps.encoding;
+      }
+    });
+    this.serviceEncodings = captionServiceEncodings;
+    this.current708Packet = null;
+    this.services = {};
+    this.push = function (packet) {
+      if (packet.type === 3) {
+        // 708 packet start
+        self.new708Packet();
+        self.add708Bytes(packet);
+      } else {
+        if (self.current708Packet === null) {
+          // This should only happen at the start of a file if there's no packet start.
+          self.new708Packet();
+        }
+        self.add708Bytes(packet);
+      }
+    };
+  };
+  Cea708Stream.prototype = new stream();
+
+  /**
+   * Push current 708 packet, create new 708 packet.
+   */
+  Cea708Stream.prototype.new708Packet = function () {
+    if (this.current708Packet !== null) {
+      this.push708Packet();
+    }
+    this.current708Packet = {
+      data: [],
+      ptsVals: []
+    };
+  };
+
+  /**
+   * Add pts and both bytes from packet into current 708 packet.
+   */
+  Cea708Stream.prototype.add708Bytes = function (packet) {
+    var data = packet.ccData;
+    var byte0 = data >>> 8;
+    var byte1 = data & 0xff;
+
+    // I would just keep a list of packets instead of bytes, but it isn't clear in the spec
+    // that service blocks will always line up with byte pairs.
+    this.current708Packet.ptsVals.push(packet.pts);
+    this.current708Packet.data.push(byte0);
+    this.current708Packet.data.push(byte1);
+  };
+
+  /**
+   * Parse completed 708 packet into service blocks and push each service block.
+   */
+  Cea708Stream.prototype.push708Packet = function () {
+    var packet708 = this.current708Packet;
+    var packetData = packet708.data;
+    var serviceNum = null;
+    var blockSize = null;
+    var i = 0;
+    var b = packetData[i++];
+    packet708.seq = b >> 6;
+    packet708.sizeCode = b & 0x3f; // 0b00111111;
+
+    for (; i < packetData.length; i++) {
+      b = packetData[i++];
+      serviceNum = b >> 5;
+      blockSize = b & 0x1f; // 0b00011111
+
+      if (serviceNum === 7 && blockSize > 0) {
+        // Extended service num
+        b = packetData[i++];
+        serviceNum = b;
+      }
+      this.pushServiceBlock(serviceNum, i, blockSize);
+      if (blockSize > 0) {
+        i += blockSize - 1;
+      }
+    }
+  };
+
+  /**
+   * Parse service block, execute commands, read text.
+   *
+   * Note: While many of these commands serve important purposes,
+   * many others just parse out the parameters or attributes, but
+   * nothing is done with them because this is not a full and complete
+   * implementation of the entire 708 spec.
+   *
+   * @param  {Integer} serviceNum Service number
+   * @param  {Integer} start      Start index of the 708 packet data
+   * @param  {Integer} size       Block size
+   */
+  Cea708Stream.prototype.pushServiceBlock = function (serviceNum, start, size) {
+    var b;
+    var i = start;
+    var packetData = this.current708Packet.data;
+    var service = this.services[serviceNum];
+    if (!service) {
+      service = this.initService(serviceNum, i);
+    }
+    for (; i < start + size && i < packetData.length; i++) {
+      b = packetData[i];
+      if (within708TextBlock(b)) {
+        i = this.handleText(i, service);
+      } else if (b === 0x18) {
+        i = this.multiByteCharacter(i, service);
+      } else if (b === 0x10) {
+        i = this.extendedCommands(i, service);
+      } else if (0x80 <= b && b <= 0x87) {
+        i = this.setCurrentWindow(i, service);
+      } else if (0x98 <= b && b <= 0x9f) {
+        i = this.defineWindow(i, service);
+      } else if (b === 0x88) {
+        i = this.clearWindows(i, service);
+      } else if (b === 0x8c) {
+        i = this.deleteWindows(i, service);
+      } else if (b === 0x89) {
+        i = this.displayWindows(i, service);
+      } else if (b === 0x8a) {
+        i = this.hideWindows(i, service);
+      } else if (b === 0x8b) {
+        i = this.toggleWindows(i, service);
+      } else if (b === 0x97) {
+        i = this.setWindowAttributes(i, service);
+      } else if (b === 0x90) {
+        i = this.setPenAttributes(i, service);
+      } else if (b === 0x91) {
+        i = this.setPenColor(i, service);
+      } else if (b === 0x92) {
+        i = this.setPenLocation(i, service);
+      } else if (b === 0x8f) {
+        service = this.reset(i, service);
+      } else if (b === 0x08) {
+        // BS: Backspace
+        service.currentWindow.backspace();
+      } else if (b === 0x0c) {
+        // FF: Form feed
+        service.currentWindow.clearText();
+      } else if (b === 0x0d) {
+        // CR: Carriage return
+        service.currentWindow.pendingNewLine = true;
+      } else if (b === 0x0e) {
+        // HCR: Horizontal carriage return
+        service.currentWindow.clearText();
+      } else if (b === 0x8d) {
+        // DLY: Delay, nothing to do
+        i++;
+      } else ;
+    }
+  };
+
+  /**
+   * Execute an extended command
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.extendedCommands = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[++i];
+    if (within708TextBlock(b)) {
+      i = this.handleText(i, service, {
+        isExtended: true
+      });
+    }
+    return i;
+  };
+
+  /**
+   * Get PTS value of a given byte index
+   *
+   * @param  {Integer} byteIndex  Index of the byte
+   * @return {Integer}            PTS
+   */
+  Cea708Stream.prototype.getPts = function (byteIndex) {
+    // There's 1 pts value per 2 bytes
+    return this.current708Packet.ptsVals[Math.floor(byteIndex / 2)];
+  };
+
+  /**
+   * Initializes a service
+   *
+   * @param  {Integer} serviceNum Service number
+   * @return {Service}            Initialized service object
+   */
+  Cea708Stream.prototype.initService = function (serviceNum, i) {
+    var serviceName = 'SERVICE' + serviceNum;
+    var self = this;
+    var serviceName;
+    var encoding;
+    if (serviceName in this.serviceEncodings) {
+      encoding = this.serviceEncodings[serviceName];
+    }
+    this.services[serviceNum] = new Cea708Service(serviceNum, encoding, self);
+    this.services[serviceNum].init(this.getPts(i), function (pts) {
+      self.flushDisplayed(pts, self.services[serviceNum]);
+    });
+    return this.services[serviceNum];
+  };
+
+  /**
+   * Execute text writing to current window
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.handleText = function (i, service, options) {
+    var isExtended = options && options.isExtended;
+    var isMultiByte = options && options.isMultiByte;
+    var packetData = this.current708Packet.data;
+    var extended = isExtended ? 0x1000 : 0x0000;
+    var currentByte = packetData[i];
+    var nextByte = packetData[i + 1];
+    var win = service.currentWindow;
+    var char;
+    var charCodeArray;
+
+    // Use the TextDecoder if one was created for this service
+    if (service.textDecoder_ && !isExtended) {
+      if (isMultiByte) {
+        charCodeArray = [currentByte, nextByte];
+        i++;
+      } else {
+        charCodeArray = [currentByte];
+      }
+      char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
+    } else {
+      char = get708CharFromCode(extended | currentByte);
+    }
+    if (win.pendingNewLine && !win.isEmpty()) {
+      win.newLine(this.getPts(i));
+    }
+    win.pendingNewLine = false;
+    win.addText(char);
+    return i;
+  };
+
+  /**
+   * Handle decoding of multibyte character
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.multiByteCharacter = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var firstByte = packetData[i + 1];
+    var secondByte = packetData[i + 2];
+    if (within708TextBlock(firstByte) && within708TextBlock(secondByte)) {
+      i = this.handleText(++i, service, {
+        isMultiByte: true
+      });
+    }
+    return i;
+  };
+
+  /**
+   * Parse and execute the CW# command.
+   *
+   * Set the current window.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.setCurrentWindow = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[i];
+    var windowNum = b & 0x07;
+    service.setCurrentWindow(windowNum);
+    return i;
+  };
+
+  /**
+   * Parse and execute the DF# command.
+   *
+   * Define a window and set it as the current window.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.defineWindow = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[i];
+    var windowNum = b & 0x07;
+    service.setCurrentWindow(windowNum);
+    var win = service.currentWindow;
+    b = packetData[++i];
+    win.visible = (b & 0x20) >> 5; // v
+    win.rowLock = (b & 0x10) >> 4; // rl
+    win.columnLock = (b & 0x08) >> 3; // cl
+    win.priority = b & 0x07; // p
+
+    b = packetData[++i];
+    win.relativePositioning = (b & 0x80) >> 7; // rp
+    win.anchorVertical = b & 0x7f; // av
+
+    b = packetData[++i];
+    win.anchorHorizontal = b; // ah
+
+    b = packetData[++i];
+    win.anchorPoint = (b & 0xf0) >> 4; // ap
+    win.rowCount = b & 0x0f; // rc
+
+    b = packetData[++i];
+    win.columnCount = b & 0x3f; // cc
+
+    b = packetData[++i];
+    win.windowStyle = (b & 0x38) >> 3; // ws
+    win.penStyle = b & 0x07; // ps
+
+    // The spec says there are (rowCount+1) "virtual rows"
+    win.virtualRowCount = win.rowCount + 1;
+    return i;
+  };
+
+  /**
+   * Parse and execute the SWA command.
+   *
+   * Set attributes of the current window.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.setWindowAttributes = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[i];
+    var winAttr = service.currentWindow.winAttr;
+    b = packetData[++i];
+    winAttr.fillOpacity = (b & 0xc0) >> 6; // fo
+    winAttr.fillRed = (b & 0x30) >> 4; // fr
+    winAttr.fillGreen = (b & 0x0c) >> 2; // fg
+    winAttr.fillBlue = b & 0x03; // fb
+
+    b = packetData[++i];
+    winAttr.borderType = (b & 0xc0) >> 6; // bt
+    winAttr.borderRed = (b & 0x30) >> 4; // br
+    winAttr.borderGreen = (b & 0x0c) >> 2; // bg
+    winAttr.borderBlue = b & 0x03; // bb
+
+    b = packetData[++i];
+    winAttr.borderType += (b & 0x80) >> 5; // bt
+    winAttr.wordWrap = (b & 0x40) >> 6; // ww
+    winAttr.printDirection = (b & 0x30) >> 4; // pd
+    winAttr.scrollDirection = (b & 0x0c) >> 2; // sd
+    winAttr.justify = b & 0x03; // j
+
+    b = packetData[++i];
+    winAttr.effectSpeed = (b & 0xf0) >> 4; // es
+    winAttr.effectDirection = (b & 0x0c) >> 2; // ed
+    winAttr.displayEffect = b & 0x03; // de
+
+    return i;
+  };
+
+  /**
+   * Gather text from all displayed windows and push a caption to output.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   */
+  Cea708Stream.prototype.flushDisplayed = function (pts, service) {
+    var displayedText = [];
+
+    // TODO: Positioning not supported, displaying multiple windows will not necessarily
+    // display text in the correct order, but sample files so far have not shown any issue.
+    for (var winId = 0; winId < 8; winId++) {
+      if (service.windows[winId].visible && !service.windows[winId].isEmpty()) {
+        displayedText.push(service.windows[winId].getText());
+      }
+    }
+    service.endPts = pts;
+    service.text = displayedText.join('\n\n');
+    this.pushCaption(service);
+    service.startPts = pts;
+  };
+
+  /**
+   * Push a caption to output if the caption contains text.
+   *
+   * @param  {Service} service  The service object to be affected
+   */
+  Cea708Stream.prototype.pushCaption = function (service) {
+    if (service.text !== '') {
+      this.trigger('data', {
+        startPts: service.startPts,
+        endPts: service.endPts,
+        text: service.text,
+        stream: 'cc708_' + service.serviceNum
+      });
+      service.text = '';
+      service.startPts = service.endPts;
+    }
+  };
+
+  /**
+   * Parse and execute the DSW command.
+   *
+   * Set visible property of windows based on the parsed bitmask.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.displayWindows = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[++i];
+    var pts = this.getPts(i);
+    this.flushDisplayed(pts, service);
+    for (var winId = 0; winId < 8; winId++) {
+      if (b & 0x01 << winId) {
+        service.windows[winId].visible = 1;
+      }
+    }
+    return i;
+  };
+
+  /**
+   * Parse and execute the HDW command.
+   *
+   * Set visible property of windows based on the parsed bitmask.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.hideWindows = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[++i];
+    var pts = this.getPts(i);
+    this.flushDisplayed(pts, service);
+    for (var winId = 0; winId < 8; winId++) {
+      if (b & 0x01 << winId) {
+        service.windows[winId].visible = 0;
+      }
+    }
+    return i;
+  };
+
+  /**
+   * Parse and execute the TGW command.
+   *
+   * Set visible property of windows based on the parsed bitmask.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.toggleWindows = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[++i];
+    var pts = this.getPts(i);
+    this.flushDisplayed(pts, service);
+    for (var winId = 0; winId < 8; winId++) {
+      if (b & 0x01 << winId) {
+        service.windows[winId].visible ^= 1;
+      }
+    }
+    return i;
+  };
+
+  /**
+   * Parse and execute the CLW command.
+   *
+   * Clear text of windows based on the parsed bitmask.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.clearWindows = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[++i];
+    var pts = this.getPts(i);
+    this.flushDisplayed(pts, service);
+    for (var winId = 0; winId < 8; winId++) {
+      if (b & 0x01 << winId) {
+        service.windows[winId].clearText();
+      }
+    }
+    return i;
+  };
+
+  /**
+   * Parse and execute the DLW command.
+   *
+   * Re-initialize windows based on the parsed bitmask.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.deleteWindows = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[++i];
+    var pts = this.getPts(i);
+    this.flushDisplayed(pts, service);
+    for (var winId = 0; winId < 8; winId++) {
+      if (b & 0x01 << winId) {
+        service.windows[winId].reset();
+      }
+    }
+    return i;
+  };
+
+  /**
+   * Parse and execute the SPA command.
+   *
+   * Set pen attributes of the current window.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.setPenAttributes = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[i];
+    var penAttr = service.currentWindow.penAttr;
+    b = packetData[++i];
+    penAttr.textTag = (b & 0xf0) >> 4; // tt
+    penAttr.offset = (b & 0x0c) >> 2; // o
+    penAttr.penSize = b & 0x03; // s
+
+    b = packetData[++i];
+    penAttr.italics = (b & 0x80) >> 7; // i
+    penAttr.underline = (b & 0x40) >> 6; // u
+    penAttr.edgeType = (b & 0x38) >> 3; // et
+    penAttr.fontStyle = b & 0x07; // fs
+
+    return i;
+  };
+
+  /**
+   * Parse and execute the SPC command.
+   *
+   * Set pen color of the current window.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.setPenColor = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[i];
+    var penColor = service.currentWindow.penColor;
+    b = packetData[++i];
+    penColor.fgOpacity = (b & 0xc0) >> 6; // fo
+    penColor.fgRed = (b & 0x30) >> 4; // fr
+    penColor.fgGreen = (b & 0x0c) >> 2; // fg
+    penColor.fgBlue = b & 0x03; // fb
+
+    b = packetData[++i];
+    penColor.bgOpacity = (b & 0xc0) >> 6; // bo
+    penColor.bgRed = (b & 0x30) >> 4; // br
+    penColor.bgGreen = (b & 0x0c) >> 2; // bg
+    penColor.bgBlue = b & 0x03; // bb
+
+    b = packetData[++i];
+    penColor.edgeRed = (b & 0x30) >> 4; // er
+    penColor.edgeGreen = (b & 0x0c) >> 2; // eg
+    penColor.edgeBlue = b & 0x03; // eb
+
+    return i;
+  };
+
+  /**
+   * Parse and execute the SPL command.
+   *
+   * Set pen location of the current window.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Integer}          New index after parsing
+   */
+  Cea708Stream.prototype.setPenLocation = function (i, service) {
+    var packetData = this.current708Packet.data;
+    var b = packetData[i];
+    var penLoc = service.currentWindow.penLoc;
+
+    // Positioning isn't really supported at the moment, so this essentially just inserts a linebreak
+    service.currentWindow.pendingNewLine = true;
+    b = packetData[++i];
+    penLoc.row = b & 0x0f; // r
+
+    b = packetData[++i];
+    penLoc.column = b & 0x3f; // c
+
+    return i;
+  };
+
+  /**
+   * Execute the RST command.
+   *
+   * Reset service to a clean slate. Re-initialize.
+   *
+   * @param  {Integer} i        Current index in the 708 packet
+   * @param  {Service} service  The service object to be affected
+   * @return {Service}          Re-initialized service
+   */
+  Cea708Stream.prototype.reset = function (i, service) {
+    var pts = this.getPts(i);
+    this.flushDisplayed(pts, service);
+    return this.initService(service.serviceNum, i);
+  };
+
+  // This hash maps non-ASCII, special, and extended character codes to their
+  // proper Unicode equivalent. The first keys that are only a single byte
+  // are the non-standard ASCII characters, which simply map the CEA608 byte
+  // to the standard ASCII/Unicode. The two-byte keys that follow are the CEA608
+  // character codes, but have their MSB bitmasked with 0x03 so that a lookup
+  // can be performed regardless of the field and data channel on which the
+  // character code was received.
+  var CHARACTER_TRANSLATION = {
+    0x2a: 0xe1,
+    // á
+    0x5c: 0xe9,
+    // é
+    0x5e: 0xed,
+    // í
+    0x5f: 0xf3,
+    // ó
+    0x60: 0xfa,
+    // ú
+    0x7b: 0xe7,
+    // ç
+    0x7c: 0xf7,
+    // ÷
+    0x7d: 0xd1,
+    // Ñ
+    0x7e: 0xf1,
+    // ñ
+    0x7f: 0x2588,
+    // █
+    0x0130: 0xae,
+    // ®
+    0x0131: 0xb0,
+    // °
+    0x0132: 0xbd,
+    // ½
+    0x0133: 0xbf,
+    // ¿
+    0x0134: 0x2122,
+    // ™
+    0x0135: 0xa2,
+    // ¢
+    0x0136: 0xa3,
+    // £
+    0x0137: 0x266a,
+    // ♪
+    0x0138: 0xe0,
+    // à
+    0x0139: 0xa0,
+    //
+    0x013a: 0xe8,
+    // è
+    0x013b: 0xe2,
+    // â
+    0x013c: 0xea,
+    // ê
+    0x013d: 0xee,
+    // î
+    0x013e: 0xf4,
+    // ô
+    0x013f: 0xfb,
+    // û
+    0x0220: 0xc1,
+    // Á
+    0x0221: 0xc9,
+    // É
+    0x0222: 0xd3,
+    // Ó
+    0x0223: 0xda,
+    // Ú
+    0x0224: 0xdc,
+    // Ü
+    0x0225: 0xfc,
+    // ü
+    0x0226: 0x2018,
+    // ‘
+    0x0227: 0xa1,
+    // ¡
+    0x0228: 0x2a,
+    // *
+    0x0229: 0x27,
+    // '
+    0x022a: 0x2014,
+    // —
+    0x022b: 0xa9,
+    // ©
+    0x022c: 0x2120,
+    // ℠
+    0x022d: 0x2022,
+    // •
+    0x022e: 0x201c,
+    // “
+    0x022f: 0x201d,
+    // ”
+    0x0230: 0xc0,
+    // À
+    0x0231: 0xc2,
+    // Â
+    0x0232: 0xc7,
+    // Ç
+    0x0233: 0xc8,
+    // È
+    0x0234: 0xca,
+    // Ê
+    0x0235: 0xcb,
+    // Ë
+    0x0236: 0xeb,
+    // ë
+    0x0237: 0xce,
+    // Î
+    0x0238: 0xcf,
+    // Ï
+    0x0239: 0xef,
+    // ï
+    0x023a: 0xd4,
+    // Ô
+    0x023b: 0xd9,
+    // Ù
+    0x023c: 0xf9,
+    // ù
+    0x023d: 0xdb,
+    // Û
+    0x023e: 0xab,
+    // «
+    0x023f: 0xbb,
+    // »
+    0x0320: 0xc3,
+    // Ã
+    0x0321: 0xe3,
+    // ã
+    0x0322: 0xcd,
+    // Í
+    0x0323: 0xcc,
+    // Ì
+    0x0324: 0xec,
+    // ì
+    0x0325: 0xd2,
+    // Ò
+    0x0326: 0xf2,
+    // ò
+    0x0327: 0xd5,
+    // Õ
+    0x0328: 0xf5,
+    // õ
+    0x0329: 0x7b,
+    // {
+    0x032a: 0x7d,
+    // }
+    0x032b: 0x5c,
+    // \
+    0x032c: 0x5e,
+    // ^
+    0x032d: 0x5f,
+    // _
+    0x032e: 0x7c,
+    // |
+    0x032f: 0x7e,
+    // ~
+    0x0330: 0xc4,
+    // Ä
+    0x0331: 0xe4,
+    // ä
+    0x0332: 0xd6,
+    // Ö
+    0x0333: 0xf6,
+    // ö
+    0x0334: 0xdf,
+    // ß
+    0x0335: 0xa5,
+    // ¥
+    0x0336: 0xa4,
+    // ¤
+    0x0337: 0x2502,
+    // │
+    0x0338: 0xc5,
+    // Å
+    0x0339: 0xe5,
+    // å
+    0x033a: 0xd8,
+    // Ø
+    0x033b: 0xf8,
+    // ø
+    0x033c: 0x250c,
+    // ┌
+    0x033d: 0x2510,
+    // ┐
+    0x033e: 0x2514,
+    // └
+    0x033f: 0x2518 // ┘
+  };
+
+  var getCharFromCode = function getCharFromCode(code) {
+    if (code === null) {
+      return '';
+    }
+    code = CHARACTER_TRANSLATION[code] || code;
+    return String.fromCharCode(code);
+  };
+
+  // the index of the last row in a CEA-608 display buffer
+  var BOTTOM_ROW = 14;
+
+  // This array is used for mapping PACs -> row #, since there's no way of
+  // getting it through bit logic.
+  var ROWS = [0x1100, 0x1120, 0x1200, 0x1220, 0x1500, 0x1520, 0x1600, 0x1620, 0x1700, 0x1720, 0x1000, 0x1300, 0x1320, 0x1400, 0x1420];
+
+  // CEA-608 captions are rendered onto a 34x15 matrix of character
+  // cells. The "bottom" row is the last element in the outer array.
+  var createDisplayBuffer = function createDisplayBuffer() {
+    var result = [],
+      i = BOTTOM_ROW + 1;
+    while (i--) {
+      result.push('');
+    }
+    return result;
+  };
+  var Cea608Stream = function Cea608Stream(field, dataChannel) {
+    Cea608Stream.prototype.init.call(this);
+    this.field_ = field || 0;
+    this.dataChannel_ = dataChannel || 0;
+    this.name_ = 'CC' + ((this.field_ << 1 | this.dataChannel_) + 1);
+    this.setConstants();
+    this.reset();
+    this.push = function (packet) {
+      var data, swap, char0, char1, text;
+      // remove the parity bits
+      data = packet.ccData & 0x7f7f;
+
+      // ignore duplicate control codes; the spec demands they're sent twice
+      if (data === this.lastControlCode_) {
+        this.lastControlCode_ = null;
+        return;
+      }
+
+      // Store control codes
+      if ((data & 0xf000) === 0x1000) {
+        this.lastControlCode_ = data;
+      } else if (data !== this.PADDING_) {
+        this.lastControlCode_ = null;
+      }
+      char0 = data >>> 8;
+      char1 = data & 0xff;
+      if (data === this.PADDING_) {
+        return;
+      } else if (data === this.RESUME_CAPTION_LOADING_) {
+        this.mode_ = 'popOn';
+      } else if (data === this.END_OF_CAPTION_) {
+        // If an EOC is received while in paint-on mode, the displayed caption
+        // text should be swapped to non-displayed memory as if it was a pop-on
+        // caption. Because of that, we should explicitly switch back to pop-on
+        // mode
+        this.mode_ = 'popOn';
+        this.clearFormatting(packet.pts);
+        // if a caption was being displayed, it's gone now
+        this.flushDisplayed(packet.pts);
+
+        // flip memory
+        swap = this.displayed_;
+        this.displayed_ = this.nonDisplayed_;
+        this.nonDisplayed_ = swap;
+
+        // start measuring the time to display the caption
+        this.startPts_ = packet.pts;
+      } else if (data === this.ROLL_UP_2_ROWS_) {
+        this.rollUpRows_ = 2;
+        this.setRollUp(packet.pts);
+      } else if (data === this.ROLL_UP_3_ROWS_) {
+        this.rollUpRows_ = 3;
+        this.setRollUp(packet.pts);
+      } else if (data === this.ROLL_UP_4_ROWS_) {
+        this.rollUpRows_ = 4;
+        this.setRollUp(packet.pts);
+      } else if (data === this.CARRIAGE_RETURN_) {
+        this.clearFormatting(packet.pts);
+        this.flushDisplayed(packet.pts);
+        this.shiftRowsUp_();
+        this.startPts_ = packet.pts;
+      } else if (data === this.BACKSPACE_) {
+        if (this.mode_ === 'popOn') {
+          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+        } else {
+          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+        }
+      } else if (data === this.ERASE_DISPLAYED_MEMORY_) {
+        this.flushDisplayed(packet.pts);
+        this.displayed_ = createDisplayBuffer();
+      } else if (data === this.ERASE_NON_DISPLAYED_MEMORY_) {
+        this.nonDisplayed_ = createDisplayBuffer();
+      } else if (data === this.RESUME_DIRECT_CAPTIONING_) {
+        if (this.mode_ !== 'paintOn') {
+          // NOTE: This should be removed when proper caption positioning is
+          // implemented
+          this.flushDisplayed(packet.pts);
+          this.displayed_ = createDisplayBuffer();
+        }
+        this.mode_ = 'paintOn';
+        this.startPts_ = packet.pts;
+
+        // Append special characters to caption text
+      } else if (this.isSpecialCharacter(char0, char1)) {
+        // Bitmask char0 so that we can apply character transformations
+        // regardless of field and data channel.
+        // Then byte-shift to the left and OR with char1 so we can pass the
+        // entire character code to `getCharFromCode`.
+        char0 = (char0 & 0x03) << 8;
+        text = getCharFromCode(char0 | char1);
+        this[this.mode_](packet.pts, text);
+        this.column_++;
+
+        // Append extended characters to caption text
+      } else if (this.isExtCharacter(char0, char1)) {
+        // Extended characters always follow their "non-extended" equivalents.
+        // IE if a "è" is desired, you'll always receive "eè"; non-compliant
+        // decoders are supposed to drop the "è", while compliant decoders
+        // backspace the "e" and insert "è".
+
+        // Delete the previous character
+        if (this.mode_ === 'popOn') {
+          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);
+        } else {
+          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);
+        }
+
+        // Bitmask char0 so that we can apply character transformations
+        // regardless of field and data channel.
+        // Then byte-shift to the left and OR with char1 so we can pass the
+        // entire character code to `getCharFromCode`.
+        char0 = (char0 & 0x03) << 8;
+        text = getCharFromCode(char0 | char1);
+        this[this.mode_](packet.pts, text);
+        this.column_++;
+
+        // Process mid-row codes
+      } else if (this.isMidRowCode(char0, char1)) {
+        // Attributes are not additive, so clear all formatting
+        this.clearFormatting(packet.pts);
+
+        // According to the standard, mid-row codes
+        // should be replaced with spaces, so add one now
+        this[this.mode_](packet.pts, ' ');
+        this.column_++;
+        if ((char1 & 0xe) === 0xe) {
+          this.addFormatting(packet.pts, ['i']);
+        }
+        if ((char1 & 0x1) === 0x1) {
+          this.addFormatting(packet.pts, ['u']);
+        }
+
+        // Detect offset control codes and adjust cursor
+      } else if (this.isOffsetControlCode(char0, char1)) {
+        // Cursor position is set by indent PAC (see below) in 4-column
+        // increments, with an additional offset code of 1-3 to reach any
+        // of the 32 columns specified by CEA-608. So all we need to do
+        // here is increment the column cursor by the given offset.
+        this.column_ += char1 & 0x03;
+
+        // Detect PACs (Preamble Address Codes)
+      } else if (this.isPAC(char0, char1)) {
+        // There's no logic for PAC -> row mapping, so we have to just
+        // find the row code in an array and use its index :(
+        var row = ROWS.indexOf(data & 0x1f20);
+
+        // Configure the caption window if we're in roll-up mode
+        if (this.mode_ === 'rollUp') {
+          // This implies that the base row is incorrectly set.
+          // As per the recommendation in CEA-608(Base Row Implementation), defer to the number
+          // of roll-up rows set.
+          if (row - this.rollUpRows_ + 1 < 0) {
+            row = this.rollUpRows_ - 1;
+          }
+          this.setRollUp(packet.pts, row);
+        }
+        if (row !== this.row_) {
+          // formatting is only persistent for current row
+          this.clearFormatting(packet.pts);
+          this.row_ = row;
+        }
+        // All PACs can apply underline, so detect and apply
+        // (All odd-numbered second bytes set underline)
+        if (char1 & 0x1 && this.formatting_.indexOf('u') === -1) {
+          this.addFormatting(packet.pts, ['u']);
+        }
+        if ((data & 0x10) === 0x10) {
+          // We've got an indent level code. Each successive even number
+          // increments the column cursor by 4, so we can get the desired
+          // column position by bit-shifting to the right (to get n/2)
+          // and multiplying by 4.
+          this.column_ = ((data & 0xe) >> 1) * 4;
+        }
+        if (this.isColorPAC(char1)) {
+          // it's a color code, though we only support white, which
+          // can be either normal or italicized. white italics can be
+          // either 0x4e or 0x6e depending on the row, so we just
+          // bitwise-and with 0xe to see if italics should be turned on
+          if ((char1 & 0xe) === 0xe) {
+            this.addFormatting(packet.pts, ['i']);
+          }
+        }
+
+        // We have a normal character in char0, and possibly one in char1
+      } else if (this.isNormalChar(char0)) {
+        if (char1 === 0x00) {
+          char1 = null;
+        }
+        text = getCharFromCode(char0);
+        text += getCharFromCode(char1);
+        this[this.mode_](packet.pts, text);
+        this.column_ += text.length;
+      } // finish data processing
+    };
+  };
+
+  Cea608Stream.prototype = new stream();
+  // Trigger a cue point that captures the current state of the
+  // display buffer
+  Cea608Stream.prototype.flushDisplayed = function (pts) {
+    var content = this.displayed_
+    // remove spaces from the start and end of the string
+    .map(function (row, index) {
+      try {
+        return row.trim();
+      } catch (e) {
+        // Ordinarily, this shouldn't happen. However, caption
+        // parsing errors should not throw exceptions and
+        // break playback.
+        this.trigger('log', {
+          level: 'warn',
+          message: 'Skipping a malformed 608 caption at index ' + index + '.'
+        });
+        return '';
+      }
+    }, this)
+    // combine all text rows to display in one cue
+    .join('\n')
+    // and remove blank rows from the start and end, but not the middle
+    .replace(/^\n+|\n+$/g, '');
+    if (content.length) {
+      this.trigger('data', {
+        startPts: this.startPts_,
+        endPts: pts,
+        text: content,
+        stream: this.name_
+      });
+    }
+  };
+
+  /**
+   * Zero out the data, used for startup and on seek
+   */
+  Cea608Stream.prototype.reset = function () {
+    this.mode_ = 'popOn';
+    // When in roll-up mode, the index of the last row that will
+    // actually display captions. If a caption is shifted to a row
+    // with a lower index than this, it is cleared from the display
+    // buffer
+    this.topRow_ = 0;
+    this.startPts_ = 0;
+    this.displayed_ = createDisplayBuffer();
+    this.nonDisplayed_ = createDisplayBuffer();
+    this.lastControlCode_ = null;
+
+    // Track row and column for proper line-breaking and spacing
+    this.column_ = 0;
+    this.row_ = BOTTOM_ROW;
+    this.rollUpRows_ = 2;
+
+    // This variable holds currently-applied formatting
+    this.formatting_ = [];
+  };
+
+  /**
+   * Sets up control code and related constants for this instance
+   */
+  Cea608Stream.prototype.setConstants = function () {
+    // The following attributes have these uses:
+    // ext_ :    char0 for mid-row codes, and the base for extended
+    //           chars (ext_+0, ext_+1, and ext_+2 are char0s for
+    //           extended codes)
+    // control_: char0 for control codes, except byte-shifted to the
+    //           left so that we can do this.control_ | CONTROL_CODE
+    // offset_:  char0 for tab offset codes
+    //
+    // It's also worth noting that control codes, and _only_ control codes,
+    // differ between field 1 and field2. Field 2 control codes are always
+    // their field 1 value plus 1. That's why there's the "| field" on the
+    // control value.
+    if (this.dataChannel_ === 0) {
+      this.BASE_ = 0x10;
+      this.EXT_ = 0x11;
+      this.CONTROL_ = (0x14 | this.field_) << 8;
+      this.OFFSET_ = 0x17;
+    } else if (this.dataChannel_ === 1) {
+      this.BASE_ = 0x18;
+      this.EXT_ = 0x19;
+      this.CONTROL_ = (0x1c | this.field_) << 8;
+      this.OFFSET_ = 0x1f;
+    }
+
+    // Constants for the LSByte command codes recognized by Cea608Stream. This
+    // list is not exhaustive. For a more comprehensive listing and semantics see
+    // http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf
+    // Padding
+    this.PADDING_ = 0x0000;
+    // Pop-on Mode
+    this.RESUME_CAPTION_LOADING_ = this.CONTROL_ | 0x20;
+    this.END_OF_CAPTION_ = this.CONTROL_ | 0x2f;
+    // Roll-up Mode
+    this.ROLL_UP_2_ROWS_ = this.CONTROL_ | 0x25;
+    this.ROLL_UP_3_ROWS_ = this.CONTROL_ | 0x26;
+    this.ROLL_UP_4_ROWS_ = this.CONTROL_ | 0x27;
+    this.CARRIAGE_RETURN_ = this.CONTROL_ | 0x2d;
+    // paint-on mode
+    this.RESUME_DIRECT_CAPTIONING_ = this.CONTROL_ | 0x29;
+    // Erasure
+    this.BACKSPACE_ = this.CONTROL_ | 0x21;
+    this.ERASE_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2c;
+    this.ERASE_NON_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2e;
+  };
+
+  /**
+   * Detects if the 2-byte packet data is a special character
+   *
+   * Special characters have a second byte in the range 0x30 to 0x3f,
+   * with the first byte being 0x11 (for data channel 1) or 0x19 (for
+   * data channel 2).
+   *
+   * @param  {Integer} char0 The first byte
+   * @param  {Integer} char1 The second byte
+   * @return {Boolean}       Whether the 2 bytes are an special character
+   */
+  Cea608Stream.prototype.isSpecialCharacter = function (char0, char1) {
+    return char0 === this.EXT_ && char1 >= 0x30 && char1 <= 0x3f;
+  };
+
+  /**
+   * Detects if the 2-byte packet data is an extended character
+   *
+   * Extended characters have a second byte in the range 0x20 to 0x3f,
+   * with the first byte being 0x12 or 0x13 (for data channel 1) or
+   * 0x1a or 0x1b (for data channel 2).
+   *
+   * @param  {Integer} char0 The first byte
+   * @param  {Integer} char1 The second byte
+   * @return {Boolean}       Whether the 2 bytes are an extended character
+   */
+  Cea608Stream.prototype.isExtCharacter = function (char0, char1) {
+    return (char0 === this.EXT_ + 1 || char0 === this.EXT_ + 2) && char1 >= 0x20 && char1 <= 0x3f;
+  };
+
+  /**
+   * Detects if the 2-byte packet is a mid-row code
+   *
+   * Mid-row codes have a second byte in the range 0x20 to 0x2f, with
+   * the first byte being 0x11 (for data channel 1) or 0x19 (for data
+   * channel 2).
+   *
+   * @param  {Integer} char0 The first byte
+   * @param  {Integer} char1 The second byte
+   * @return {Boolean}       Whether the 2 bytes are a mid-row code
+   */
+  Cea608Stream.prototype.isMidRowCode = function (char0, char1) {
+    return char0 === this.EXT_ && char1 >= 0x20 && char1 <= 0x2f;
+  };
+
+  /**
+   * Detects if the 2-byte packet is an offset control code
+   *
+   * Offset control codes have a second byte in the range 0x21 to 0x23,
+   * with the first byte being 0x17 (for data channel 1) or 0x1f (for
+   * data channel 2).
+   *
+   * @param  {Integer} char0 The first byte
+   * @param  {Integer} char1 The second byte
+   * @return {Boolean}       Whether the 2 bytes are an offset control code
+   */
+  Cea608Stream.prototype.isOffsetControlCode = function (char0, char1) {
+    return char0 === this.OFFSET_ && char1 >= 0x21 && char1 <= 0x23;
+  };
+
+  /**
+   * Detects if the 2-byte packet is a Preamble Address Code
+   *
+   * PACs have a first byte in the range 0x10 to 0x17 (for data channel 1)
+   * or 0x18 to 0x1f (for data channel 2), with the second byte in the
+   * range 0x40 to 0x7f.
+   *
+   * @param  {Integer} char0 The first byte
+   * @param  {Integer} char1 The second byte
+   * @return {Boolean}       Whether the 2 bytes are a PAC
+   */
+  Cea608Stream.prototype.isPAC = function (char0, char1) {
+    return char0 >= this.BASE_ && char0 < this.BASE_ + 8 && char1 >= 0x40 && char1 <= 0x7f;
+  };
+
+  /**
+   * Detects if a packet's second byte is in the range of a PAC color code
+   *
+   * PAC color codes have the second byte be in the range 0x40 to 0x4f, or
+   * 0x60 to 0x6f.
+   *
+   * @param  {Integer} char1 The second byte
+   * @return {Boolean}       Whether the byte is a color PAC
+   */
+  Cea608Stream.prototype.isColorPAC = function (char1) {
+    return char1 >= 0x40 && char1 <= 0x4f || char1 >= 0x60 && char1 <= 0x7f;
+  };
+
+  /**
+   * Detects if a single byte is in the range of a normal character
+   *
+   * Normal text bytes are in the range 0x20 to 0x7f.
+   *
+   * @param  {Integer} char  The byte
+   * @return {Boolean}       Whether the byte is a normal character
+   */
+  Cea608Stream.prototype.isNormalChar = function (char) {
+    return char >= 0x20 && char <= 0x7f;
+  };
+
+  /**
+   * Configures roll-up
+   *
+   * @param  {Integer} pts         Current PTS
+   * @param  {Integer} newBaseRow  Used by PACs to slide the current window to
+   *                               a new position
+   */
+  Cea608Stream.prototype.setRollUp = function (pts, newBaseRow) {
+    // Reset the base row to the bottom row when switching modes
+    if (this.mode_ !== 'rollUp') {
+      this.row_ = BOTTOM_ROW;
+      this.mode_ = 'rollUp';
+      // Spec says to wipe memories when switching to roll-up
+      this.flushDisplayed(pts);
+      this.nonDisplayed_ = createDisplayBuffer();
+      this.displayed_ = createDisplayBuffer();
+    }
+    if (newBaseRow !== undefined && newBaseRow !== this.row_) {
+      // move currently displayed captions (up or down) to the new base row
+      for (var i = 0; i < this.rollUpRows_; i++) {
+        this.displayed_[newBaseRow - i] = this.displayed_[this.row_ - i];
+        this.displayed_[this.row_ - i] = '';
+      }
+    }
+    if (newBaseRow === undefined) {
+      newBaseRow = this.row_;
+    }
+    this.topRow_ = newBaseRow - this.rollUpRows_ + 1;
+  };
+
+  // Adds the opening HTML tag for the passed character to the caption text,
+  // and keeps track of it for later closing
+  Cea608Stream.prototype.addFormatting = function (pts, format) {
+    this.formatting_ = this.formatting_.concat(format);
+    var text = format.reduce(function (text, format) {
+      return text + '<' + format + '>';
+    }, '');
+    this[this.mode_](pts, text);
+  };
+
+  // Adds HTML closing tags for current formatting to caption text and
+  // clears remembered formatting
+  Cea608Stream.prototype.clearFormatting = function (pts) {
+    if (!this.formatting_.length) {
+      return;
+    }
+    var text = this.formatting_.reverse().reduce(function (text, format) {
+      return text + '</' + format + '>';
+    }, '');
+    this.formatting_ = [];
+    this[this.mode_](pts, text);
+  };
+
+  // Mode Implementations
+  Cea608Stream.prototype.popOn = function (pts, text) {
+    var baseRow = this.nonDisplayed_[this.row_];
+
+    // buffer characters
+    baseRow += text;
+    this.nonDisplayed_[this.row_] = baseRow;
+  };
+  Cea608Stream.prototype.rollUp = function (pts, text) {
+    var baseRow = this.displayed_[this.row_];
+    baseRow += text;
+    this.displayed_[this.row_] = baseRow;
+  };
+  Cea608Stream.prototype.shiftRowsUp_ = function () {
+    var i;
+    // clear out inactive rows
+    for (i = 0; i < this.topRow_; i++) {
+      this.displayed_[i] = '';
+    }
+    for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {
+      this.displayed_[i] = '';
+    }
+    // shift displayed rows up
+    for (i = this.topRow_; i < this.row_; i++) {
+      this.displayed_[i] = this.displayed_[i + 1];
+    }
+    // clear out the bottom row
+    this.displayed_[this.row_] = '';
+  };
+  Cea608Stream.prototype.paintOn = function (pts, text) {
+    var baseRow = this.displayed_[this.row_];
+    baseRow += text;
+    this.displayed_[this.row_] = baseRow;
+  };
+
+  // exports
+  var captionStream = {
+    CaptionStream: CaptionStream,
+    Cea608Stream: Cea608Stream,
+    Cea708Stream: Cea708Stream
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+
+  var streamTypes = {
+    H264_STREAM_TYPE: 0x1B,
+    ADTS_STREAM_TYPE: 0x0F,
+    METADATA_STREAM_TYPE: 0x15
+  };
+
+  var MAX_TS = 8589934592;
+  var RO_THRESH = 4294967296;
+  var TYPE_SHARED = 'shared';
+  var handleRollover = function handleRollover(value, reference) {
+    var direction = 1;
+    if (value > reference) {
+      // If the current timestamp value is greater than our reference timestamp and we detect a
+      // timestamp rollover, this means the roll over is happening in the opposite direction.
+      // Example scenario: Enter a long stream/video just after a rollover occurred. The reference
+      // point will be set to a small number, e.g. 1. The user then seeks backwards over the
+      // rollover point. In loading this segment, the timestamp values will be very large,
+      // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust
+      // the time stamp to be `value - 2^33`.
+      direction = -1;
+    }
+
+    // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will
+    // cause an incorrect adjustment.
+    while (Math.abs(reference - value) > RO_THRESH) {
+      value += direction * MAX_TS;
+    }
+    return value;
+  };
+  var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {
+    var lastDTS, referenceDTS;
+    TimestampRolloverStream.prototype.init.call(this);
+
+    // The "shared" type is used in cases where a stream will contain muxed
+    // video and audio. We could use `undefined` here, but having a string
+    // makes debugging a little clearer.
+    this.type_ = type || TYPE_SHARED;
+    this.push = function (data) {
+      // Any "shared" rollover streams will accept _all_ data. Otherwise,
+      // streams will only accept data that matches their type.
+      if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {
+        return;
+      }
+      if (referenceDTS === undefined) {
+        referenceDTS = data.dts;
+      }
+      data.dts = handleRollover(data.dts, referenceDTS);
+      data.pts = handleRollover(data.pts, referenceDTS);
+      lastDTS = data.dts;
+      this.trigger('data', data);
+    };
+    this.flush = function () {
+      referenceDTS = lastDTS;
+      this.trigger('done');
+    };
+    this.endTimeline = function () {
+      this.flush();
+      this.trigger('endedtimeline');
+    };
+    this.discontinuity = function () {
+      referenceDTS = void 0;
+      lastDTS = void 0;
+    };
+    this.reset = function () {
+      this.discontinuity();
+      this.trigger('reset');
+    };
+  };
+  TimestampRolloverStream$1.prototype = new stream();
+  var timestampRolloverStream = {
+    TimestampRolloverStream: TimestampRolloverStream$1,
+    handleRollover: handleRollover
+  };
+
+  // IE11 doesn't support indexOf for TypedArrays.
+  // Once IE11 support is dropped, this function should be removed.
+  var typedArrayIndexOf$1 = function typedArrayIndexOf(typedArray, element, fromIndex) {
+    if (!typedArray) {
+      return -1;
+    }
+    var currentIndex = fromIndex;
+    for (; currentIndex < typedArray.length; currentIndex++) {
+      if (typedArray[currentIndex] === element) {
+        return currentIndex;
+      }
+    }
+    return -1;
+  };
+  var typedArray = {
+    typedArrayIndexOf: typedArrayIndexOf$1
+  };
+
+  var typedArrayIndexOf = typedArray.typedArrayIndexOf,
+    // Frames that allow different types of text encoding contain a text
+    // encoding description byte [ID3v2.4.0 section 4.]
+    textEncodingDescriptionByte = {
+      Iso88591: 0x00,
+      // ISO-8859-1, terminated with \0.
+      Utf16: 0x01,
+      // UTF-16 encoded Unicode BOM, terminated with \0\0
+      Utf16be: 0x02,
+      // UTF-16BE encoded Unicode, without BOM, terminated with \0\0
+      Utf8: 0x03 // UTF-8 encoded Unicode, terminated with \0
+    },
+    // return a percent-encoded representation of the specified byte range
+    // @see http://en.wikipedia.org/wiki/Percent-encoding 
+    percentEncode$1 = function percentEncode(bytes, start, end) {
+      var i,
+        result = '';
+      for (i = start; i < end; i++) {
+        result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+      }
+      return result;
+    },
+    // return the string representation of the specified byte range,
+    // interpreted as UTf-8.
+    parseUtf8 = function parseUtf8(bytes, start, end) {
+      return decodeURIComponent(percentEncode$1(bytes, start, end));
+    },
+    // return the string representation of the specified byte range,
+    // interpreted as ISO-8859-1.
+    parseIso88591$1 = function parseIso88591(bytes, start, end) {
+      return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line
+    },
+    parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {
+      return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+    },
+    frameParsers = {
+      'APIC': function APIC(frame) {
+        var i = 1,
+          mimeTypeEndIndex,
+          descriptionEndIndex,
+          LINK_MIME_TYPE = '-->';
+        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+          // ignore frames with unrecognized character encodings
+          return;
+        }
+
+        // parsing fields [ID3v2.4.0 section 4.14.]
+        mimeTypeEndIndex = typedArrayIndexOf(frame.data, 0, i);
+        if (mimeTypeEndIndex < 0) {
+          // malformed frame
+          return;
+        }
+
+        // parsing Mime type field (terminated with \0)
+        frame.mimeType = parseIso88591$1(frame.data, i, mimeTypeEndIndex);
+        i = mimeTypeEndIndex + 1;
+
+        // parsing 1-byte Picture Type field
+        frame.pictureType = frame.data[i];
+        i++;
+        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, i);
+        if (descriptionEndIndex < 0) {
+          // malformed frame
+          return;
+        }
+
+        // parsing Description field (terminated with \0)
+        frame.description = parseUtf8(frame.data, i, descriptionEndIndex);
+        i = descriptionEndIndex + 1;
+        if (frame.mimeType === LINK_MIME_TYPE) {
+          // parsing Picture Data field as URL (always represented as ISO-8859-1 [ID3v2.4.0 section 4.])
+          frame.url = parseIso88591$1(frame.data, i, frame.data.length);
+        } else {
+          // parsing Picture Data field as binary data
+          frame.pictureData = frame.data.subarray(i, frame.data.length);
+        }
+      },
+      'T*': function T(frame) {
+        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+          // ignore frames with unrecognized character encodings
+          return;
+        }
+
+        // parse text field, do not include null terminator in the frame value
+        // frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
+        frame.value = parseUtf8(frame.data, 1, frame.data.length).replace(/\0*$/, '');
+        // text information frames supports multiple strings, stored as a terminator separated list [ID3v2.4.0 section 4.2.]
+        frame.values = frame.value.split('\0');
+      },
+      'TXXX': function TXXX(frame) {
+        var descriptionEndIndex;
+        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+          // ignore frames with unrecognized character encodings
+          return;
+        }
+        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+        if (descriptionEndIndex === -1) {
+          return;
+        }
+
+        // parse the text fields
+        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+        // do not include the null terminator in the tag value
+        // frames that allow different types of encoding contain terminated text
+        // [ID3v2.4.0 section 4.]
+        frame.value = parseUtf8(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0*$/, '');
+        frame.data = frame.value;
+      },
+      'W*': function W(frame) {
+        // parse URL field; URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+        // if the value is followed by a string termination all the following information should be ignored [ID3v2.4.0 section 4.3]
+        frame.url = parseIso88591$1(frame.data, 0, frame.data.length).replace(/\0.*$/, '');
+      },
+      'WXXX': function WXXX(frame) {
+        var descriptionEndIndex;
+        if (frame.data[0] !== textEncodingDescriptionByte.Utf8) {
+          // ignore frames with unrecognized character encodings
+          return;
+        }
+        descriptionEndIndex = typedArrayIndexOf(frame.data, 0, 1);
+        if (descriptionEndIndex === -1) {
+          return;
+        }
+
+        // parse the description and URL fields
+        frame.description = parseUtf8(frame.data, 1, descriptionEndIndex);
+        // URL fields are always represented as ISO-8859-1 [ID3v2.4.0 section 4.]
+        // if the value is followed by a string termination all the following information
+        // should be ignored [ID3v2.4.0 section 4.3]
+        frame.url = parseIso88591$1(frame.data, descriptionEndIndex + 1, frame.data.length).replace(/\0.*$/, '');
+      },
+      'PRIV': function PRIV(frame) {
+        var i;
+        for (i = 0; i < frame.data.length; i++) {
+          if (frame.data[i] === 0) {
+            // parse the description and URL fields
+            frame.owner = parseIso88591$1(frame.data, 0, i);
+            break;
+          }
+        }
+        frame.privateData = frame.data.subarray(i + 1);
+        frame.data = frame.privateData;
+      }
+    };
+  var parseId3Frames = function parseId3Frames(data) {
+    var frameSize,
+      frameHeader,
+      frameStart = 10,
+      tagSize = 0,
+      frames = [];
+
+    // If we don't have enough data for a header, 10 bytes, 
+    // or 'ID3' in the first 3 bytes this is not a valid ID3 tag.
+    if (data.length < 10 || data[0] !== 'I'.charCodeAt(0) || data[1] !== 'D'.charCodeAt(0) || data[2] !== '3'.charCodeAt(0)) {
+      return;
+    }
+    // the frame size is transmitted as a 28-bit integer in the
+    // last four bytes of the ID3 header.
+    // The most significant bit of each byte is dropped and the
+    // results concatenated to recover the actual value.
+    tagSize = parseSyncSafeInteger$1(data.subarray(6, 10));
+
+    // ID3 reports the tag size excluding the header but it's more
+    // convenient for our comparisons to include it
+    tagSize += 10;
+    // check bit 6 of byte 5 for the extended header flag.
+    var hasExtendedHeader = data[5] & 0x40;
+    if (hasExtendedHeader) {
+      // advance the frame start past the extended header
+      frameStart += 4; // header size field
+      frameStart += parseSyncSafeInteger$1(data.subarray(10, 14));
+      tagSize -= parseSyncSafeInteger$1(data.subarray(16, 20)); // clip any padding off the end
+    }
+
+    // parse one or more ID3 frames
+    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    do {
+      // determine the number of bytes in this frame
+      frameSize = parseSyncSafeInteger$1(data.subarray(frameStart + 4, frameStart + 8));
+      if (frameSize < 1) {
+        break;
+      }
+      frameHeader = String.fromCharCode(data[frameStart], data[frameStart + 1], data[frameStart + 2], data[frameStart + 3]);
+      var frame = {
+        id: frameHeader,
+        data: data.subarray(frameStart + 10, frameStart + frameSize + 10)
+      };
+      frame.key = frame.id;
+
+      // parse frame values
+      if (frameParsers[frame.id]) {
+        // use frame specific parser
+        frameParsers[frame.id](frame);
+      } else if (frame.id[0] === 'T') {
+        // use text frame generic parser
+        frameParsers['T*'](frame);
+      } else if (frame.id[0] === 'W') {
+        // use URL link frame generic parser
+        frameParsers['W*'](frame);
+      }
+      frames.push(frame);
+      frameStart += 10; // advance past the frame header
+      frameStart += frameSize; // advance past the frame body
+    } while (frameStart < tagSize);
+    return frames;
+  };
+  var parseId3 = {
+    parseId3Frames: parseId3Frames,
+    parseSyncSafeInteger: parseSyncSafeInteger$1,
+    frameParsers: frameParsers
+  };
+
+  var _MetadataStream;
+  _MetadataStream = function MetadataStream(options) {
+    var settings = {
+        // the bytes of the program-level descriptor field in MP2T
+        // see ISO/IEC 13818-1:2013 (E), section 2.6 "Program and
+        // program element descriptors"
+        descriptor: options && options.descriptor
+      },
+      // the total size in bytes of the ID3 tag being parsed
+      tagSize = 0,
+      // tag data that is not complete enough to be parsed
+      buffer = [],
+      // the total number of bytes currently in the buffer
+      bufferSize = 0,
+      i;
+    _MetadataStream.prototype.init.call(this);
+
+    // calculate the text track in-band metadata track dispatch type
+    // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
+    this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);
+    if (settings.descriptor) {
+      for (i = 0; i < settings.descriptor.length; i++) {
+        this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);
+      }
+    }
+    this.push = function (chunk) {
+      var tag, frameStart, frameSize, frame, i, frameHeader;
+      if (chunk.type !== 'timed-metadata') {
+        return;
+      }
+
+      // if data_alignment_indicator is set in the PES header,
+      // we must have the start of a new ID3 tag. Assume anything
+      // remaining in the buffer was malformed and throw it out
+      if (chunk.dataAlignmentIndicator) {
+        bufferSize = 0;
+        buffer.length = 0;
+      }
+
+      // ignore events that don't look like ID3 data
+      if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {
+        this.trigger('log', {
+          level: 'warn',
+          message: 'Skipping unrecognized metadata packet'
+        });
+        return;
+      }
+
+      // add this chunk to the data we've collected so far
+
+      buffer.push(chunk);
+      bufferSize += chunk.data.byteLength;
+
+      // grab the size of the entire frame from the ID3 header
+      if (buffer.length === 1) {
+        // the frame size is transmitted as a 28-bit integer in the
+        // last four bytes of the ID3 header.
+        // The most significant bit of each byte is dropped and the
+        // results concatenated to recover the actual value.
+        tagSize = parseId3.parseSyncSafeInteger(chunk.data.subarray(6, 10));
+
+        // ID3 reports the tag size excluding the header but it's more
+        // convenient for our comparisons to include it
+        tagSize += 10;
+      }
+
+      // if the entire frame has not arrived, wait for more data
+      if (bufferSize < tagSize) {
+        return;
+      }
+
+      // collect the entire frame so it can be parsed
+      tag = {
+        data: new Uint8Array(tagSize),
+        frames: [],
+        pts: buffer[0].pts,
+        dts: buffer[0].dts
+      };
+      for (i = 0; i < tagSize;) {
+        tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);
+        i += buffer[0].data.byteLength;
+        bufferSize -= buffer[0].data.byteLength;
+        buffer.shift();
+      }
+
+      // find the start of the first frame and the end of the tag
+      frameStart = 10;
+      if (tag.data[5] & 0x40) {
+        // advance the frame start past the extended header
+        frameStart += 4; // header size field
+        frameStart += parseId3.parseSyncSafeInteger(tag.data.subarray(10, 14));
+
+        // clip any padding off the end
+        tagSize -= parseId3.parseSyncSafeInteger(tag.data.subarray(16, 20));
+      }
+
+      // parse one or more ID3 frames
+      // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+      do {
+        // determine the number of bytes in this frame
+        frameSize = parseId3.parseSyncSafeInteger(tag.data.subarray(frameStart + 4, frameStart + 8));
+        if (frameSize < 1) {
+          this.trigger('log', {
+            level: 'warn',
+            message: 'Malformed ID3 frame encountered. Skipping remaining metadata parsing.'
+          });
+          // If the frame is malformed, don't parse any further frames but allow previous valid parsed frames
+          // to be sent along.
+          break;
+        }
+        frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);
+        frame = {
+          id: frameHeader,
+          data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)
+        };
+        frame.key = frame.id;
+
+        // parse frame values
+        if (parseId3.frameParsers[frame.id]) {
+          // use frame specific parser
+          parseId3.frameParsers[frame.id](frame);
+        } else if (frame.id[0] === 'T') {
+          // use text frame generic parser
+          parseId3.frameParsers['T*'](frame);
+        } else if (frame.id[0] === 'W') {
+          // use URL link frame generic parser
+          parseId3.frameParsers['W*'](frame);
+        }
+
+        // handle the special PRIV frame used to indicate the start
+        // time for raw AAC data
+        if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {
+          var d = frame.data,
+            size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+          size *= 4;
+          size += d[7] & 0x03;
+          frame.timeStamp = size;
+          // in raw AAC, all subsequent data will be timestamped based
+          // on the value of this frame
+          // we couldn't have known the appropriate pts and dts before
+          // parsing this ID3 tag so set those values now
+          if (tag.pts === undefined && tag.dts === undefined) {
+            tag.pts = frame.timeStamp;
+            tag.dts = frame.timeStamp;
+          }
+          this.trigger('timestamp', frame);
+        }
+        tag.frames.push(frame);
+        frameStart += 10; // advance past the frame header
+        frameStart += frameSize; // advance past the frame body
+      } while (frameStart < tagSize);
+      this.trigger('data', tag);
+    };
+  };
+  _MetadataStream.prototype = new stream();
+  var metadataStream = _MetadataStream;
+
+  var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream;
+
+  // object types
+  var _TransportPacketStream, _TransportParseStream, _ElementaryStream;
+
+  // constants
+  var MP2T_PACKET_LENGTH = 188,
+    // bytes
+    SYNC_BYTE = 0x47;
+
+  /**
+   * Splits an incoming stream of binary data into MPEG-2 Transport
+   * Stream packets.
+   */
+  _TransportPacketStream = function TransportPacketStream() {
+    var buffer = new Uint8Array(MP2T_PACKET_LENGTH),
+      bytesInBuffer = 0;
+    _TransportPacketStream.prototype.init.call(this);
+
+    // Deliver new bytes to the stream.
+
+    /**
+     * Split a stream of data into M2TS packets
+    **/
+    this.push = function (bytes) {
+      var startIndex = 0,
+        endIndex = MP2T_PACKET_LENGTH,
+        everything;
+
+      // If there are bytes remaining from the last segment, prepend them to the
+      // bytes that were pushed in
+      if (bytesInBuffer) {
+        everything = new Uint8Array(bytes.byteLength + bytesInBuffer);
+        everything.set(buffer.subarray(0, bytesInBuffer));
+        everything.set(bytes, bytesInBuffer);
+        bytesInBuffer = 0;
+      } else {
+        everything = bytes;
+      }
+
+      // While we have enough data for a packet
+      while (endIndex < everything.byteLength) {
+        // Look for a pair of start and end sync bytes in the data..
+        if (everything[startIndex] === SYNC_BYTE && everything[endIndex] === SYNC_BYTE) {
+          // We found a packet so emit it and jump one whole packet forward in
+          // the stream
+          this.trigger('data', everything.subarray(startIndex, endIndex));
+          startIndex += MP2T_PACKET_LENGTH;
+          endIndex += MP2T_PACKET_LENGTH;
+          continue;
+        }
+        // If we get here, we have somehow become de-synchronized and we need to step
+        // forward one byte at a time until we find a pair of sync bytes that denote
+        // a packet
+        startIndex++;
+        endIndex++;
+      }
+
+      // If there was some data left over at the end of the segment that couldn't
+      // possibly be a whole packet, keep it because it might be the start of a packet
+      // that continues in the next segment
+      if (startIndex < everything.byteLength) {
+        buffer.set(everything.subarray(startIndex), 0);
+        bytesInBuffer = everything.byteLength - startIndex;
+      }
+    };
+
+    /**
+     * Passes identified M2TS packets to the TransportParseStream to be parsed
+    **/
+    this.flush = function () {
+      // If the buffer contains a whole packet when we are being flushed, emit it
+      // and empty the buffer. Otherwise hold onto the data because it may be
+      // important for decoding the next segment
+      if (bytesInBuffer === MP2T_PACKET_LENGTH && buffer[0] === SYNC_BYTE) {
+        this.trigger('data', buffer);
+        bytesInBuffer = 0;
+      }
+      this.trigger('done');
+    };
+    this.endTimeline = function () {
+      this.flush();
+      this.trigger('endedtimeline');
+    };
+    this.reset = function () {
+      bytesInBuffer = 0;
+      this.trigger('reset');
+    };
+  };
+  _TransportPacketStream.prototype = new stream();
+
+  /**
+   * Accepts an MP2T TransportPacketStream and emits data events with parsed
+   * forms of the individual transport stream packets.
+   */
+  _TransportParseStream = function TransportParseStream() {
+    var parsePsi, parsePat, parsePmt, self;
+    _TransportParseStream.prototype.init.call(this);
+    self = this;
+    this.packetsWaitingForPmt = [];
+    this.programMapTable = undefined;
+    parsePsi = function parsePsi(payload, psi) {
+      var offset = 0;
+
+      // PSI packets may be split into multiple sections and those
+      // sections may be split into multiple packets. If a PSI
+      // section starts in this packet, the payload_unit_start_indicator
+      // will be true and the first byte of the payload will indicate
+      // the offset from the current position to the start of the
+      // section.
+      if (psi.payloadUnitStartIndicator) {
+        offset += payload[offset] + 1;
+      }
+      if (psi.type === 'pat') {
+        parsePat(payload.subarray(offset), psi);
+      } else {
+        parsePmt(payload.subarray(offset), psi);
+      }
+    };
+    parsePat = function parsePat(payload, pat) {
+      pat.section_number = payload[7]; // eslint-disable-line camelcase
+      pat.last_section_number = payload[8]; // eslint-disable-line camelcase
+
+      // skip the PSI header and parse the first PMT entry
+      self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];
+      pat.pmtPid = self.pmtPid;
+    };
+
+    /**
+     * Parse out the relevant fields of a Program Map Table (PMT).
+     * @param payload {Uint8Array} the PMT-specific portion of an MP2T
+     * packet. The first byte in this array should be the table_id
+     * field.
+     * @param pmt {object} the object that should be decorated with
+     * fields parsed from the PMT.
+     */
+    parsePmt = function parsePmt(payload, pmt) {
+      var sectionLength, tableEnd, programInfoLength, offset;
+
+      // PMTs can be sent ahead of the time when they should actually
+      // take effect. We don't believe this should ever be the case
+      // for HLS but we'll ignore "forward" PMT declarations if we see
+      // them. Future PMT declarations have the current_next_indicator
+      // set to zero.
+      if (!(payload[5] & 0x01)) {
+        return;
+      }
+
+      // overwrite any existing program map table
+      self.programMapTable = {
+        video: null,
+        audio: null,
+        'timed-metadata': {}
+      };
+
+      // the mapping table ends at the end of the current section
+      sectionLength = (payload[1] & 0x0f) << 8 | payload[2];
+      tableEnd = 3 + sectionLength - 4;
+
+      // to determine where the table is, we have to figure out how
+      // long the program info descriptors are
+      programInfoLength = (payload[10] & 0x0f) << 8 | payload[11];
+
+      // advance the offset to the first entry in the mapping table
+      offset = 12 + programInfoLength;
+      while (offset < tableEnd) {
+        var streamType = payload[offset];
+        var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2];
+
+        // only map a single elementary_pid for audio and video stream types
+        // TODO: should this be done for metadata too? for now maintain behavior of
+        //       multiple metadata streams
+        if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {
+          self.programMapTable.video = pid;
+        } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {
+          self.programMapTable.audio = pid;
+        } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {
+          // map pid to stream type for metadata streams
+          self.programMapTable['timed-metadata'][pid] = streamType;
+        }
+
+        // move to the next table entry
+        // skip past the elementary stream descriptors, if present
+        offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;
+      }
+
+      // record the map on the packet as well
+      pmt.programMapTable = self.programMapTable;
+    };
+
+    /**
+     * Deliver a new MP2T packet to the next stream in the pipeline.
+     */
+    this.push = function (packet) {
+      var result = {},
+        offset = 4;
+      result.payloadUnitStartIndicator = !!(packet[1] & 0x40);
+
+      // pid is a 13-bit field starting at the last bit of packet[1]
+      result.pid = packet[1] & 0x1f;
+      result.pid <<= 8;
+      result.pid |= packet[2];
+
+      // if an adaption field is present, its length is specified by the
+      // fifth byte of the TS packet header. The adaptation field is
+      // used to add stuffing to PES packets that don't fill a complete
+      // TS packet, and to specify some forms of timing and control data
+      // that we do not currently use.
+      if ((packet[3] & 0x30) >>> 4 > 0x01) {
+        offset += packet[offset] + 1;
+      }
+
+      // parse the rest of the packet based on the type
+      if (result.pid === 0) {
+        result.type = 'pat';
+        parsePsi(packet.subarray(offset), result);
+        this.trigger('data', result);
+      } else if (result.pid === this.pmtPid) {
+        result.type = 'pmt';
+        parsePsi(packet.subarray(offset), result);
+        this.trigger('data', result);
+
+        // if there are any packets waiting for a PMT to be found, process them now
+        while (this.packetsWaitingForPmt.length) {
+          this.processPes_.apply(this, this.packetsWaitingForPmt.shift());
+        }
+      } else if (this.programMapTable === undefined) {
+        // When we have not seen a PMT yet, defer further processing of
+        // PES packets until one has been parsed
+        this.packetsWaitingForPmt.push([packet, offset, result]);
+      } else {
+        this.processPes_(packet, offset, result);
+      }
+    };
+    this.processPes_ = function (packet, offset, result) {
+      // set the appropriate stream type
+      if (result.pid === this.programMapTable.video) {
+        result.streamType = streamTypes.H264_STREAM_TYPE;
+      } else if (result.pid === this.programMapTable.audio) {
+        result.streamType = streamTypes.ADTS_STREAM_TYPE;
+      } else {
+        // if not video or audio, it is timed-metadata or unknown
+        // if unknown, streamType will be undefined
+        result.streamType = this.programMapTable['timed-metadata'][result.pid];
+      }
+      result.type = 'pes';
+      result.data = packet.subarray(offset);
+      this.trigger('data', result);
+    };
+  };
+  _TransportParseStream.prototype = new stream();
+  _TransportParseStream.STREAM_TYPES = {
+    h264: 0x1b,
+    adts: 0x0f
+  };
+
+  /**
+   * Reconsistutes program elementary stream (PES) packets from parsed
+   * transport stream packets. That is, if you pipe an
+   * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output
+   * events will be events which capture the bytes for individual PES
+   * packets plus relevant metadata that has been extracted from the
+   * container.
+   */
+  _ElementaryStream = function ElementaryStream() {
+    var self = this,
+      segmentHadPmt = false,
+      // PES packet fragments
+      video = {
+        data: [],
+        size: 0
+      },
+      audio = {
+        data: [],
+        size: 0
+      },
+      timedMetadata = {
+        data: [],
+        size: 0
+      },
+      programMapTable,
+      parsePes = function parsePes(payload, pes) {
+        var ptsDtsFlags;
+        var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2];
+        // default to an empty array
+        pes.data = new Uint8Array();
+        // In certain live streams, the start of a TS fragment has ts packets
+        // that are frame data that is continuing from the previous fragment. This
+        // is to check that the pes data is the start of a new pes payload
+        if (startPrefix !== 1) {
+          return;
+        }
+        // get the packet length, this will be 0 for video
+        pes.packetLength = 6 + (payload[4] << 8 | payload[5]);
+
+        // find out if this packets starts a new keyframe
+        pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0;
+        // PES packets may be annotated with a PTS value, or a PTS value
+        // and a DTS value. Determine what combination of values is
+        // available to work with.
+        ptsDtsFlags = payload[7];
+
+        // PTS and DTS are normally stored as a 33-bit number.  Javascript
+        // performs all bitwise operations on 32-bit integers but javascript
+        // supports a much greater range (52-bits) of integer using standard
+        // mathematical operations.
+        // We construct a 31-bit value using bitwise operators over the 31
+        // most significant bits and then multiply by 4 (equal to a left-shift
+        // of 2) before we add the final 2 least significant bits of the
+        // timestamp (equal to an OR.)
+        if (ptsDtsFlags & 0xC0) {
+          // the PTS and DTS are not written out directly. For information
+          // on how they are encoded, see
+          // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
+          pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;
+          pes.pts *= 4; // Left shift by 2
+          pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs
+          pes.dts = pes.pts;
+          if (ptsDtsFlags & 0x40) {
+            pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;
+            pes.dts *= 4; // Left shift by 2
+            pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs
+          }
+        }
+        // the data section starts immediately after the PES header.
+        // pes_header_data_length specifies the number of header bytes
+        // that follow the last byte of the field.
+        pes.data = payload.subarray(9 + payload[8]);
+      },
+      /**
+        * Pass completely parsed PES packets to the next stream in the pipeline
+       **/
+      flushStream = function flushStream(stream, type, forceFlush) {
+        var packetData = new Uint8Array(stream.size),
+          event = {
+            type: type
+          },
+          i = 0,
+          offset = 0,
+          packetFlushable = false,
+          fragment;
+
+        // do nothing if there is not enough buffered data for a complete
+        // PES header
+        if (!stream.data.length || stream.size < 9) {
+          return;
+        }
+        event.trackId = stream.data[0].pid;
+
+        // reassemble the packet
+        for (i = 0; i < stream.data.length; i++) {
+          fragment = stream.data[i];
+          packetData.set(fragment.data, offset);
+          offset += fragment.data.byteLength;
+        }
+
+        // parse assembled packet's PES header
+        parsePes(packetData, event);
+
+        // non-video PES packets MUST have a non-zero PES_packet_length
+        // check that there is enough stream data to fill the packet
+        packetFlushable = type === 'video' || event.packetLength <= stream.size;
+
+        // flush pending packets if the conditions are right
+        if (forceFlush || packetFlushable) {
+          stream.size = 0;
+          stream.data.length = 0;
+        }
+
+        // only emit packets that are complete. this is to avoid assembling
+        // incomplete PES packets due to poor segmentation
+        if (packetFlushable) {
+          self.trigger('data', event);
+        }
+      };
+    _ElementaryStream.prototype.init.call(this);
+
+    /**
+     * Identifies M2TS packet types and parses PES packets using metadata
+     * parsed from the PMT
+     **/
+    this.push = function (data) {
+      ({
+        pat: function pat() {
+          // we have to wait for the PMT to arrive as well before we
+          // have any meaningful metadata
+        },
+        pes: function pes() {
+          var stream, streamType;
+          switch (data.streamType) {
+            case streamTypes.H264_STREAM_TYPE:
+              stream = video;
+              streamType = 'video';
+              break;
+            case streamTypes.ADTS_STREAM_TYPE:
+              stream = audio;
+              streamType = 'audio';
+              break;
+            case streamTypes.METADATA_STREAM_TYPE:
+              stream = timedMetadata;
+              streamType = 'timed-metadata';
+              break;
+            default:
+              // ignore unknown stream types
+              return;
+          }
+
+          // if a new packet is starting, we can flush the completed
+          // packet
+          if (data.payloadUnitStartIndicator) {
+            flushStream(stream, streamType, true);
+          }
+
+          // buffer this fragment until we are sure we've received the
+          // complete payload
+          stream.data.push(data);
+          stream.size += data.data.byteLength;
+        },
+        pmt: function pmt() {
+          var event = {
+            type: 'metadata',
+            tracks: []
+          };
+          programMapTable = data.programMapTable;
+
+          // translate audio and video streams to tracks
+          if (programMapTable.video !== null) {
+            event.tracks.push({
+              timelineStartInfo: {
+                baseMediaDecodeTime: 0
+              },
+              id: +programMapTable.video,
+              codec: 'avc',
+              type: 'video'
+            });
+          }
+          if (programMapTable.audio !== null) {
+            event.tracks.push({
+              timelineStartInfo: {
+                baseMediaDecodeTime: 0
+              },
+              id: +programMapTable.audio,
+              codec: 'adts',
+              type: 'audio'
+            });
+          }
+          segmentHadPmt = true;
+          self.trigger('data', event);
+        }
+      })[data.type]();
+    };
+    this.reset = function () {
+      video.size = 0;
+      video.data.length = 0;
+      audio.size = 0;
+      audio.data.length = 0;
+      this.trigger('reset');
+    };
+
+    /**
+     * Flush any remaining input. Video PES packets may be of variable
+     * length. Normally, the start of a new video packet can trigger the
+     * finalization of the previous packet. That is not possible if no
+     * more video is forthcoming, however. In that case, some other
+     * mechanism (like the end of the file) has to be employed. When it is
+     * clear that no additional data is forthcoming, calling this method
+     * will flush the buffered packets.
+     */
+    this.flushStreams_ = function () {
+      // !!THIS ORDER IS IMPORTANT!!
+      // video first then audio
+      flushStream(video, 'video');
+      flushStream(audio, 'audio');
+      flushStream(timedMetadata, 'timed-metadata');
+    };
+    this.flush = function () {
+      // if on flush we haven't had a pmt emitted
+      // and we have a pmt to emit. emit the pmt
+      // so that we trigger a trackinfo downstream.
+      if (!segmentHadPmt && programMapTable) {
+        var pmt = {
+          type: 'metadata',
+          tracks: []
+        };
+        // translate audio and video streams to tracks
+        if (programMapTable.video !== null) {
+          pmt.tracks.push({
+            timelineStartInfo: {
+              baseMediaDecodeTime: 0
+            },
+            id: +programMapTable.video,
+            codec: 'avc',
+            type: 'video'
+          });
+        }
+        if (programMapTable.audio !== null) {
+          pmt.tracks.push({
+            timelineStartInfo: {
+              baseMediaDecodeTime: 0
+            },
+            id: +programMapTable.audio,
+            codec: 'adts',
+            type: 'audio'
+          });
+        }
+        self.trigger('data', pmt);
+      }
+      segmentHadPmt = false;
+      this.flushStreams_();
+      this.trigger('done');
+    };
+  };
+  _ElementaryStream.prototype = new stream();
+  var m2ts = {
+    PAT_PID: 0x0000,
+    MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH,
+    TransportPacketStream: _TransportPacketStream,
+    TransportParseStream: _TransportParseStream,
+    ElementaryStream: _ElementaryStream,
+    TimestampRolloverStream: TimestampRolloverStream,
+    CaptionStream: captionStream.CaptionStream,
+    Cea608Stream: captionStream.Cea608Stream,
+    Cea708Stream: captionStream.Cea708Stream,
+    MetadataStream: metadataStream
+  };
+  for (var type in streamTypes) {
+    if (streamTypes.hasOwnProperty(type)) {
+      m2ts[type] = streamTypes[type];
+    }
+  }
+  var m2ts_1 = m2ts;
+
+  var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;
+  var _AdtsStream;
+  var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+
+  /*
+   * Accepts a ElementaryStream and emits data events with parsed
+   * AAC Audio Frames of the individual packets. Input audio in ADTS
+   * format is unpacked and re-emitted as AAC frames.
+   *
+   * @see http://wiki.multimedia.cx/index.php?title=ADTS
+   * @see http://wiki.multimedia.cx/?title=Understanding_AAC
+   */
+  _AdtsStream = function AdtsStream(handlePartialSegments) {
+    var buffer,
+      frameNum = 0;
+    _AdtsStream.prototype.init.call(this);
+    this.skipWarn_ = function (start, end) {
+      this.trigger('log', {
+        level: 'warn',
+        message: "adts skiping bytes " + start + " to " + end + " in frame " + frameNum + " outside syncword"
+      });
+    };
+    this.push = function (packet) {
+      var i = 0,
+        frameLength,
+        protectionSkipBytes,
+        oldBuffer,
+        sampleCount,
+        adtsFrameDuration;
+      if (!handlePartialSegments) {
+        frameNum = 0;
+      }
+      if (packet.type !== 'audio') {
+        // ignore non-audio data
+        return;
+      }
+
+      // Prepend any data in the buffer to the input data so that we can parse
+      // aac frames the cross a PES packet boundary
+      if (buffer && buffer.length) {
+        oldBuffer = buffer;
+        buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);
+        buffer.set(oldBuffer);
+        buffer.set(packet.data, oldBuffer.byteLength);
+      } else {
+        buffer = packet.data;
+      }
+
+      // unpack any ADTS frames which have been fully received
+      // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS
+      var skip;
+
+      // We use i + 7 here because we want to be able to parse the entire header.
+      // If we don't have enough bytes to do that, then we definitely won't have a full frame.
+      while (i + 7 < buffer.length) {
+        // Look for the start of an ADTS header..
+        if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {
+          if (typeof skip !== 'number') {
+            skip = i;
+          }
+          // If a valid header was not found,  jump one forward and attempt to
+          // find a valid ADTS header starting at the next byte
+          i++;
+          continue;
+        }
+        if (typeof skip === 'number') {
+          this.skipWarn_(skip, i);
+          skip = null;
+        }
+
+        // The protection skip bit tells us if we have 2 bytes of CRC data at the
+        // end of the ADTS header
+        protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2;
+
+        // Frame length is a 13 bit integer starting 16 bits from the
+        // end of the sync sequence
+        // NOTE: frame length includes the size of the header
+        frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;
+        sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;
+        adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$1 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2];
+
+        // If we don't have enough data to actually finish this ADTS frame,
+        // then we have to wait for more data
+        if (buffer.byteLength - i < frameLength) {
+          break;
+        }
+
+        // Otherwise, deliver the complete AAC frame
+        this.trigger('data', {
+          pts: packet.pts + frameNum * adtsFrameDuration,
+          dts: packet.dts + frameNum * adtsFrameDuration,
+          sampleCount: sampleCount,
+          audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,
+          channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,
+          samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],
+          samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,
+          // assume ISO/IEC 14496-12 AudioSampleEntry default of 16
+          samplesize: 16,
+          // data is the frame without it's header
+          data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)
+        });
+        frameNum++;
+        i += frameLength;
+      }
+      if (typeof skip === 'number') {
+        this.skipWarn_(skip, i);
+        skip = null;
+      }
+
+      // remove processed bytes from the buffer.
+      buffer = buffer.subarray(i);
+    };
+    this.flush = function () {
+      frameNum = 0;
+      this.trigger('done');
+    };
+    this.reset = function () {
+      buffer = void 0;
+      this.trigger('reset');
+    };
+    this.endTimeline = function () {
+      buffer = void 0;
+      this.trigger('endedtimeline');
+    };
+  };
+  _AdtsStream.prototype = new stream();
+  var adts = _AdtsStream;
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   */
+
+  var ExpGolomb;
+
+  /**
+   * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+   * scheme used by h264.
+   */
+  ExpGolomb = function ExpGolomb(workingData) {
+    var
+      // the number of bytes left to examine in workingData
+      workingBytesAvailable = workingData.byteLength,
+      // the current word being examined
+      workingWord = 0,
+      // :uint
+
+      // the number of bits left to examine in the current word
+      workingBitsAvailable = 0; // :uint;
+
+    // ():uint
+    this.length = function () {
+      return 8 * workingBytesAvailable;
+    };
+
+    // ():uint
+    this.bitsAvailable = function () {
+      return 8 * workingBytesAvailable + workingBitsAvailable;
+    };
+
+    // ():void
+    this.loadWord = function () {
+      var position = workingData.byteLength - workingBytesAvailable,
+        workingBytes = new Uint8Array(4),
+        availableBytes = Math.min(4, workingBytesAvailable);
+      if (availableBytes === 0) {
+        throw new Error('no bytes available');
+      }
+      workingBytes.set(workingData.subarray(position, position + availableBytes));
+      workingWord = new DataView(workingBytes.buffer).getUint32(0);
+
+      // track the amount of workingData that has been processed
+      workingBitsAvailable = availableBytes * 8;
+      workingBytesAvailable -= availableBytes;
+    };
+
+    // (count:int):void
+    this.skipBits = function (count) {
+      var skipBytes; // :int
+      if (workingBitsAvailable > count) {
+        workingWord <<= count;
+        workingBitsAvailable -= count;
+      } else {
+        count -= workingBitsAvailable;
+        skipBytes = Math.floor(count / 8);
+        count -= skipBytes * 8;
+        workingBytesAvailable -= skipBytes;
+        this.loadWord();
+        workingWord <<= count;
+        workingBitsAvailable -= count;
+      }
+    };
+
+    // (size:int):uint
+    this.readBits = function (size) {
+      var bits = Math.min(workingBitsAvailable, size),
+        // :uint
+        valu = workingWord >>> 32 - bits; // :uint
+      // if size > 31, handle error
+      workingBitsAvailable -= bits;
+      if (workingBitsAvailable > 0) {
+        workingWord <<= bits;
+      } else if (workingBytesAvailable > 0) {
+        this.loadWord();
+      }
+      bits = size - bits;
+      if (bits > 0) {
+        return valu << bits | this.readBits(bits);
+      }
+      return valu;
+    };
+
+    // ():uint
+    this.skipLeadingZeros = function () {
+      var leadingZeroCount; // :uint
+      for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {
+        if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {
+          // the first bit of working word is 1
+          workingWord <<= leadingZeroCount;
+          workingBitsAvailable -= leadingZeroCount;
+          return leadingZeroCount;
+        }
+      }
+
+      // we exhausted workingWord and still have not found a 1
+      this.loadWord();
+      return leadingZeroCount + this.skipLeadingZeros();
+    };
+
+    // ():void
+    this.skipUnsignedExpGolomb = function () {
+      this.skipBits(1 + this.skipLeadingZeros());
+    };
+
+    // ():void
+    this.skipExpGolomb = function () {
+      this.skipBits(1 + this.skipLeadingZeros());
+    };
+
+    // ():uint
+    this.readUnsignedExpGolomb = function () {
+      var clz = this.skipLeadingZeros(); // :uint
+      return this.readBits(clz + 1) - 1;
+    };
+
+    // ():int
+    this.readExpGolomb = function () {
+      var valu = this.readUnsignedExpGolomb(); // :int
+      if (0x01 & valu) {
+        // the number is odd if the low order bit is set
+        return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
+      }
+
+      return -1 * (valu >>> 1); // divide by two then make it negative
+    };
+
+    // Some convenience functions
+    // :Boolean
+    this.readBoolean = function () {
+      return this.readBits(1) === 1;
+    };
+
+    // ():int
+    this.readUnsignedByte = function () {
+      return this.readBits(8);
+    };
+    this.loadWord();
+  };
+  var expGolomb = ExpGolomb;
+
+  var _H264Stream, _NalByteStream;
+  var PROFILES_WITH_OPTIONAL_SPS_DATA;
+
+  /**
+   * Accepts a NAL unit byte stream and unpacks the embedded NAL units.
+   */
+  _NalByteStream = function NalByteStream() {
+    var syncPoint = 0,
+      i,
+      buffer;
+    _NalByteStream.prototype.init.call(this);
+
+    /*
+     * Scans a byte stream and triggers a data event with the NAL units found.
+     * @param {Object} data Event received from H264Stream
+     * @param {Uint8Array} data.data The h264 byte stream to be scanned
+     *
+     * @see H264Stream.push
+     */
+    this.push = function (data) {
+      var swapBuffer;
+      if (!buffer) {
+        buffer = data.data;
+      } else {
+        swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);
+        swapBuffer.set(buffer);
+        swapBuffer.set(data.data, buffer.byteLength);
+        buffer = swapBuffer;
+      }
+      var len = buffer.byteLength;
+
+      // Rec. ITU-T H.264, Annex B
+      // scan for NAL unit boundaries
+
+      // a match looks like this:
+      // 0 0 1 .. NAL .. 0 0 1
+      // ^ sync point        ^ i
+      // or this:
+      // 0 0 1 .. NAL .. 0 0 0
+      // ^ sync point        ^ i
+
+      // advance the sync point to a NAL start, if necessary
+      for (; syncPoint < len - 3; syncPoint++) {
+        if (buffer[syncPoint + 2] === 1) {
+          // the sync point is properly aligned
+          i = syncPoint + 5;
+          break;
+        }
+      }
+      while (i < len) {
+        // look at the current byte to determine if we've hit the end of
+        // a NAL unit boundary
+        switch (buffer[i]) {
+          case 0:
+            // skip past non-sync sequences
+            if (buffer[i - 1] !== 0) {
+              i += 2;
+              break;
+            } else if (buffer[i - 2] !== 0) {
+              i++;
+              break;
+            }
+
+            // deliver the NAL unit if it isn't empty
+            if (syncPoint + 3 !== i - 2) {
+              this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+            }
+
+            // drop trailing zeroes
+            do {
+              i++;
+            } while (buffer[i] !== 1 && i < len);
+            syncPoint = i - 2;
+            i += 3;
+            break;
+          case 1:
+            // skip past non-sync sequences
+            if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {
+              i += 3;
+              break;
+            }
+
+            // deliver the NAL unit
+            this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
+            syncPoint = i - 2;
+            i += 3;
+            break;
+          default:
+            // the current byte isn't a one or zero, so it cannot be part
+            // of a sync sequence
+            i += 3;
+            break;
+        }
+      }
+      // filter out the NAL units that were delivered
+      buffer = buffer.subarray(syncPoint);
+      i -= syncPoint;
+      syncPoint = 0;
+    };
+    this.reset = function () {
+      buffer = null;
+      syncPoint = 0;
+      this.trigger('reset');
+    };
+    this.flush = function () {
+      // deliver the last buffered NAL unit
+      if (buffer && buffer.byteLength > 3) {
+        this.trigger('data', buffer.subarray(syncPoint + 3));
+      }
+      // reset the stream state
+      buffer = null;
+      syncPoint = 0;
+      this.trigger('done');
+    };
+    this.endTimeline = function () {
+      this.flush();
+      this.trigger('endedtimeline');
+    };
+  };
+  _NalByteStream.prototype = new stream();
+
+  // values of profile_idc that indicate additional fields are included in the SPS
+  // see Recommendation ITU-T H.264 (4/2013),
+  // 7.3.2.1.1 Sequence parameter set data syntax
+  PROFILES_WITH_OPTIONAL_SPS_DATA = {
+    100: true,
+    110: true,
+    122: true,
+    244: true,
+    44: true,
+    83: true,
+    86: true,
+    118: true,
+    128: true,
+    // TODO: the three profiles below don't
+    // appear to have sps data in the specificiation anymore?
+    138: true,
+    139: true,
+    134: true
+  };
+
+  /**
+   * Accepts input from a ElementaryStream and produces H.264 NAL unit data
+   * events.
+   */
+  _H264Stream = function H264Stream() {
+    var nalByteStream = new _NalByteStream(),
+      self,
+      trackId,
+      currentPts,
+      currentDts,
+      discardEmulationPreventionBytes,
+      readSequenceParameterSet,
+      skipScalingList;
+    _H264Stream.prototype.init.call(this);
+    self = this;
+
+    /*
+     * Pushes a packet from a stream onto the NalByteStream
+     *
+     * @param {Object} packet - A packet received from a stream
+     * @param {Uint8Array} packet.data - The raw bytes of the packet
+     * @param {Number} packet.dts - Decode timestamp of the packet
+     * @param {Number} packet.pts - Presentation timestamp of the packet
+     * @param {Number} packet.trackId - The id of the h264 track this packet came from
+     * @param {('video'|'audio')} packet.type - The type of packet
+     *
+     */
+    this.push = function (packet) {
+      if (packet.type !== 'video') {
+        return;
+      }
+      trackId = packet.trackId;
+      currentPts = packet.pts;
+      currentDts = packet.dts;
+      nalByteStream.push(packet);
+    };
+
+    /*
+     * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps
+     * for the NALUs to the next stream component.
+     * Also, preprocess caption and sequence parameter NALUs.
+     *
+     * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`
+     * @see NalByteStream.push
+     */
+    nalByteStream.on('data', function (data) {
+      var event = {
+        trackId: trackId,
+        pts: currentPts,
+        dts: currentDts,
+        data: data,
+        nalUnitTypeCode: data[0] & 0x1f
+      };
+      switch (event.nalUnitTypeCode) {
+        case 0x05:
+          event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';
+          break;
+        case 0x06:
+          event.nalUnitType = 'sei_rbsp';
+          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+          break;
+        case 0x07:
+          event.nalUnitType = 'seq_parameter_set_rbsp';
+          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
+          event.config = readSequenceParameterSet(event.escapedRBSP);
+          break;
+        case 0x08:
+          event.nalUnitType = 'pic_parameter_set_rbsp';
+          break;
+        case 0x09:
+          event.nalUnitType = 'access_unit_delimiter_rbsp';
+          break;
+      }
+      // This triggers data on the H264Stream
+      self.trigger('data', event);
+    });
+    nalByteStream.on('done', function () {
+      self.trigger('done');
+    });
+    nalByteStream.on('partialdone', function () {
+      self.trigger('partialdone');
+    });
+    nalByteStream.on('reset', function () {
+      self.trigger('reset');
+    });
+    nalByteStream.on('endedtimeline', function () {
+      self.trigger('endedtimeline');
+    });
+    this.flush = function () {
+      nalByteStream.flush();
+    };
+    this.partialFlush = function () {
+      nalByteStream.partialFlush();
+    };
+    this.reset = function () {
+      nalByteStream.reset();
+    };
+    this.endTimeline = function () {
+      nalByteStream.endTimeline();
+    };
+
+    /**
+     * Advance the ExpGolomb decoder past a scaling list. The scaling
+     * list is optionally transmitted as part of a sequence parameter
+     * set and is not relevant to transmuxing.
+     * @param count {number} the number of entries in this scaling list
+     * @param expGolombDecoder {object} an ExpGolomb pointed to the
+     * start of a scaling list
+     * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+     */
+    skipScalingList = function skipScalingList(count, expGolombDecoder) {
+      var lastScale = 8,
+        nextScale = 8,
+        j,
+        deltaScale;
+      for (j = 0; j < count; j++) {
+        if (nextScale !== 0) {
+          deltaScale = expGolombDecoder.readExpGolomb();
+          nextScale = (lastScale + deltaScale + 256) % 256;
+        }
+        lastScale = nextScale === 0 ? lastScale : nextScale;
+      }
+    };
+
+    /**
+     * Expunge any "Emulation Prevention" bytes from a "Raw Byte
+     * Sequence Payload"
+     * @param data {Uint8Array} the bytes of a RBSP from a NAL
+     * unit
+     * @return {Uint8Array} the RBSP without any Emulation
+     * Prevention Bytes
+     */
+    discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {
+      var length = data.byteLength,
+        emulationPreventionBytesPositions = [],
+        i = 1,
+        newLength,
+        newData;
+
+      // Find all `Emulation Prevention Bytes`
+      while (i < length - 2) {
+        if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
+          emulationPreventionBytesPositions.push(i + 2);
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+
+      // If no Emulation Prevention Bytes were found just return the original
+      // array
+      if (emulationPreventionBytesPositions.length === 0) {
+        return data;
+      }
+
+      // Create a new array to hold the NAL unit data
+      newLength = length - emulationPreventionBytesPositions.length;
+      newData = new Uint8Array(newLength);
+      var sourceIndex = 0;
+      for (i = 0; i < newLength; sourceIndex++, i++) {
+        if (sourceIndex === emulationPreventionBytesPositions[0]) {
+          // Skip this byte
+          sourceIndex++;
+          // Remove this position index
+          emulationPreventionBytesPositions.shift();
+        }
+        newData[i] = data[sourceIndex];
+      }
+      return newData;
+    };
+
+    /**
+     * Read a sequence parameter set and return some interesting video
+     * properties. A sequence parameter set is the H264 metadata that
+     * describes the properties of upcoming video frames.
+     * @param data {Uint8Array} the bytes of a sequence parameter set
+     * @return {object} an object with configuration parsed from the
+     * sequence parameter set, including the dimensions of the
+     * associated video frames.
+     */
+    readSequenceParameterSet = function readSequenceParameterSet(data) {
+      var frameCropLeftOffset = 0,
+        frameCropRightOffset = 0,
+        frameCropTopOffset = 0,
+        frameCropBottomOffset = 0,
+        expGolombDecoder,
+        profileIdc,
+        levelIdc,
+        profileCompatibility,
+        chromaFormatIdc,
+        picOrderCntType,
+        numRefFramesInPicOrderCntCycle,
+        picWidthInMbsMinus1,
+        picHeightInMapUnitsMinus1,
+        frameMbsOnlyFlag,
+        scalingListCount,
+        sarRatio = [1, 1],
+        aspectRatioIdc,
+        i;
+      expGolombDecoder = new expGolomb(data);
+      profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc
+      profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag
+      levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)
+      expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id
+
+      // some profiles have more optional data we don't need
+      if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {
+        chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
+        if (chromaFormatIdc === 3) {
+          expGolombDecoder.skipBits(1); // separate_colour_plane_flag
+        }
+
+        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8
+        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8
+        expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
+        if (expGolombDecoder.readBoolean()) {
+          // seq_scaling_matrix_present_flag
+          scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+          for (i = 0; i < scalingListCount; i++) {
+            if (expGolombDecoder.readBoolean()) {
+              // seq_scaling_list_present_flag[ i ]
+              if (i < 6) {
+                skipScalingList(16, expGolombDecoder);
+              } else {
+                skipScalingList(64, expGolombDecoder);
+              }
+            }
+          }
+        }
+      }
+      expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4
+      picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
+      if (picOrderCntType === 0) {
+        expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4
+      } else if (picOrderCntType === 1) {
+        expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag
+        expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic
+        expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field
+        numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();
+        for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+          expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]
+        }
+      }
+
+      expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames
+      expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
+
+      picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+      picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
+      frameMbsOnlyFlag = expGolombDecoder.readBits(1);
+      if (frameMbsOnlyFlag === 0) {
+        expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag
+      }
+
+      expGolombDecoder.skipBits(1); // direct_8x8_inference_flag
+      if (expGolombDecoder.readBoolean()) {
+        // frame_cropping_flag
+        frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
+        frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
+        frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
+        frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
+      }
+      if (expGolombDecoder.readBoolean()) {
+        // vui_parameters_present_flag
+        if (expGolombDecoder.readBoolean()) {
+          // aspect_ratio_info_present_flag
+          aspectRatioIdc = expGolombDecoder.readUnsignedByte();
+          switch (aspectRatioIdc) {
+            case 1:
+              sarRatio = [1, 1];
+              break;
+            case 2:
+              sarRatio = [12, 11];
+              break;
+            case 3:
+              sarRatio = [10, 11];
+              break;
+            case 4:
+              sarRatio = [16, 11];
+              break;
+            case 5:
+              sarRatio = [40, 33];
+              break;
+            case 6:
+              sarRatio = [24, 11];
+              break;
+            case 7:
+              sarRatio = [20, 11];
+              break;
+            case 8:
+              sarRatio = [32, 11];
+              break;
+            case 9:
+              sarRatio = [80, 33];
+              break;
+            case 10:
+              sarRatio = [18, 11];
+              break;
+            case 11:
+              sarRatio = [15, 11];
+              break;
+            case 12:
+              sarRatio = [64, 33];
+              break;
+            case 13:
+              sarRatio = [160, 99];
+              break;
+            case 14:
+              sarRatio = [4, 3];
+              break;
+            case 15:
+              sarRatio = [3, 2];
+              break;
+            case 16:
+              sarRatio = [2, 1];
+              break;
+            case 255:
+              {
+                sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];
+                break;
+              }
+          }
+          if (sarRatio) {
+            sarRatio[0] / sarRatio[1];
+          }
+        }
+      }
+      return {
+        profileIdc: profileIdc,
+        levelIdc: levelIdc,
+        profileCompatibility: profileCompatibility,
+        width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,
+        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,
+        // sar is sample aspect ratio
+        sarRatio: sarRatio
+      };
+    };
+  };
+  _H264Stream.prototype = new stream();
+  var h264 = {
+    H264Stream: _H264Stream,
+    NalByteStream: _NalByteStream
+  };
+
+  /**
+   * mux.js
+   *
+   * Copyright (c) Brightcove
+   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+   *
+   * Utilities to detect basic properties and metadata about Aac data.
+   */
+
+  var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+  var parseId3TagSize = function parseId3TagSize(header, byteIndex) {
+    var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],
+      flags = header[byteIndex + 5],
+      footerPresent = (flags & 16) >> 4;
+
+    // if we get a negative returnSize clamp it to 0
+    returnSize = returnSize >= 0 ? returnSize : 0;
+    if (footerPresent) {
+      return returnSize + 20;
+    }
+    return returnSize + 10;
+  };
+  var getId3Offset = function getId3Offset(data, offset) {
+    if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {
+      return offset;
+    }
+    offset += parseId3TagSize(data, offset);
+    return getId3Offset(data, offset);
+  };
+
+  // TODO: use vhs-utils
+  var isLikelyAacData$1 = function isLikelyAacData(data) {
+    var offset = getId3Offset(data, 0);
+    return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 &&
+    // verify that the 2 layer bits are 0, aka this
+    // is not mp3 data but aac data.
+    (data[offset + 1] & 0x16) === 0x10;
+  };
+  var parseSyncSafeInteger = function parseSyncSafeInteger(data) {
+    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];
+  };
+
+  // return a percent-encoded representation of the specified byte range
+  // @see http://en.wikipedia.org/wiki/Percent-encoding
+  var percentEncode = function percentEncode(bytes, start, end) {
+    var i,
+      result = '';
+    for (i = start; i < end; i++) {
+      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
+    }
+    return result;
+  };
+
+  // return the string representation of the specified byte range,
+  // interpreted as ISO-8859-1.
+  var parseIso88591 = function parseIso88591(bytes, start, end) {
+    return unescape(percentEncode(bytes, start, end)); // jshint ignore:line
+  };
+
+  var parseAdtsSize = function parseAdtsSize(header, byteIndex) {
+    var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,
+      middle = header[byteIndex + 4] << 3,
+      highTwo = header[byteIndex + 3] & 0x3 << 11;
+    return highTwo | middle | lowThree;
+  };
+  var parseType = function parseType(header, byteIndex) {
+    if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {
+      return 'timed-metadata';
+    } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {
+      return 'audio';
+    }
+    return null;
+  };
+  var parseSampleRate = function parseSampleRate(packet) {
+    var i = 0;
+    while (i + 5 < packet.length) {
+      if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {
+        // If a valid header was not found,  jump one forward and attempt to
+        // find a valid ADTS header starting at the next byte
+        i++;
+        continue;
+      }
+      return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];
+    }
+    return null;
+  };
+  var parseAacTimestamp = function parseAacTimestamp(packet) {
+    var frameStart, frameSize, frame, frameHeader;
+
+    // find the start of the first frame and the end of the tag
+    frameStart = 10;
+    if (packet[5] & 0x40) {
+      // advance the frame start past the extended header
+      frameStart += 4; // header size field
+      frameStart += parseSyncSafeInteger(packet.subarray(10, 14));
+    }
+
+    // parse one or more ID3 frames
+    // http://id3.org/id3v2.3.0#ID3v2_frame_overview
+    do {
+      // determine the number of bytes in this frame
+      frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));
+      if (frameSize < 1) {
+        return null;
+      }
+      frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);
+      if (frameHeader === 'PRIV') {
+        frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);
+        for (var i = 0; i < frame.byteLength; i++) {
+          if (frame[i] === 0) {
+            var owner = parseIso88591(frame, 0, i);
+            if (owner === 'com.apple.streaming.transportStreamTimestamp') {
+              var d = frame.subarray(i + 1);
+              var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;
+              size *= 4;
+              size += d[7] & 0x03;
+              return size;
+            }
+            break;
+          }
+        }
+      }
+      frameStart += 10; // advance past the frame header
+      frameStart += frameSize; // advance past the frame body
+    } while (frameStart < packet.byteLength);
+    return null;
+  };
+  var utils = {
+    isLikelyAacData: isLikelyAacData$1,
+    parseId3TagSize: parseId3TagSize,
+    parseAdtsSize: parseAdtsSize,
+    parseType: parseType,
+    parseSampleRate: parseSampleRate,
+    parseAacTimestamp: parseAacTimestamp
+  };
+
+  // Constants
+  var _AacStream;
+
+  /**
+   * Splits an incoming stream of binary data into ADTS and ID3 Frames.
+   */
+
+  _AacStream = function AacStream() {
+    var everything = new Uint8Array(),
+      timeStamp = 0;
+    _AacStream.prototype.init.call(this);
+    this.setTimestamp = function (timestamp) {
+      timeStamp = timestamp;
+    };
+    this.push = function (bytes) {
+      var frameSize = 0,
+        byteIndex = 0,
+        bytesLeft,
+        chunk,
+        packet,
+        tempLength;
+
+      // If there are bytes remaining from the last segment, prepend them to the
+      // bytes that were pushed in
+      if (everything.length) {
+        tempLength = everything.length;
+        everything = new Uint8Array(bytes.byteLength + tempLength);
+        everything.set(everything.subarray(0, tempLength));
+        everything.set(bytes, tempLength);
+      } else {
+        everything = bytes;
+      }
+      while (everything.length - byteIndex >= 3) {
+        if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {
+          // Exit early because we don't have enough to parse
+          // the ID3 tag header
+          if (everything.length - byteIndex < 10) {
+            break;
+          }
+
+          // check framesize
+          frameSize = utils.parseId3TagSize(everything, byteIndex);
+
+          // Exit early if we don't have enough in the buffer
+          // to emit a full packet
+          // Add to byteIndex to support multiple ID3 tags in sequence
+          if (byteIndex + frameSize > everything.length) {
+            break;
+          }
+          chunk = {
+            type: 'timed-metadata',
+            data: everything.subarray(byteIndex, byteIndex + frameSize)
+          };
+          this.trigger('data', chunk);
+          byteIndex += frameSize;
+          continue;
+        } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {
+          // Exit early because we don't have enough to parse
+          // the ADTS frame header
+          if (everything.length - byteIndex < 7) {
+            break;
+          }
+          frameSize = utils.parseAdtsSize(everything, byteIndex);
+
+          // Exit early if we don't have enough in the buffer
+          // to emit a full packet
+          if (byteIndex + frameSize > everything.length) {
+            break;
+          }
+          packet = {
+            type: 'audio',
+            data: everything.subarray(byteIndex, byteIndex + frameSize),
+            pts: timeStamp,
+            dts: timeStamp
+          };
+          this.trigger('data', packet);
+          byteIndex += frameSize;
+          continue;
+        }
+        byteIndex++;
+      }
+      bytesLeft = everything.length - byteIndex;
+      if (bytesLeft > 0) {
+        everything = everything.subarray(byteIndex);
+      } else {
+        everything = new Uint8Array();
+      }
+    };
+    this.reset = function () {
+      everything = new Uint8Array();
+      this.trigger('reset');
+    };
+    this.endTimeline = function () {
+      everything = new Uint8Array();
+      this.trigger('endedtimeline');
+    };
+  };
+  _AacStream.prototype = new stream();
+  var aac = _AacStream;
+
+  // constants
+  var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];
+  var audioProperties = AUDIO_PROPERTIES;
+
+  var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];
+  var videoProperties = VIDEO_PROPERTIES;
+
+  var H264Stream = h264.H264Stream;
+  var isLikelyAacData = utils.isLikelyAacData;
+  var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;
+
+  // object types
+  var _VideoSegmentStream, _AudioSegmentStream, _Transmuxer, _CoalesceStream;
+  var retriggerForStream = function retriggerForStream(key, event) {
+    event.stream = key;
+    this.trigger('log', event);
+  };
+  var addPipelineLogRetriggers = function addPipelineLogRetriggers(transmuxer, pipeline) {
+    var keys = Object.keys(pipeline);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+
+      // skip non-stream keys and headOfPipeline
+      // which is just a duplicate
+      if (key === 'headOfPipeline' || !pipeline[key].on) {
+        continue;
+      }
+      pipeline[key].on('log', retriggerForStream.bind(transmuxer, key));
+    }
+  };
+
+  /**
+   * Compare two arrays (even typed) for same-ness
+   */
+  var arrayEquals = function arrayEquals(a, b) {
+    var i;
+    if (a.length !== b.length) {
+      return false;
+    }
+
+    // compare the value of each element in the array
+    for (i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {
+    var ptsOffsetFromDts = startPts - startDts,
+      decodeDuration = endDts - startDts,
+      presentationDuration = endPts - startPts;
+
+    // The PTS and DTS values are based on the actual stream times from the segment,
+    // however, the player time values will reflect a start from the baseMediaDecodeTime.
+    // In order to provide relevant values for the player times, base timing info on the
+    // baseMediaDecodeTime and the DTS and PTS durations of the segment.
+    return {
+      start: {
+        dts: baseMediaDecodeTime,
+        pts: baseMediaDecodeTime + ptsOffsetFromDts
+      },
+      end: {
+        dts: baseMediaDecodeTime + decodeDuration,
+        pts: baseMediaDecodeTime + presentationDuration
+      },
+      prependedContentDuration: prependedContentDuration,
+      baseMediaDecodeTime: baseMediaDecodeTime
+    };
+  };
+
+  /**
+   * Constructs a single-track, ISO BMFF media segment from AAC data
+   * events. The output of this stream can be fed to a SourceBuffer
+   * configured with a suitable initialization segment.
+   * @param track {object} track metadata configuration
+   * @param options {object} transmuxer options object
+   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+   *        in the source; false to adjust the first segment to start at 0.
+   */
+  _AudioSegmentStream = function AudioSegmentStream(track, options) {
+    var adtsFrames = [],
+      sequenceNumber,
+      earliestAllowedDts = 0,
+      audioAppendStartTs = 0,
+      videoBaseMediaDecodeTime = Infinity;
+    options = options || {};
+    sequenceNumber = options.firstSequenceNumber || 0;
+    _AudioSegmentStream.prototype.init.call(this);
+    this.push = function (data) {
+      trackDecodeInfo.collectDtsInfo(track, data);
+      if (track) {
+        audioProperties.forEach(function (prop) {
+          track[prop] = data[prop];
+        });
+      }
+
+      // buffer audio data until end() is called
+      adtsFrames.push(data);
+    };
+    this.setEarliestDts = function (earliestDts) {
+      earliestAllowedDts = earliestDts;
+    };
+    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+      videoBaseMediaDecodeTime = baseMediaDecodeTime;
+    };
+    this.setAudioAppendStart = function (timestamp) {
+      audioAppendStartTs = timestamp;
+    };
+    this.flush = function () {
+      var frames, moof, mdat, boxes, frameDuration, segmentDuration, videoClockCyclesOfSilencePrefixed;
+
+      // return early if no audio data has been observed
+      if (adtsFrames.length === 0) {
+        this.trigger('done', 'AudioSegmentStream');
+        return;
+      }
+      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);
+      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+
+      // amount of audio filled but the value is in video clock rather than audio clock
+      videoClockCyclesOfSilencePrefixed = audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime);
+
+      // we have to build the index from byte locations to
+      // samples (that is, adts frames) in the audio data
+      track.samples = audioFrameUtils.generateSampleTable(frames);
+
+      // concatenate the audio data to constuct the mdat
+      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));
+      adtsFrames = [];
+      moof = mp4Generator.moof(sequenceNumber, [track]);
+      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+      // bump the sequence number for next time
+      sequenceNumber++;
+      boxes.set(moof);
+      boxes.set(mdat, moof.byteLength);
+      trackDecodeInfo.clearDtsInfo(track);
+      frameDuration = Math.ceil(ONE_SECOND_IN_TS * 1024 / track.samplerate);
+
+      // TODO this check was added to maintain backwards compatibility (particularly with
+      // tests) on adding the timingInfo event. However, it seems unlikely that there's a
+      // valid use-case where an init segment/data should be triggered without associated
+      // frames. Leaving for now, but should be looked into.
+      if (frames.length) {
+        segmentDuration = frames.length * frameDuration;
+        this.trigger('segmentTimingInfo', generateSegmentTimingInfo(
+        // The audio track's baseMediaDecodeTime is in audio clock cycles, but the
+        // frame info is in video clock cycles. Convert to match expectation of
+        // listeners (that all timestamps will be based on video clock cycles).
+        clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate),
+        // frame times are already in video clock, as is segment duration
+        frames[0].dts, frames[0].pts, frames[0].dts + segmentDuration, frames[0].pts + segmentDuration, videoClockCyclesOfSilencePrefixed || 0));
+        this.trigger('timingInfo', {
+          start: frames[0].pts,
+          end: frames[0].pts + segmentDuration
+        });
+      }
+      this.trigger('data', {
+        track: track,
+        boxes: boxes
+      });
+      this.trigger('done', 'AudioSegmentStream');
+    };
+    this.reset = function () {
+      trackDecodeInfo.clearDtsInfo(track);
+      adtsFrames = [];
+      this.trigger('reset');
+    };
+  };
+  _AudioSegmentStream.prototype = new stream();
+
+  /**
+   * Constructs a single-track, ISO BMFF media segment from H264 data
+   * events. The output of this stream can be fed to a SourceBuffer
+   * configured with a suitable initialization segment.
+   * @param track {object} track metadata configuration
+   * @param options {object} transmuxer options object
+   * @param options.alignGopsAtEnd {boolean} If true, start from the end of the
+   *        gopsToAlignWith list when attempting to align gop pts
+   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+   *        in the source; false to adjust the first segment to start at 0.
+   */
+  _VideoSegmentStream = function VideoSegmentStream(track, options) {
+    var sequenceNumber,
+      nalUnits = [],
+      gopsToAlignWith = [],
+      config,
+      pps;
+    options = options || {};
+    sequenceNumber = options.firstSequenceNumber || 0;
+    _VideoSegmentStream.prototype.init.call(this);
+    delete track.minPTS;
+    this.gopCache_ = [];
+
+    /**
+      * Constructs a ISO BMFF segment given H264 nalUnits
+      * @param {Object} nalUnit A data event representing a nalUnit
+      * @param {String} nalUnit.nalUnitType
+      * @param {Object} nalUnit.config Properties for a mp4 track
+      * @param {Uint8Array} nalUnit.data The nalUnit bytes
+      * @see lib/codecs/h264.js
+     **/
+    this.push = function (nalUnit) {
+      trackDecodeInfo.collectDtsInfo(track, nalUnit);
+
+      // record the track config
+      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {
+        config = nalUnit.config;
+        track.sps = [nalUnit.data];
+        videoProperties.forEach(function (prop) {
+          track[prop] = config[prop];
+        }, this);
+      }
+      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {
+        pps = nalUnit.data;
+        track.pps = [nalUnit.data];
+      }
+
+      // buffer video until flush() is called
+      nalUnits.push(nalUnit);
+    };
+
+    /**
+      * Pass constructed ISO BMFF track and boxes on to the
+      * next stream in the pipeline
+     **/
+    this.flush = function () {
+      var frames,
+        gopForFusion,
+        gops,
+        moof,
+        mdat,
+        boxes,
+        prependedContentDuration = 0,
+        firstGop,
+        lastGop;
+
+      // Throw away nalUnits at the start of the byte stream until
+      // we find the first AUD
+      while (nalUnits.length) {
+        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
+          break;
+        }
+        nalUnits.shift();
+      }
+
+      // Return early if no video data has been observed
+      if (nalUnits.length === 0) {
+        this.resetStream_();
+        this.trigger('done', 'VideoSegmentStream');
+        return;
+      }
+
+      // Organize the raw nal-units into arrays that represent
+      // higher-level constructs such as frames and gops
+      // (group-of-pictures)
+      frames = frameUtils.groupNalsIntoFrames(nalUnits);
+      gops = frameUtils.groupFramesIntoGops(frames);
+
+      // If the first frame of this fragment is not a keyframe we have
+      // a problem since MSE (on Chrome) requires a leading keyframe.
+      //
+      // We have two approaches to repairing this situation:
+      // 1) GOP-FUSION:
+      //    This is where we keep track of the GOPS (group-of-pictures)
+      //    from previous fragments and attempt to find one that we can
+      //    prepend to the current fragment in order to create a valid
+      //    fragment.
+      // 2) KEYFRAME-PULLING:
+      //    Here we search for the first keyframe in the fragment and
+      //    throw away all the frames between the start of the fragment
+      //    and that keyframe. We then extend the duration and pull the
+      //    PTS of the keyframe forward so that it covers the time range
+      //    of the frames that were disposed of.
+      //
+      // #1 is far prefereable over #2 which can cause "stuttering" but
+      // requires more things to be just right.
+      if (!gops[0][0].keyFrame) {
+        // Search for a gop for fusion from our gopCache
+        gopForFusion = this.getGopForFusion_(nalUnits[0], track);
+        if (gopForFusion) {
+          // in order to provide more accurate timing information about the segment, save
+          // the number of seconds prepended to the original segment due to GOP fusion
+          prependedContentDuration = gopForFusion.duration;
+          gops.unshift(gopForFusion);
+          // Adjust Gops' metadata to account for the inclusion of the
+          // new gop at the beginning
+          gops.byteLength += gopForFusion.byteLength;
+          gops.nalCount += gopForFusion.nalCount;
+          gops.pts = gopForFusion.pts;
+          gops.dts = gopForFusion.dts;
+          gops.duration += gopForFusion.duration;
+        } else {
+          // If we didn't find a candidate gop fall back to keyframe-pulling
+          gops = frameUtils.extendFirstKeyFrame(gops);
+        }
+      }
+
+      // Trim gops to align with gopsToAlignWith
+      if (gopsToAlignWith.length) {
+        var alignedGops;
+        if (options.alignGopsAtEnd) {
+          alignedGops = this.alignGopsAtEnd_(gops);
+        } else {
+          alignedGops = this.alignGopsAtStart_(gops);
+        }
+        if (!alignedGops) {
+          // save all the nals in the last GOP into the gop cache
+          this.gopCache_.unshift({
+            gop: gops.pop(),
+            pps: track.pps,
+            sps: track.sps
+          });
+
+          // Keep a maximum of 6 GOPs in the cache
+          this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+          // Clear nalUnits
+          nalUnits = [];
+
+          // return early no gops can be aligned with desired gopsToAlignWith
+          this.resetStream_();
+          this.trigger('done', 'VideoSegmentStream');
+          return;
+        }
+
+        // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct
+        // when recalculated before sending off to CoalesceStream
+        trackDecodeInfo.clearDtsInfo(track);
+        gops = alignedGops;
+      }
+      trackDecodeInfo.collectDtsInfo(track, gops);
+
+      // First, we have to build the index from byte locations to
+      // samples (that is, frames) in the video data
+      track.samples = frameUtils.generateSampleTable(gops);
+
+      // Concatenate the video data and construct the mdat
+      mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));
+      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);
+      this.trigger('processedGopsInfo', gops.map(function (gop) {
+        return {
+          pts: gop.pts,
+          dts: gop.dts,
+          byteLength: gop.byteLength
+        };
+      }));
+      firstGop = gops[0];
+      lastGop = gops[gops.length - 1];
+      this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));
+      this.trigger('timingInfo', {
+        start: gops[0].pts,
+        end: gops[gops.length - 1].pts + gops[gops.length - 1].duration
+      });
+
+      // save all the nals in the last GOP into the gop cache
+      this.gopCache_.unshift({
+        gop: gops.pop(),
+        pps: track.pps,
+        sps: track.sps
+      });
+
+      // Keep a maximum of 6 GOPs in the cache
+      this.gopCache_.length = Math.min(6, this.gopCache_.length);
+
+      // Clear nalUnits
+      nalUnits = [];
+      this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);
+      this.trigger('timelineStartInfo', track.timelineStartInfo);
+      moof = mp4Generator.moof(sequenceNumber, [track]);
+
+      // it would be great to allocate this array up front instead of
+      // throwing away hundreds of media segment fragments
+      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
+
+      // Bump the sequence number for next time
+      sequenceNumber++;
+      boxes.set(moof);
+      boxes.set(mdat, moof.byteLength);
+      this.trigger('data', {
+        track: track,
+        boxes: boxes
+      });
+      this.resetStream_();
+
+      // Continue with the flush process now
+      this.trigger('done', 'VideoSegmentStream');
+    };
+    this.reset = function () {
+      this.resetStream_();
+      nalUnits = [];
+      this.gopCache_.length = 0;
+      gopsToAlignWith.length = 0;
+      this.trigger('reset');
+    };
+    this.resetStream_ = function () {
+      trackDecodeInfo.clearDtsInfo(track);
+
+      // reset config and pps because they may differ across segments
+      // for instance, when we are rendition switching
+      config = undefined;
+      pps = undefined;
+    };
+
+    // Search for a candidate Gop for gop-fusion from the gop cache and
+    // return it or return null if no good candidate was found
+    this.getGopForFusion_ = function (nalUnit) {
+      var halfSecond = 45000,
+        // Half-a-second in a 90khz clock
+        allowableOverlap = 10000,
+        // About 3 frames @ 30fps
+        nearestDistance = Infinity,
+        dtsDistance,
+        nearestGopObj,
+        currentGop,
+        currentGopObj,
+        i;
+
+      // Search for the GOP nearest to the beginning of this nal unit
+      for (i = 0; i < this.gopCache_.length; i++) {
+        currentGopObj = this.gopCache_[i];
+        currentGop = currentGopObj.gop;
+
+        // Reject Gops with different SPS or PPS
+        if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {
+          continue;
+        }
+
+        // Reject Gops that would require a negative baseMediaDecodeTime
+        if (currentGop.dts < track.timelineStartInfo.dts) {
+          continue;
+        }
+
+        // The distance between the end of the gop and the start of the nalUnit
+        dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration;
+
+        // Only consider GOPS that start before the nal unit and end within
+        // a half-second of the nal unit
+        if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {
+          // Always use the closest GOP we found if there is more than
+          // one candidate
+          if (!nearestGopObj || nearestDistance > dtsDistance) {
+            nearestGopObj = currentGopObj;
+            nearestDistance = dtsDistance;
+          }
+        }
+      }
+      if (nearestGopObj) {
+        return nearestGopObj.gop;
+      }
+      return null;
+    };
+
+    // trim gop list to the first gop found that has a matching pts with a gop in the list
+    // of gopsToAlignWith starting from the START of the list
+    this.alignGopsAtStart_ = function (gops) {
+      var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;
+      byteLength = gops.byteLength;
+      nalCount = gops.nalCount;
+      duration = gops.duration;
+      alignIndex = gopIndex = 0;
+      while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {
+        align = gopsToAlignWith[alignIndex];
+        gop = gops[gopIndex];
+        if (align.pts === gop.pts) {
+          break;
+        }
+        if (gop.pts > align.pts) {
+          // this current gop starts after the current gop we want to align on, so increment
+          // align index
+          alignIndex++;
+          continue;
+        }
+
+        // current gop starts before the current gop we want to align on. so increment gop
+        // index
+        gopIndex++;
+        byteLength -= gop.byteLength;
+        nalCount -= gop.nalCount;
+        duration -= gop.duration;
+      }
+      if (gopIndex === 0) {
+        // no gops to trim
+        return gops;
+      }
+      if (gopIndex === gops.length) {
+        // all gops trimmed, skip appending all gops
+        return null;
+      }
+      alignedGops = gops.slice(gopIndex);
+      alignedGops.byteLength = byteLength;
+      alignedGops.duration = duration;
+      alignedGops.nalCount = nalCount;
+      alignedGops.pts = alignedGops[0].pts;
+      alignedGops.dts = alignedGops[0].dts;
+      return alignedGops;
+    };
+
+    // trim gop list to the first gop found that has a matching pts with a gop in the list
+    // of gopsToAlignWith starting from the END of the list
+    this.alignGopsAtEnd_ = function (gops) {
+      var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;
+      alignIndex = gopsToAlignWith.length - 1;
+      gopIndex = gops.length - 1;
+      alignEndIndex = null;
+      matchFound = false;
+      while (alignIndex >= 0 && gopIndex >= 0) {
+        align = gopsToAlignWith[alignIndex];
+        gop = gops[gopIndex];
+        if (align.pts === gop.pts) {
+          matchFound = true;
+          break;
+        }
+        if (align.pts > gop.pts) {
+          alignIndex--;
+          continue;
+        }
+        if (alignIndex === gopsToAlignWith.length - 1) {
+          // gop.pts is greater than the last alignment candidate. If no match is found
+          // by the end of this loop, we still want to append gops that come after this
+          // point
+          alignEndIndex = gopIndex;
+        }
+        gopIndex--;
+      }
+      if (!matchFound && alignEndIndex === null) {
+        return null;
+      }
+      var trimIndex;
+      if (matchFound) {
+        trimIndex = gopIndex;
+      } else {
+        trimIndex = alignEndIndex;
+      }
+      if (trimIndex === 0) {
+        return gops;
+      }
+      var alignedGops = gops.slice(trimIndex);
+      var metadata = alignedGops.reduce(function (total, gop) {
+        total.byteLength += gop.byteLength;
+        total.duration += gop.duration;
+        total.nalCount += gop.nalCount;
+        return total;
+      }, {
+        byteLength: 0,
+        duration: 0,
+        nalCount: 0
+      });
+      alignedGops.byteLength = metadata.byteLength;
+      alignedGops.duration = metadata.duration;
+      alignedGops.nalCount = metadata.nalCount;
+      alignedGops.pts = alignedGops[0].pts;
+      alignedGops.dts = alignedGops[0].dts;
+      return alignedGops;
+    };
+    this.alignGopsWith = function (newGopsToAlignWith) {
+      gopsToAlignWith = newGopsToAlignWith;
+    };
+  };
+  _VideoSegmentStream.prototype = new stream();
+
+  /**
+   * A Stream that can combine multiple streams (ie. audio & video)
+   * into a single output segment for MSE. Also supports audio-only
+   * and video-only streams.
+   * @param options {object} transmuxer options object
+   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps
+   *        in the source; false to adjust the first segment to start at media timeline start.
+   */
+  _CoalesceStream = function CoalesceStream(options, metadataStream) {
+    // Number of Tracks per output segment
+    // If greater than 1, we combine multiple
+    // tracks into a single segment
+    this.numberOfTracks = 0;
+    this.metadataStream = metadataStream;
+    options = options || {};
+    if (typeof options.remux !== 'undefined') {
+      this.remuxTracks = !!options.remux;
+    } else {
+      this.remuxTracks = true;
+    }
+    if (typeof options.keepOriginalTimestamps === 'boolean') {
+      this.keepOriginalTimestamps = options.keepOriginalTimestamps;
+    } else {
+      this.keepOriginalTimestamps = false;
+    }
+    this.pendingTracks = [];
+    this.videoTrack = null;
+    this.pendingBoxes = [];
+    this.pendingCaptions = [];
+    this.pendingMetadata = [];
+    this.pendingBytes = 0;
+    this.emittedTracks = 0;
+    _CoalesceStream.prototype.init.call(this);
+
+    // Take output from multiple
+    this.push = function (output) {
+      // buffer incoming captions until the associated video segment
+      // finishes
+      if (output.text) {
+        return this.pendingCaptions.push(output);
+      }
+      // buffer incoming id3 tags until the final flush
+      if (output.frames) {
+        return this.pendingMetadata.push(output);
+      }
+
+      // Add this track to the list of pending tracks and store
+      // important information required for the construction of
+      // the final segment
+      this.pendingTracks.push(output.track);
+      this.pendingBytes += output.boxes.byteLength;
+
+      // TODO: is there an issue for this against chrome?
+      // We unshift audio and push video because
+      // as of Chrome 75 when switching from
+      // one init segment to another if the video
+      // mdat does not appear after the audio mdat
+      // only audio will play for the duration of our transmux.
+      if (output.track.type === 'video') {
+        this.videoTrack = output.track;
+        this.pendingBoxes.push(output.boxes);
+      }
+      if (output.track.type === 'audio') {
+        this.audioTrack = output.track;
+        this.pendingBoxes.unshift(output.boxes);
+      }
+    };
+  };
+  _CoalesceStream.prototype = new stream();
+  _CoalesceStream.prototype.flush = function (flushSource) {
+    var offset = 0,
+      event = {
+        captions: [],
+        captionStreams: {},
+        metadata: [],
+        info: {}
+      },
+      caption,
+      id3,
+      initSegment,
+      timelineStartPts = 0,
+      i;
+    if (this.pendingTracks.length < this.numberOfTracks) {
+      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {
+        // Return because we haven't received a flush from a data-generating
+        // portion of the segment (meaning that we have only recieved meta-data
+        // or captions.)
+        return;
+      } else if (this.remuxTracks) {
+        // Return until we have enough tracks from the pipeline to remux (if we
+        // are remuxing audio and video into a single MP4)
+        return;
+      } else if (this.pendingTracks.length === 0) {
+        // In the case where we receive a flush without any data having been
+        // received we consider it an emitted track for the purposes of coalescing
+        // `done` events.
+        // We do this for the case where there is an audio and video track in the
+        // segment but no audio data. (seen in several playlists with alternate
+        // audio tracks and no audio present in the main TS segments.)
+        this.emittedTracks++;
+        if (this.emittedTracks >= this.numberOfTracks) {
+          this.trigger('done');
+          this.emittedTracks = 0;
+        }
+        return;
+      }
+    }
+    if (this.videoTrack) {
+      timelineStartPts = this.videoTrack.timelineStartInfo.pts;
+      videoProperties.forEach(function (prop) {
+        event.info[prop] = this.videoTrack[prop];
+      }, this);
+    } else if (this.audioTrack) {
+      timelineStartPts = this.audioTrack.timelineStartInfo.pts;
+      audioProperties.forEach(function (prop) {
+        event.info[prop] = this.audioTrack[prop];
+      }, this);
+    }
+    if (this.videoTrack || this.audioTrack) {
+      if (this.pendingTracks.length === 1) {
+        event.type = this.pendingTracks[0].type;
+      } else {
+        event.type = 'combined';
+      }
+      this.emittedTracks += this.pendingTracks.length;
+      initSegment = mp4Generator.initSegment(this.pendingTracks);
+
+      // Create a new typed array to hold the init segment
+      event.initSegment = new Uint8Array(initSegment.byteLength);
+
+      // Create an init segment containing a moov
+      // and track definitions
+      event.initSegment.set(initSegment);
+
+      // Create a new typed array to hold the moof+mdats
+      event.data = new Uint8Array(this.pendingBytes);
+
+      // Append each moof+mdat (one per track) together
+      for (i = 0; i < this.pendingBoxes.length; i++) {
+        event.data.set(this.pendingBoxes[i], offset);
+        offset += this.pendingBoxes[i].byteLength;
+      }
+
+      // Translate caption PTS times into second offsets to match the
+      // video timeline for the segment, and add track info
+      for (i = 0; i < this.pendingCaptions.length; i++) {
+        caption = this.pendingCaptions[i];
+        caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);
+        caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);
+        event.captionStreams[caption.stream] = true;
+        event.captions.push(caption);
+      }
+
+      // Translate ID3 frame PTS times into second offsets to match the
+      // video timeline for the segment
+      for (i = 0; i < this.pendingMetadata.length; i++) {
+        id3 = this.pendingMetadata[i];
+        id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);
+        event.metadata.push(id3);
+      }
+
+      // We add this to every single emitted segment even though we only need
+      // it for the first
+      event.metadata.dispatchType = this.metadataStream.dispatchType;
+
+      // Reset stream state
+      this.pendingTracks.length = 0;
+      this.videoTrack = null;
+      this.pendingBoxes.length = 0;
+      this.pendingCaptions.length = 0;
+      this.pendingBytes = 0;
+      this.pendingMetadata.length = 0;
+
+      // Emit the built segment
+      // We include captions and ID3 tags for backwards compatibility,
+      // ideally we should send only video and audio in the data event
+      this.trigger('data', event);
+      // Emit each caption to the outside world
+      // Ideally, this would happen immediately on parsing captions,
+      // but we need to ensure that video data is sent back first
+      // so that caption timing can be adjusted to match video timing
+      for (i = 0; i < event.captions.length; i++) {
+        caption = event.captions[i];
+        this.trigger('caption', caption);
+      }
+      // Emit each id3 tag to the outside world
+      // Ideally, this would happen immediately on parsing the tag,
+      // but we need to ensure that video data is sent back first
+      // so that ID3 frame timing can be adjusted to match video timing
+      for (i = 0; i < event.metadata.length; i++) {
+        id3 = event.metadata[i];
+        this.trigger('id3Frame', id3);
+      }
+    }
+
+    // Only emit `done` if all tracks have been flushed and emitted
+    if (this.emittedTracks >= this.numberOfTracks) {
+      this.trigger('done');
+      this.emittedTracks = 0;
+    }
+  };
+  _CoalesceStream.prototype.setRemux = function (val) {
+    this.remuxTracks = val;
+  };
+  /**
+   * A Stream that expects MP2T binary data as input and produces
+   * corresponding media segments, suitable for use with Media Source
+   * Extension (MSE) implementations that support the ISO BMFF byte
+   * stream format, like Chrome.
+   */
+  _Transmuxer = function Transmuxer(options) {
+    var self = this,
+      hasFlushed = true,
+      videoTrack,
+      audioTrack;
+    _Transmuxer.prototype.init.call(this);
+    options = options || {};
+    var duration = this.duration = options.duration || 0xffffffff;
+    this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;
+    this.transmuxPipeline_ = {};
+    this.setupAacPipeline = function () {
+      var pipeline = {};
+      this.transmuxPipeline_ = pipeline;
+      pipeline.type = 'aac';
+      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+      // set up the parsing pipeline
+      pipeline.aacStream = new aac();
+      pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');
+      pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');
+      pipeline.adtsStream = new adts();
+      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+      pipeline.headOfPipeline = pipeline.aacStream;
+      pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);
+      pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+      pipeline.metadataStream.on('timestamp', function (frame) {
+        pipeline.aacStream.setTimestamp(frame.timeStamp);
+      });
+      pipeline.aacStream.on('data', function (data) {
+        if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {
+          return;
+        }
+        audioTrack = audioTrack || {
+          timelineStartInfo: {
+            baseMediaDecodeTime: self.baseMediaDecodeTime
+          },
+          codec: 'adts',
+          type: 'audio'
+        };
+        // hook up the audio segment stream to the first track with aac data
+        pipeline.coalesceStream.numberOfTracks++;
+        pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+        pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+        pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+
+        // Set up the final part of the audio pipeline
+        pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+
+        // emit pmt info
+        self.trigger('trackinfo', {
+          hasAudio: !!audioTrack,
+          hasVideo: !!videoTrack
+        });
+      });
+
+      // Re-emit any data coming from the coalesce stream to the outside world
+      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+      // Let the consumer know we have finished flushing the entire pipeline
+      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+      addPipelineLogRetriggers(this, pipeline);
+    };
+    this.setupTsPipeline = function () {
+      var pipeline = {};
+      this.transmuxPipeline_ = pipeline;
+      pipeline.type = 'ts';
+      pipeline.duration = duration * 9e4;
+      pipeline.metadataStream = new m2ts_1.MetadataStream();
+
+      // set up the parsing pipeline
+      pipeline.packetStream = new m2ts_1.TransportPacketStream();
+      pipeline.parseStream = new m2ts_1.TransportParseStream();
+      pipeline.elementaryStream = new m2ts_1.ElementaryStream();
+      pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();
+      pipeline.adtsStream = new adts();
+      pipeline.h264Stream = new H264Stream();
+      pipeline.captionStream = new m2ts_1.CaptionStream(options);
+      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);
+      pipeline.headOfPipeline = pipeline.packetStream;
+
+      // disassemble MPEG2-TS packets into elementary streams
+      pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream);
+
+      // !!THIS ORDER IS IMPORTANT!!
+      // demux the streams
+      pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);
+      pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);
+      pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);
+
+      // Hook up CEA-608/708 caption stream
+      pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);
+      pipeline.elementaryStream.on('data', function (data) {
+        var i;
+        if (data.type === 'metadata') {
+          i = data.tracks.length;
+
+          // scan the tracks listed in the metadata
+          while (i--) {
+            if (!videoTrack && data.tracks[i].type === 'video') {
+              videoTrack = data.tracks[i];
+              videoTrack.duration = pipeline.duration / 2;
+              videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+            } else if (!audioTrack && data.tracks[i].type === 'audio') {
+              audioTrack = data.tracks[i];
+              audioTrack.duration = pipeline.duration / 2;
+              audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
+            }
+          }
+
+          // hook up the video segment stream to the first track with h264 data
+          if (videoTrack && !pipeline.videoSegmentStream) {
+            pipeline.coalesceStream.numberOfTracks++;
+            pipeline.videoSegmentStream = new _VideoSegmentStream(videoTrack, options);
+            pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));
+            pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {
+              // When video emits timelineStartInfo data after a flush, we forward that
+              // info to the AudioSegmentStream, if it exists, because video timeline
+              // data takes precedence.  Do not do this if keepOriginalTimestamps is set,
+              // because this is a particularly subtle form of timestamp alteration.
+              if (audioTrack && !options.keepOriginalTimestamps) {
+                audioTrack.timelineStartInfo = timelineStartInfo;
+                // On the first segment we trim AAC frames that exist before the
+                // very earliest DTS we have seen in video because Chrome will
+                // interpret any video track with a baseMediaDecodeTime that is
+                // non-zero as a gap.
+                pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);
+              }
+            });
+            pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));
+            pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));
+            pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {
+              if (audioTrack) {
+                pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);
+              }
+            });
+            pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo'));
+
+            // Set up the final part of the video pipeline
+            pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);
+          }
+          if (audioTrack && !pipeline.audioSegmentStream) {
+            // hook up the audio segment stream to the first track with aac data
+            pipeline.coalesceStream.numberOfTracks++;
+            pipeline.audioSegmentStream = new _AudioSegmentStream(audioTrack, options);
+            pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));
+            pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));
+            pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo'));
+
+            // Set up the final part of the audio pipeline
+            pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);
+          }
+
+          // emit pmt info
+          self.trigger('trackinfo', {
+            hasAudio: !!audioTrack,
+            hasVideo: !!videoTrack
+          });
+        }
+      });
+
+      // Re-emit any data coming from the coalesce stream to the outside world
+      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
+      pipeline.coalesceStream.on('id3Frame', function (id3Frame) {
+        id3Frame.dispatchType = pipeline.metadataStream.dispatchType;
+        self.trigger('id3Frame', id3Frame);
+      });
+      pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption'));
+      // Let the consumer know we have finished flushing the entire pipeline
+      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
+      addPipelineLogRetriggers(this, pipeline);
+    };
+
+    // hook up the segment streams once track metadata is delivered
+    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {
+      var pipeline = this.transmuxPipeline_;
+      if (!options.keepOriginalTimestamps) {
+        this.baseMediaDecodeTime = baseMediaDecodeTime;
+      }
+      if (audioTrack) {
+        audioTrack.timelineStartInfo.dts = undefined;
+        audioTrack.timelineStartInfo.pts = undefined;
+        trackDecodeInfo.clearDtsInfo(audioTrack);
+        if (pipeline.audioTimestampRolloverStream) {
+          pipeline.audioTimestampRolloverStream.discontinuity();
+        }
+      }
+      if (videoTrack) {
+        if (pipeline.videoSegmentStream) {
+          pipeline.videoSegmentStream.gopCache_ = [];
+        }
+        videoTrack.timelineStartInfo.dts = undefined;
+        videoTrack.timelineStartInfo.pts = undefined;
+        trackDecodeInfo.clearDtsInfo(videoTrack);
+        pipeline.captionStream.reset();
+      }
+      if (pipeline.timestampRolloverStream) {
+        pipeline.timestampRolloverStream.discontinuity();
+      }
+    };
+    this.setAudioAppendStart = function (timestamp) {
+      if (audioTrack) {
+        this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);
+      }
+    };
+    this.setRemux = function (val) {
+      var pipeline = this.transmuxPipeline_;
+      options.remux = val;
+      if (pipeline && pipeline.coalesceStream) {
+        pipeline.coalesceStream.setRemux(val);
+      }
+    };
+    this.alignGopsWith = function (gopsToAlignWith) {
+      if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {
+        this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);
+      }
+    };
+    this.getLogTrigger_ = function (key) {
+      var self = this;
+      return function (event) {
+        event.stream = key;
+        self.trigger('log', event);
+      };
+    };
+    // feed incoming data to the front of the parsing pipeline
+    this.push = function (data) {
+      if (hasFlushed) {
+        var isAac = isLikelyAacData(data);
+        if (isAac && this.transmuxPipeline_.type !== 'aac') {
+          this.setupAacPipeline();
+        } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {
+          this.setupTsPipeline();
+        }
+        hasFlushed = false;
+      }
+      this.transmuxPipeline_.headOfPipeline.push(data);
+    };
+
+    // flush any buffered data
+    this.flush = function () {
+      hasFlushed = true;
+      // Start at the top of the pipeline and flush all pending work
+      this.transmuxPipeline_.headOfPipeline.flush();
+    };
+    this.endTimeline = function () {
+      this.transmuxPipeline_.headOfPipeline.endTimeline();
+    };
+    this.reset = function () {
+      if (this.transmuxPipeline_.headOfPipeline) {
+        this.transmuxPipeline_.headOfPipeline.reset();
+      }
+    };
+
+    // Caption data has to be reset when seeking outside buffered range
+    this.resetCaptions = function () {
+      if (this.transmuxPipeline_.captionStream) {
+        this.transmuxPipeline_.captionStream.reset();
+      }
+    };
+  };
+  _Transmuxer.prototype = new stream();
+  var transmuxer = _Transmuxer;
+
+  return transmuxer;
+
+}));
diff --git a/src/util/http.ts b/src/util/http.ts
new file mode 100644
index 0000000..ff1007b
--- /dev/null
+++ b/src/util/http.ts
@@ -0,0 +1,6 @@
+
+export async function fetchFile(url: string) {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    return new Uint8Array(arrayBuffer)
+}
diff --git a/yarn.lock b/yarn.lock
index 15a8832..8047264 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,29 +2,14 @@
 # yarn lockfile v1
 
 
-"@ffmpeg/core@^0.11.0":
-  version "0.11.0"
-  resolved "https://registry.yarnpkg.com/@ffmpeg/core/-/core-0.11.0.tgz#fc24fe5af587f83cd2575d0e45de455d8eed9ba9"
-  integrity sha512-9Tt/+2PMpkGPXUK8n6He9G8Y+qR6qmCPSCw9iEKZxHHOvJ9BE/r0Fccj+YgDZTlyu6rXxc9x6EqCaFBIt7qzjA==
-
-"@ffmpeg/ffmpeg@^0.11.6":
-  version "0.11.6"
-  resolved "https://registry.yarnpkg.com/@ffmpeg/ffmpeg/-/ffmpeg-0.11.6.tgz#9cbe42dfb5132fca74ae5570ebeee2341f8c6e51"
-  integrity sha512-uN8J8KDjADEavPhNva6tYO9Fj0lWs9z82swF3YXnTxWMBoFLGq3LZ6FLlIldRKEzhOBKnkVfA8UnFJuvGvNxcA==
-  dependencies:
-    is-url "^1.2.4"
-    node-fetch "^2.6.1"
-    regenerator-runtime "^0.13.7"
-    resolve-url "^0.2.1"
-
 "@jridgewell/sourcemap-codec@^1.4.13":
   version "1.4.15"
-  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
+  resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz"
   integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
 
 "@rollup/plugin-commonjs@^25.0.0":
   version "25.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-25.0.0.tgz#ef55d12415dfcfb77fd52650dc1448c8aae8ed5c"
+  resolved "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-25.0.0.tgz"
   integrity sha512-hoho2Kay9TZrLu0bnDsTTCaj4Npa+THk9snajP/XDNb9a9mmjTjh52EQM9sKl3HD1LsnihX7js+eA2sd2uKAhw==
   dependencies:
     "@rollup/pluginutils" "^5.0.1"
@@ -36,7 +21,7 @@
 
 "@rollup/plugin-node-resolve@^15.0.2":
   version "15.0.2"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.0.2.tgz#8183a80c2cbf7b471f5ac86b16747997f3b5d185"
+  resolved "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.0.2.tgz"
   integrity sha512-Y35fRGUjC3FaurG722uhUuG8YHOJRJQbI6/CkbRkdPotSpDj9NtIN85z1zrcyDcCQIW4qp5mgG72U+gJ0TAFEg==
   dependencies:
     "@rollup/pluginutils" "^5.0.1"
@@ -48,7 +33,7 @@
 
 "@rollup/plugin-typescript@^11.1.0":
   version "11.1.1"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-typescript/-/plugin-typescript-11.1.1.tgz#258663a7aa6b51390dd39ae6e5502f2c4b2807cb"
+  resolved "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-11.1.1.tgz"
   integrity sha512-Ioir+x5Bejv72Lx2Zbz3/qGg7tvGbxQZALCLoJaGrkNXak/19+vKgKYJYM3i/fJxvsb23I9FuFQ8CUBEfsmBRg==
   dependencies:
     "@rollup/pluginutils" "^5.0.1"
@@ -56,7 +41,7 @@
 
 "@rollup/pluginutils@^5.0.1":
   version "5.0.2"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.0.2.tgz#012b8f53c71e4f6f9cb317e311df1404f56e7a33"
+  resolved "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.0.2.tgz"
   integrity sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -65,59 +50,64 @@
 
 "@types/aes-js@^3.1.1":
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/@types/aes-js/-/aes-js-3.1.1.tgz#34b3978122310c135de4b377270d1d65676fae28"
+  resolved "https://registry.npmjs.org/@types/aes-js/-/aes-js-3.1.1.tgz"
   integrity sha512-SDSGgXT3LRCH6qMWk8OHT1vLSVNuHNvCpKCx2/TYtQMbMGGgxJC9fspwSkQjqzRagrWnCrxuLL3jMNXLXHHvSw==
 
 "@types/estree@*", "@types/estree@^1.0.0":
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.1.tgz#aa22750962f3bf0e79d753d3cc067f010c95f194"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.1.tgz"
   integrity sha512-LG4opVs2ANWZ1TJoKc937iMmNstM/d0ae1vNbnBvBhqCSezgVUOzcLCqbI5elV8Vy6WKwKjaqR+zO9VKirBBCA==
 
+"@types/node@^20.2.5":
+  version "20.2.5"
+  resolved "https://registry.npmjs.org/@types/node/-/node-20.2.5.tgz"
+  integrity sha512-JJulVEQXmiY9Px5axXHeYGLSjhkZEnD+MDPDGbCbIAbMslkKwmygtZFy1X6s/075Yo94sf8GuSlFfPzysQrWZQ==
+
 "@types/resolve@1.20.2":
   version "1.20.2"
-  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.20.2.tgz#97d26e00cd4a0423b4af620abecf3e6f442b7975"
+  resolved "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz"
   integrity sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==
 
 aes-js@^3.1.2:
   version "3.1.2"
-  resolved "https://registry.yarnpkg.com/aes-js/-/aes-js-3.1.2.tgz#db9aabde85d5caabbfc0d4f2a4446960f627146a"
+  resolved "https://registry.npmjs.org/aes-js/-/aes-js-3.1.2.tgz"
   integrity sha512-e5pEa2kBnBOgR4Y/p20pskXI74UEz7de8ZGVo58asOtvSVG5YAbJeELPZxOmt+Bnz3rX753YKhfIn4X4l1PPRQ==
 
 balanced-match@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
+  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 
 brace-expansion@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae"
+  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz"
   integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
   dependencies:
     balanced-match "^1.0.0"
 
 builtin-modules@^3.3.0:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.3.0.tgz#cae62812b89801e9656336e46223e030386be7b6"
+  resolved "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.3.0.tgz"
   integrity sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==
 
 commondir@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
+  resolved "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz"
   integrity sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==
 
 deepmerge@^4.2.2:
   version "4.3.1"
-  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a"
+  resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz"
   integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==
 
 estree-walker@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
+  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz"
   integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
 
 fs.realpath@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
   integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
 
 fsevents@~2.3.2:
@@ -127,12 +117,12 @@ fsevents@~2.3.2:
 
 function-bind@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz"
   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 
 glob@^8.0.3:
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-8.1.0.tgz#d388f656593ef708ee3e34640fdfb99a9fd1c33e"
+  resolved "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz"
   integrity sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==
   dependencies:
     fs.realpath "^1.0.0"
@@ -143,14 +133,14 @@ glob@^8.0.3:
 
 has@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
+  resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz"
   integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
   dependencies:
     function-bind "^1.1.1"
 
 inflight@^1.0.4:
   version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
   integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
   dependencies:
     once "^1.3.0"
@@ -158,91 +148,69 @@ inflight@^1.0.4:
 
 inherits@2:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
 is-builtin-module@^3.2.1:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-3.2.1.tgz#f03271717d8654cfcaf07ab0463faa3571581169"
+  resolved "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-3.2.1.tgz"
   integrity sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==
   dependencies:
     builtin-modules "^3.3.0"
 
 is-core-module@^2.11.0:
   version "2.12.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.12.0.tgz#36ad62f6f73c8253fd6472517a12483cf03e7ec4"
+  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.12.0.tgz"
   integrity sha512-RECHCBCd/viahWmwj6enj19sKbHfJrddi/6cBDsNTKbNq0f7VeaUkBo60BqzvPqo/W54ChS62Z5qyun7cfOMqQ==
   dependencies:
     has "^1.0.3"
 
 is-module@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
+  resolved "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz"
   integrity sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==
 
 is-reference@1.2.1:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/is-reference/-/is-reference-1.2.1.tgz#8b2dac0b371f4bc994fdeaba9eb542d03002d0b7"
+  resolved "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz"
   integrity sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==
   dependencies:
     "@types/estree" "*"
 
-is-url@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/is-url/-/is-url-1.2.4.tgz#04a4df46d28c4cff3d73d01ff06abeb318a1aa52"
-  integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==
-
 magic-string@^0.27.0:
   version "0.27.0"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.27.0.tgz#e4a3413b4bab6d98d2becffd48b4a257effdbbf3"
+  resolved "https://registry.npmjs.org/magic-string/-/magic-string-0.27.0.tgz"
   integrity sha512-8UnnX2PeRAPZuN12svgR9j7M1uWMovg/CEnIwIG0LFkXSJJe4PdfUGiTGl8V9bsBHFUtfVINcSyYxd7q+kx9fA==
   dependencies:
     "@jridgewell/sourcemap-codec" "^1.4.13"
 
 minimatch@^5.0.1:
   version "5.1.6"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.1.6.tgz#1cfcb8cf5522ea69952cd2af95ae09477f122a96"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz"
   integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
   dependencies:
     brace-expansion "^2.0.1"
 
-node-fetch@^2.6.1:
-  version "2.6.11"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.11.tgz#cde7fc71deef3131ef80a738919f999e6edfff25"
-  integrity sha512-4I6pdBY1EthSqDmJkiNk3JIT8cswwR9nfeW/cPdUagJYEQG7R95WRH74wpz7ma8Gh/9dI9FP+OU+0E4FvtA55w==
-  dependencies:
-    whatwg-url "^5.0.0"
-
 once@^1.3.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
   integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
   dependencies:
     wrappy "1"
 
 path-parse@^1.0.7:
   version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
+  resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
 
 picomatch@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
   integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
 
-regenerator-runtime@^0.13.7:
-  version "0.13.11"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz#f6dca3e7ceec20590d07ada785636a90cdca17f9"
-  integrity sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==
-
-resolve-url@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
-  integrity sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg==
-
 resolve@^1.22.1:
   version "1.22.2"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.2.tgz#0ed0943d4e301867955766c9f3e1ae6d01c6845f"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz"
   integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==
   dependencies:
     is-core-module "^2.11.0"
@@ -251,45 +219,27 @@ resolve@^1.22.1:
 
 rollup@^3.21.4:
   version "3.21.7"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.21.7.tgz#022ab47416712c93546f369abfb20da5fb8ed42e"
+  resolved "https://registry.npmjs.org/rollup/-/rollup-3.21.7.tgz"
   integrity sha512-KXPaEuR8FfUoK2uHwNjxTmJ18ApyvD6zJpYv9FOJSqLStmt6xOY84l1IjK2dSolQmoXknrhEFRaPRgOPdqCT5w==
   optionalDependencies:
     fsevents "~2.3.2"
 
 supports-preserve-symlinks-flag@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
+  resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
-tr46@~0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
-  integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==
-
 tslib@^2.0.0:
   version "2.5.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.0.tgz#42bfed86f5787aeb41d031866c8f402429e0fddf"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz"
   integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==
 
 typescript@^4.7.4:
   version "4.9.5"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.9.5.tgz#095979f9bcc0d09da324d58d03ce8f8374cbe65a"
+  resolved "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz"
   integrity sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==
 
-webidl-conversions@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
-  integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==
-
-whatwg-url@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
-  integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==
-  dependencies:
-    tr46 "~0.0.3"
-    webidl-conversions "^3.0.0"
-
 wrappy@1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
+  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==