Multiple audio track support (#681)

* Support for multiple alternate audio tracks

* Separated segment loading logic into a reusable piece of functionality so that we can have more than one segment loader and they can manage the segment fetch behavior unique to each playlist they are loading from

* Introduced the MasterPlaylistController to coordinate the loading of the master playlist and separate the behavior of the player from videojs-contrib-hls.js leaving the latter to be the glue between HLS and the video element's events

* Added the SourceUpdater to manage the asynchronous bahavior of SourceBuffers and MediaSource objects so that we can treat it as a non-blocking work queue

* Added parsing for MediaGroups in master playlists

* Added support for AudioTrackList objects and events

* Add support for every HLS mime type possible (#684)

* Flash live fixes (#682)

-sudo: false
+sudo: required
+dist: trusty
 language: node_js
 language: node_js
-addons:
-  firefox: "latest"
 node_js:
 node_js:
   - "stable"
   - "stable"
 notifications:
 notifications:
@@ -14,6 +13,7 @@ notifications:
     use_notice: true
     use_notice: true
 # Set up a virtual screen for Firefox.
 # Set up a virtual screen for Firefox.
 before_script:
 before_script:
+  - export CHROME_BIN=/usr/bin/google-chrome
   - export DISPLAY=:99.0
   - export DISPLAY=:99.0
   - sh -e /etc/init.d/xvfb start
   - sh -e /etc/init.d/xvfb start
 env:
 env:
@@ -22,4 +22,8 @@ env:
   - secure: AnduYGXka5ft1x7V3SuVYqvlKLvJGhUaRNFdy4UDJr3ZVuwpQjE4TMDG8REmJIJvXfHbh4qY4N1cFSGnXkZ4bH21Xk0v9DLhsxbarKz+X2BvPgXs+Af9EQ6vLEy/5S1vMLxfT5+y+Ec5bVNGOsdUZby8Y21CRzSg6ADN9kwPGlE=
   - secure: AnduYGXka5ft1x7V3SuVYqvlKLvJGhUaRNFdy4UDJr3ZVuwpQjE4TMDG8REmJIJvXfHbh4qY4N1cFSGnXkZ4bH21Xk0v9DLhsxbarKz+X2BvPgXs+Af9EQ6vLEy/5S1vMLxfT5+y+Ec5bVNGOsdUZby8Y21CRzSg6ADN9kwPGlE=
 addons:
 addons:
   sauce_connect: true
   sauce_connect: true
-  firefox: latest
+  apt:
+    sources:
+    - google-chrome
+    packages:
+    - google-chrome-stable

@@ -9,6 +9,8 @@ Play back HLS with video.js, even where it's not natively supported.
 **Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
 **Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
 
 
 - [Getting Started](#getting-started)
 - [Getting Started](#getting-started)
+- [Known Issues](#known-issues)
+  - [IE11](#ie11)
 - [Documentation](#documentation)
 - [Documentation](#documentation)
   - [Options](#options)
   - [Options](#options)
     - [withCredentials](#withcredentials)
     - [withCredentials](#withcredentials)
@@ -44,7 +46,7 @@ and include it in your page along with video.js:
      type="application/x-mpegURL">
      type="application/x-mpegURL">
 </video>
 </video>
 <script src="video.js"></script>
 <script src="video.js"></script>
-<script src="videojs-hls.min.js"></script>
+<script src="videojs-contrib-hls.min.js"></script>
 <script>
 <script>
 var player = videojs('example-video');
 var player = videojs('example-video');
 player.play();
 player.play();
@@ -53,6 +55,16 @@ player.play();
 
 
 Check out our [live example](http://videojs.github.io/videojs-contrib-hls/) if you're having trouble.
 Check out our [live example](http://videojs.github.io/videojs-contrib-hls/) if you're having trouble.
 
 
+## Known Issues
+Issues that are currenty know about with workarounds. If you want to
+help find a solution that would be appreciated!
+
+### IE11
+In some IE11 setups there are issues working with it's native HTML
+SourceBuffers functionality. This leads to various issues, such as
+videos stopping playback with media decode errors. The known workaround
+for this issues is to force the player to use flash when running on IE11.
+
 ## Documentation
 ## Documentation
 [HTTP Live Streaming](https://developer.apple.com/streaming/) (HLS) has
 [HTTP Live Streaming](https://developer.apple.com/streaming/) (HLS) has
 become a de-facto standard for streaming video on mobile devices
 become a de-facto standard for streaming video on mobile devices
@@ -89,8 +101,7 @@ are some highlights:
 - mid-segment quality switching
 - mid-segment quality switching
 - AES-128 segment encryption
 - AES-128 segment encryption
 - CEA-608 captions are automatically translated into standard HTML5
 - CEA-608 captions are automatically translated into standard HTML5
-  [caption text
-  tracks](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/track)
+  [caption text tracks][0]
 - Timed ID3 Metadata is automatically translated into HTML5 metedata
 - Timed ID3 Metadata is automatically translated into HTML5 metedata
   text tracks
   text tracks
 - Highly customizable adaptive bitrate selection
 - Highly customizable adaptive bitrate selection
@@ -98,6 +109,10 @@ are some highlights:
 - Cross-domain credentials support with CORS
 - Cross-domain credentials support with CORS
 - Tight integration with video.js and a philosophy of exposing as much
 - Tight integration with video.js and a philosophy of exposing as much
   as possible with standard HTML APIs
   as possible with standard HTML APIs
+- Stream with multiple audio tracks and switching to those audio tracks
+  (see the docs folder) for info
+
+[0]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/track
 
 
 ### Options
 ### Options
 
 
@@ -106,11 +121,22 @@ initialization. You can pass in options just like you would for other
 parts of video.js:
 parts of video.js:
 
 
 ```javascript
 ```javascript
-videojs(video, {
+// html5 for html hls
+videojs(video, {html5: {
   hls: {
   hls: {
     withCredentials: true
     withCredentials: true
   }
   }
-});
+}});
+
+// or
+
+// flash for flash hls
+videojs(video, {flash: {
+  hls: {
+    withCredentials: true
+  }
+}});
+
 ```
 ```
 
 
 #### withCredentials
 #### withCredentials
@@ -289,26 +315,8 @@ and most CDNs should have no trouble turning CORS on for your account.
 
 
 ### Testing
 ### Testing
 
 
-For testing, you can either run `npm test` or use `grunt` directly.
-If you use `npm test`, it will only run the karma and end-to-end tests using chrome.
-You can specify which browsers you want the tests to run via grunt's `test` task.
-You can use either grunt-style arguments or comma separated arguments:
-```
-grunt test:chrome:firefox	# grunt-style
-grunt test:chrome,firefox	# comma-separated
-```
-Possible options are:
-* `chromecanary`
-* `phantomjs`
-* `opera`
-* `chrome`<sup>1</sup>
-* `safari`<sup>1, 2</sup>
-* `firefox`<sup>1</sup>
-* `ie`<sup>1</sup>
-
-
-_<sup>1</sup>supported end-to-end browsers_<br />
-_<sup>2</sup>requires the [SafariDriver extension]( https://code.google.com/p/selenium/wiki/SafariDriver) to be installed_
+For testing, you run `npm run test`. This will run tests using any of the
+browsers that karma-detect-browsers detects on your machine.
 
 
 ## Release History
 ## Release History
 Check out the [changelog](CHANGELOG.md) for a summary of each release.
 Check out the [changelog](CHANGELOG.md) for a summary of each release.

+# Multiple Alternative Audio Tracks
+## General
+m3u8 manifests with multiple audio streams will have those streams added to `video.js` in an `AudioTrackList`. The `AudioTrackList` can be accessed using `player.audioTracks()` or `tech.audioTracks()`.
+
+## Mapping m3u8 metadata to AudioTracks
+The mapping between `AudioTrack` and the parsed m3u8  file is fairly straight forward. The table below shows the mapping
+
+| m3u8    | AudioTrack |
+|---------|------------|
+| label   | label      |
+| lang    | language   |
+| default | enabled    |
+| ???     | kind       |
+| ???     | id         |
+
+As you can see m3u8's do not have a property for `AudioTrack.id`, which means that we let `video.js` randomly generate the id for `AudioTrack`s. This will have no real impact on any part of the system as we do not use the `id` anywhere.
+
+The other property that does not have a mapping in the m3u8 is `AudioTrack.kind`. It was decided that we would set the `kind` to `main` when `default` is set to `true` and in all other cases we set it to `alternative`
+
+Below is a basic example of a mapping
+m3u8 layout
+``` JavaScript
+{
+	'media-group-1': [{
+		'audio-track-1': {
+			default: true,
+			lang: 'eng'
+		},
+		'audio-track-2': {
+			default: true,
+			lang: 'fr'
+		}
+	}]
+}
+```
+
+Corresponding AudioTrackList when media-group-1 is used (before any tracks have been changed)
+``` JavaScript
+[{
+	label: 'audio-tracks-1',
+	enabled: true,
+	language: 'eng',
+	kind: 'main',
+	id: 'random'
+}, {
+	label: 'audio-tracks-2',
+	enabled: false,
+	language: 'fr',
+	kind: 'alternative',
+	id: 'random'
+}]
+```
+
+## Startup (how tracks are added and used)
+> AudioTrack & AudioTrackList live in video.js
+
+1. `HLS` creates a `MasterPlaylistController` and watches for the `loadedmetadata` event
+1. `HLS` parses the m3u8 using the `MasterPlaylistController`
+1. `MasterPlaylistController` creates a `PlaylistLoader` for the master m3u8
+1. `MasterPlaylistController` creates `PlaylistLoader`s for every audio playlist
+1. `MasterPlaylistController` creates a `SegmentLoader` for the main m3u8
+1. `MasterPlaylistController` creates a `SegmentLoader` for a potential audio playlist
+1. `HLS` sees the `loadedmetadata` and finds the currently selected MediaGroup and all the metadata
+1. `HLS` removes all `AudioTrack`s from the `AudioTrackList`
+1. `HLS` created `AudioTrack`s for the MediaGroup and adds them to the `AudioTrackList`
+1. `HLS` calls `MasterPlaylistController`s `useAudio` with no arguments (causes it to use the currently enabled audio)
+1. `MasterPlaylistController` turns off the current audio `PlaylistLoader` if it is on
+1. `MasterPlaylistController` maps the `label` to the `PlaylistLoader` containing the audio
+1. `MasterPlaylistController` turns on that `PlaylistLoader` and the Corresponding `SegmentLoader` (master or audio only)
+1. `MediaSource`/`mux.js` determine how to mux
+
+## How tracks are switched
+> AudioTrack & AudioTrackList live in video.js
+
+1. `HLS` is setup to watch for the `changed` event on the `AudioTrackList`
+1. User selects a new `AudioTrack` from a menu (where only one track can be enabled)
+1. `AudioTrackList` enables the new `Audiotrack` and disables all others
+1. `AudioTrackList` triggers a `changed` event
+1. `HLS` sees the `changed` event and finds the newly enabled `AudioTrack`
+1. `HLS` sends the `label` for the new `AudioTrack` to `MasterPlaylistController`s `useAudio` function
+1. `MasterPlaylistController` turns off the current audio `PlaylistLoader` if it is on
+1. `MasterPlaylistController` maps the `label` to the `PlaylistLoader` containing the audio
+1. `MasterPlaylistController` maps the `label` to the `PlaylistLoader` containing the audio
+1. `MasterPlaylistController` turns on that `PlaylistLoader` and the Corresponding `SegmentLoader` (master or audio only)
+1. `MediaSource`/`mux.js` determine how to mux
+

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Index</title>
+  </head>
+  <body>
+    <ul>
+      <li><a href="multiple-alternative-audio-tracks">Multiple Alternative Audio Tracks</a></li>
+    </ul>
+  </body>
+</html>

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Multiple Alternative Audio Tracks - Example</title>
+    <link href="/node_modules/video.js/dist/video-js.css" rel="stylesheet">
+  </head>
+  <body>
+    <h1>Multiple Alternative Audio Tracks</h1>
+    <p>Check the source of this page and the console for detailed information on this example</p>
+    <video id="maat-player" class="video-js vjs-default-skin" controls>
+      <source src="https://s3.amazonaws.com/_bc_dml/example-content/bipbop-advanced/bipbop_16x9_variant.m3u8" type="application/x-mpegURL">
+    </video>
+    <div id="audioTrackChoice">
+      <select id="enabled-audio-track" name="enabled-audio-track">
+      </select>
+    </div>
+    <script src="/node_modules/video.js/dist/video.js"></script>
+    <script src="/dist/videojs-contrib-hls.js"></script>
+    <script>
+      (function(window, videojs) {
+        var player = window.player = videojs('maat-player');
+        var audioTrackList = player.audioTracks();
+        var audioTrackSelect = document.getElementById("enabled-audio-track");
+        // watch for a change on the select element
+        // then change the enabled audio track
+        // only one can be enabled at a time, but video.js will
+        // handle that for us, all we need to do is enable the new
+        // track
+        audioTrackSelect.addEventListener('change', function() {
+          var track = audioTrackList[this.selectedIndex];
+          console.log('User switched to track ' + track.label);
+          track.enabled = true;
+        });
+
+        // watch for changes that will be triggered by any change
+        // to enabled on any audio track. Manually or through the
+        // select element
+        audioTrackList.on('change', function() {
+          for (var i = 0; i < audioTrackList.length; i++) {
+            var track = audioTrackList[i];
+            if (track.enabled) {
+              console.log('A new ' + track.label + ' has been enabled!');
+            }
+          }
+        });
+
+        // will be fired twice in this example
+        audioTrackList.on('addtrack', function() {
+          console.log('a track has been added to the audio track list');
+        });
+
+        // will not be fired at all unless you call
+        // audioTrackList.removeTrack(trackObj)
+        // we typically will not need to do this unless we have to load
+        // another video for some reason
+        audioTrackList.on('removetrack', function() {
+          console.log('a track has been removed from the audio track list');
+        });
+
+        // getting all the possible audio tracks from the track list
+        // get all of thier properties
+        // add each track to the select on the page
+        // this is all filled out by HLS when it parses the m3u8
+        player.on('loadeddata', function() {
+          console.log('There are ' + audioTrackList.length + ' audio tracks');
+          for (var i = 0; i < audioTrackList.length; i++) {
+            var track = audioTrackList[i];
+            var option = document.createElement("option");
+            option.text = track.label;
+            if (track.enabled) {
+              option.selected = true;
+            }
+            audioTrackSelect.add(option, i);
+            console.log('Track ' + (i + 1));
+            ['label', 'enabled', 'language', 'id', 'kind'].forEach(function(prop) {
+              console.log("  " + prop + ": " + track[prop]);
+            });
+          }
+        });
+      }(window, window.videojs));
+    </script>
+  </body>
+</html>

@@ -43,6 +43,7 @@
   <ul>
   <ul>
     <li><a href="/test/">Run unit tests in browser.</a></li>
     <li><a href="/test/">Run unit tests in browser.</a></li>
     <li><a href="/docs/api/">Read generated docs.</a></li>
     <li><a href="/docs/api/">Read generated docs.</a></li>
+    <li><a href="/examples">Browse Examples</a></li>
   </ul>
   </ul>
 
 
   <script src="/node_modules/video.js/dist/video.js"></script>
   <script src="/node_modules/video.js/dist/video.js"></script>
@@ -50,6 +51,7 @@
   <script>
   <script>
     (function(window, videojs) {
     (function(window, videojs) {
       var player = window.player = videojs('videojs-contrib-hls-player');
       var player = window.player = videojs('videojs-contrib-hls-player');
+
       // hook up the video switcher
       // hook up the video switcher
       var loadUrl = document.getElementById('load-url');
       var loadUrl = document.getElementById('load-url');
       var url = document.getElementById('url');
       var url = document.getElementById('url');

@@ -28,8 +28,7 @@
     "docs:api": "jsdoc src -r -d docs/api",
     "docs:api": "jsdoc src -r -d docs/api",
     "docs:toc": "doctoc README.md",
     "docs:toc": "doctoc README.md",
     "lint": "vjsstandard",
     "lint": "vjsstandard",
-    "prestart": "npm-run-all docs build",
-    "start": "npm-run-all -p start:* watch:*",
+    "start": "npm-run-all -p watch start:*",
     "start:serve": "babel-node scripts/server.js",
     "start:serve": "babel-node scripts/server.js",
     "pretest": "npm-run-all lint build",
     "pretest": "npm-run-all lint build",
     "test": "karma start test/karma/detected.js",
     "test": "karma start test/karma/detected.js",
@@ -40,7 +39,10 @@
     "preversion": "npm test",
     "preversion": "npm test",
     "version": "npm run build",
     "version": "npm run build",
     "watch": "npm-run-all -p watch:*",
     "watch": "npm-run-all -p watch:*",
-    "watch:js": "watchify src/videojs-contrib-hls.js -t babelify -v -o dist/videojs-contrib-hls.js",
+    "watch:docs": "nodemon --watch src/ --exec npm run docs",
+    "watch:js": "npm-run-all -p watch:js:babel watch:js:browserify",
+    "watch:js:babel": "npm run build:js:babel -- --watch",
+    "watch:js:browserify": "watchify . -v -o dist/videojs-contrib-hls.js",
     "watch:test": "npm-run-all -p watch:test:*",
     "watch:test": "npm-run-all -p watch:test:*",
     "watch:test:js": "node scripts/watch-test.js",
     "watch:test:js": "node scripts/watch-test.js",
     "watch:test:manifest": "node -e \"var b=require('./scripts/manifest-data.js'); b.watch();\"",
     "watch:test:manifest": "node -e \"var b=require('./scripts/manifest-data.js'); b.watch();\"",
@@ -73,21 +75,19 @@
   },
   },
   "files": [
   "files": [
     "CONTRIBUTING.md",
     "CONTRIBUTING.md",
-    "dist-test/",
     "dist/",
     "dist/",
     "docs/",
     "docs/",
     "es5/",
     "es5/",
     "index.html",
     "index.html",
     "scripts/",
     "scripts/",
     "src/",
     "src/",
-    "test/",
-    "utils/"
+    "test/"
   ],
   ],
   "dependencies": {
   "dependencies": {
     "pkcs7": "^0.2.2",
     "pkcs7": "^0.2.2",
-    "video.js": "^5.2.1",
-    "videojs-contrib-media-sources": "^3.0.0",
-    "videojs-swf": "^5.0.0"
+    "video.js": "^5.10.1",
+    "videojs-contrib-media-sources": "^3.1.0",
+    "videojs-swf": "^5.0.2"
   },
   },
   "devDependencies": {
   "devDependencies": {
     "babel": "^5.8.0",
     "babel": "^5.8.0",
@@ -111,6 +111,7 @@
     "karma-safari-launcher": "^0.1.0",
     "karma-safari-launcher": "^0.1.0",
     "lodash-compat": "^3.10.0",
     "lodash-compat": "^3.10.0",
     "minimist": "^1.2.0",
     "minimist": "^1.2.0",
+    "nodemon": "^1.9.1",
     "npm-run-all": "^1.2.0",
     "npm-run-all": "^1.2.0",
     "portscanner": "^1.0.0",
     "portscanner": "^1.0.0",
     "qunitjs": "^1.18.0",
     "qunitjs": "^1.18.0",

@@ -17,7 +17,7 @@ glob('test/**/*.test.js', function(err, files) {
   };
   };
 
 
   b.on('log', function(msg) {
   b.on('log', function(msg) {
-    process.stdout.write(msg + '\n');
+    process.stdout.write(msg + ' dist-test/videojs-contrib-hls.js\n');
   });
   });
 
 
   b.on('update', bundle);
   b.on('update', bundle);

+/**
+ * @file bin-utils.js
+ */
+
+/**
+ * convert a TimeRange to text
+ *
+ * @param {TimeRange} range the timerange to use for conversion
+ * @param {Number} i the iterator on the range to convert
+ */
 const textRange = function(range, i) {
 const textRange = function(range, i) {
   return range.start(i) + '-' + range.end(i);
   return range.start(i) + '-' + range.end(i);
 };
 };
 
 
+/**
+ * format a number as hex string
+ *
+ * @param {Number} e The number
+ * @param {Number} i the iterator
+ */
 const formatHexString = function(e, i) {
 const formatHexString = function(e, i) {
   let value = e.toString(16);
   let value = e.toString(16);
 
 
@@ -14,6 +30,9 @@ const formatAsciiString = function(e) {
   return '.';
   return '.';
 };
 };
 
 
+/**
+ * utils to help dump binary data to the console
+ */
 const utils = {
 const utils = {
   hexDump(data) {
   hexDump(data) {
     let bytes = Array.prototype.slice.call(data);
     let bytes = Array.prototype.slice.call(data);

-/*
- * aes.js
+/**
+ * @file decrypter/aes.js
  *
  *
  * This file contains an adaptation of the AES decryption algorithm
  * This file contains an adaptation of the AES decryption algorithm
  * from the Standford Javascript Cryptography Library. That work is
  * from the Standford Javascript Cryptography Library. That work is
@@ -96,7 +96,7 @@ let aesTables = null;
  * Schedule out an AES key for both encryption and decryption. This
  * Schedule out an AES key for both encryption and decryption. This
  * is a low-level class. Use a cipher mode to do bulk encryption.
  * is a low-level class. Use a cipher mode to do bulk encryption.
  *
  *
- * @constructor
+ * @class AES
  * @param key {Array} The key as an array of 4, 6 or 8 words.
  * @param key {Array} The key as an array of 4, 6 or 8 words.
  */
  */
 export default class AES {
 export default class AES {
@@ -184,13 +184,14 @@ export default class AES {
 
 
   /**
   /**
    * Decrypt 16 bytes, specified as four 32-bit words.
    * Decrypt 16 bytes, specified as four 32-bit words.
-   * @param encrypted0 {number} the first word to decrypt
-   * @param encrypted1 {number} the second word to decrypt
-   * @param encrypted2 {number} the third word to decrypt
-   * @param encrypted3 {number} the fourth word to decrypt
-   * @param out {Int32Array} the array to write the decrypted words
+   *
+   * @param {Number} encrypted0 the first word to decrypt
+   * @param {Number} encrypted1 the second word to decrypt
+   * @param {Number} encrypted2 the third word to decrypt
+   * @param {Number} encrypted3 the fourth word to decrypt
+   * @param {Int32Array} out the array to write the decrypted words
    * into
    * into
-   * @param offset {number} the offset into the output array to start
+   * @param {Number} offset the offset into the output array to start
    * writing results
    * writing results
    * @return {Array} The plaintext.
    * @return {Array} The plaintext.
    */
    */

+/**
+ * @file decrypter/async-stream.js
+ */
 import Stream from '../stream';
 import Stream from '../stream';
 
 
 /**
 /**
  * A wrapper around the Stream class to use setTiemout
  * A wrapper around the Stream class to use setTiemout
  * and run stream "jobs" Asynchronously
  * and run stream "jobs" Asynchronously
+ *
+ * @class AsyncStream
+ * @extends Stream
  */
  */
 export default class AsyncStream extends Stream {
 export default class AsyncStream extends Stream {
   constructor() {
   constructor() {
@@ -11,6 +17,12 @@ export default class AsyncStream extends Stream {
     this.delay = 1;
     this.delay = 1;
     this.timeout_ = null;
     this.timeout_ = null;
   }
   }
+
+  /**
+   * process an async job
+   *
+   * @private
+   */
   processJob_() {
   processJob_() {
     this.jobs.shift()();
     this.jobs.shift()();
     if (this.jobs.length) {
     if (this.jobs.length) {
@@ -20,6 +32,12 @@ export default class AsyncStream extends Stream {
       this.timeout_ = null;
       this.timeout_ = null;
     }
     }
   }
   }
+
+  /**
+   * push a job into the stream
+   *
+   * @param {Function} job the job to push into the stream
+   */
   push(job) {
   push(job) {
     this.jobs.push(job);
     this.jobs.push(job);
     if (!this.timeout_) {
     if (!this.timeout_) {

-/*
- * decrypter.js
+/**
+ * @file decrypter/decrypter.js
  *
  *
  * An asynchronous implementation of AES-128 CBC decryption with
  * An asynchronous implementation of AES-128 CBC decryption with
  * PKCS#7 padding.
  * PKCS#7 padding.
@@ -20,12 +20,12 @@ const ntoh = function(word) {
     (word >>> 24);
     (word >>> 24);
 };
 };
 
 
-/* eslint-disable max-len */
 /**
 /**
  * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
  * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
- * @param encrypted {Uint8Array} the encrypted bytes
- * @param key {Uint32Array} the bytes of the decryption key
- * @param initVector {Uint32Array} the initialization vector (IV) to
+ *
+ * @param {Uint8Array} encrypted the encrypted bytes
+ * @param {Uint32Array} key the bytes of the decryption key
+ * @param {Uint32Array} initVector the initialization vector (IV) to
  * use for the first round of CBC.
  * use for the first round of CBC.
  * @return {Uint8Array} the decrypted bytes
  * @return {Uint8Array} the decrypted bytes
  *
  *
@@ -33,7 +33,6 @@ const ntoh = function(word) {
  * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
  * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
  * @see https://tools.ietf.org/html/rfc2315
  * @see https://tools.ietf.org/html/rfc2315
  */
  */
-/* eslint-enable max-len */
 export const decrypt = function(encrypted, key, initVector) {
 export const decrypt = function(encrypted, key, initVector) {
   // word-level access to the encrypted bytes
   // word-level access to the encrypted bytes
   let encrypted32 = new Int32Array(encrypted.buffer,
   let encrypted32 = new Int32Array(encrypted.buffer,
@@ -106,6 +105,12 @@ export const decrypt = function(encrypted, key, initVector) {
  * The `Decrypter` class that manages decryption of AES
  * The `Decrypter` class that manages decryption of AES
  * data through `AsyncStream` objects and the `decrypt`
  * data through `AsyncStream` objects and the `decrypt`
  * function
  * function
+ *
+ * @param {Uint8Array} encrypted the encrypted bytes
+ * @param {Uint32Array} key the bytes of the decryption key
+ * @param {Uint32Array} initVector the initialization vector (IV) to
+ * @param {Function} done the function to run when done
+ * @class Decrypter
  */
  */
 export class Decrypter {
 export class Decrypter {
   constructor(encrypted, key, initVector, done) {
   constructor(encrypted, key, initVector, done) {
@@ -137,6 +142,20 @@ export class Decrypter {
       done(null, unpad(decrypted));
       done(null, unpad(decrypted));
     });
     });
   }
   }
+
+  /**
+   * a getter for step the maximum number of bytes to process at one time
+   *
+   * @return {Number} the value of step 32000
+   */
+  static get STEP() {
+    // 4 * 8000;
+    return 32000;
+  }
+
+  /**
+   * @private
+   */
   decryptChunk_(encrypted, key, initVector, decrypted) {
   decryptChunk_(encrypted, key, initVector, decrypted) {
     return function() {
     return function() {
       let bytes = decrypt(encrypted, key, initVector);
       let bytes = decrypt(encrypted, key, initVector);
@@ -146,10 +165,6 @@ export class Decrypter {
   }
   }
 }
 }
 
 
-// the maximum number of bytes to process at one time
-// 4 * 8000;
-Decrypter.STEP = 32000;
-
 export default {
 export default {
   Decrypter,
   Decrypter,
   decrypt
   decrypt

-/*
- * index.js
+/**
+ * @file decrypter/index.js
  *
  *
  * Index module to easily import the primary components of AES-128
  * Index module to easily import the primary components of AES-128
  * decryption. Like this:
  * decryption. Like this:

+/**
+ * @file hls-audio-track.js
+ */
+import {AudioTrack} from 'video.js';
+import PlaylistLoader from './playlist-loader';
+
+/**
+ * HlsAudioTrack extends video.js audio tracks but adds HLS
+ * specific data storage such as playlist loaders, mediaGroups
+ * and default/autoselect
+ *
+ * @param {Object} options options to create HlsAudioTrack with
+ * @class HlsAudioTrack
+ * @extends AudioTrack
+ */
+export default class HlsAudioTrack extends AudioTrack {
+  constructor(options) {
+    super({
+      kind: options.default ? 'main' : 'alternative',
+      enabled: options.default || false,
+      language: options.language,
+      label: options.label
+    });
+
+    this.hls = options.hls;
+    this.autoselect = options.autoselect || false;
+    this.default = options.default || false;
+    this.withCredentials = options.withCredentials || false;
+    this.mediaGroups_ = [];
+    this.addLoader(options.mediaGroup, options.resolvedUri);
+  }
+
+  /**
+   * get a PlaylistLoader from this track given a mediaGroup name
+   *
+   * @param {String} mediaGroup the mediaGroup to get the loader for
+   * @return {PlaylistLoader|Null} the PlaylistLoader or null
+   */
+  getLoader(mediaGroup) {
+    for (let i = 0; i < this.mediaGroups_.length; i++) {
+      let mgl = this.mediaGroups_[i];
+
+      if (mgl.mediaGroup === mediaGroup) {
+        return mgl.loader;
+      }
+    }
+  }
+
+  /**
+   * add a PlaylistLoader given a mediaGroup, and a uri. for a combined track
+   * we store null for the playlistloader
+   *
+   * @param {String} mediaGroup the mediaGroup to get the loader for
+   * @param {String} uri the uri to get the audio track/mediaGroup from
+   */
+  addLoader(mediaGroup, uri = null) {
+    let loader = null;
+
+    if (uri) {
+      // TODO: this should probably happen upstream in Master Playlist
+      // Controller when we can switch PlaylistLoader sources
+      // then we can just store the uri here instead
+      loader = new PlaylistLoader(uri, this.hls, this.withCredentials);
+    }
+    this.mediaGroups_.push({mediaGroup, loader});
+  }
+
+  /**
+   * remove a playlist loader from a track given the mediaGroup
+   *
+   * @param {String} mediaGroup the mediaGroup to remove
+   */
+  removeLoader(mediaGroup) {
+    for (let i = 0; i < this.mediaGroups_.length; i++) {
+      let mgl = this.mediaGroups_[i];
+
+      if (mgl.mediaGroup === mediaGroup) {
+        if (mgl.loader) {
+          mgl.loader.dispose();
+        }
+        this.mediaGroups_.splice(i, 1);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Dispose of this audio track and
+   * the playlist loader that it holds inside
+   */
+  dispose() {
+    let i = this.mediaGroups_.length;
+
+    while (i--) {
+      this.removeLoader(this.mediaGroups_[i].mediaGroup);
+    }
+  }
+}

 /**
 /**
+ * @file m3u8/index.js
+ *
  * Utilities for parsing M3U8 files. If the entire manifest is available,
  * Utilities for parsing M3U8 files. If the entire manifest is available,
  * `Parser` will create an object representation with enough detail for managing
  * `Parser` will create an object representation with enough detail for managing
  * playback. `ParseStream` and `LineStream` are lower-level parsing primitives
  * playback. `ParseStream` and `LineStream` are lower-level parsing primitives

+/**
+ * @file m3u8/line-stream.js
+ */
 import Stream from '../stream';
 import Stream from '../stream';
+
 /**
 /**
  * A stream that buffers string input and generates a `data` event for each
  * A stream that buffers string input and generates a `data` event for each
  * line.
  * line.
+ *
+ * @class LineStream
+ * @extends Stream
  */
  */
 export default class LineStream extends Stream {
 export default class LineStream extends Stream {
   constructor() {
   constructor() {
@@ -11,7 +18,8 @@ export default class LineStream extends Stream {
 
 
   /**
   /**
    * Add new data to be parsed.
    * Add new data to be parsed.
-   * @param data {string} the text to process
+   *
+   * @param {String} data the text to process
    */
    */
   push(data) {
   push(data) {
     let nextNewline;
     let nextNewline;

+/**
+ * @file m3u8/parse-stream.js
+ */
 import Stream from '../stream';
 import Stream from '../stream';
 
 
-// "forgiving" attribute list psuedo-grammar:
-// attributes -> keyvalue (',' keyvalue)*
-// keyvalue   -> key '=' value
-// key        -> [^=]*
-// value      -> '"' [^"]* '"' | [^,]*
+/**
+ * "forgiving" attribute list psuedo-grammar:
+ * attributes -> keyvalue (',' keyvalue)*
+ * keyvalue   -> key '=' value
+ * key        -> [^=]*
+ * value      -> '"' [^"]* '"' | [^,]*
+ */
 const attributeSeparator = function() {
 const attributeSeparator = function() {
   let key = '[^=]*';
   let key = '[^=]*';
   let value = '"[^"]*"|[^,]*';
   let value = '"[^"]*"|[^,]*';
@@ -13,6 +18,11 @@ const attributeSeparator = function() {
   return new RegExp('(?:^|,)(' + keyvalue + ')');
   return new RegExp('(?:^|,)(' + keyvalue + ')');
 };
 };
 
 
+/**
+ * Parse attributes from a line given the seperator
+ *
+ * @param {String} attributes the attibute line to parse
+ */
 const parseAttributes = function(attributes) {
 const parseAttributes = function(attributes) {
   // split the string using attributes as the separator
   // split the string using attributes as the separator
   let attrs = attributes.split(attributeSeparator());
   let attrs = attributes.split(attributeSeparator());
@@ -57,6 +67,9 @@ const parseAttributes = function(attributes) {
  * `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized
  * `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized
  * tags are given the tag type `unknown` and a single additional property
  * tags are given the tag type `unknown` and a single additional property
  * `data` with the remainder of the input.
  * `data` with the remainder of the input.
+ *
+ * @class ParseStream
+ * @extends Stream
  */
  */
 export default class ParseStream extends Stream {
 export default class ParseStream extends Stream {
   constructor() {
   constructor() {
@@ -65,7 +78,8 @@ export default class ParseStream extends Stream {
 
 
   /**
   /**
    * Parses an additional line of input.
    * Parses an additional line of input.
-   * @param line {string} a single line of an M3U8 file to parse
+   *
+   * @param {String} line a single line of an M3U8 file to parse
    */
    */
   push(line) {
   push(line) {
     let match;
     let match;
@@ -254,6 +268,18 @@ export default class ParseStream extends Stream {
       this.trigger('data', event);
       this.trigger('data', event);
       return;
       return;
     }
     }
+    match = (/^#EXT-X-MEDIA:?(.*)$/).exec(line);
+    if (match) {
+      event = {
+        type: 'tag',
+        tagType: 'media'
+      };
+      if (match[1]) {
+        event.attributes = parseAttributes(match[1]);
+      }
+      this.trigger('data', event);
+      return;
+    }
     match = (/^#EXT-X-ENDLIST/).exec(line);
     match = (/^#EXT-X-ENDLIST/).exec(line);
     if (match) {
     if (match) {
       this.trigger('data', {
       this.trigger('data', {

+/**
+ * @file m3u8/parser.js
+ */
 import Stream from '../stream' ;
 import Stream from '../stream' ;
 import LineStream from './line-stream';
 import LineStream from './line-stream';
 import ParseStream from './parse-stream';
 import ParseStream from './parse-stream';
@@ -20,6 +23,9 @@ import {mergeOptions} from 'video.js';
  * underlying input is somewhat nonsensical. It emits `info` and `warning`
  * underlying input is somewhat nonsensical. It emits `info` and `warning`
  * events during the parse if it encounters input that seems invalid or
  * events during the parse if it encounters input that seems invalid or
  * requires some property of the manifest object to be defaulted.
  * requires some property of the manifest object to be defaulted.
+ *
+ * @class Parser
+ * @extends Stream
  */
  */
 export default class Parser extends Stream {
 export default class Parser extends Stream {
   constructor() {
   constructor() {
@@ -34,6 +40,14 @@ export default class Parser extends Stream {
     let currentUri = {};
     let currentUri = {};
     let key;
     let key;
     let noop = function() {};
     let noop = function() {};
+    let defaultMediaGroups = {
+      'AUDIO': {},
+      'VIDEO': {},
+      'CLOSED-CAPTIONS': {},
+      'SUBTITLES': {}
+    };
+    // group segments into numbered timelines delineated by discontinuities
+    let currentTimeline = 0;
 
 
     // the manifest is empty until the parse stream begins delivering data
     // the manifest is empty until the parse stream begins delivering data
     this.manifest = {
     this.manifest = {
@@ -43,6 +57,9 @@ export default class Parser extends Stream {
 
 
     // update the manifest with the m3u8 entry from the parse stream
     // update the manifest with the m3u8 entry from the parse stream
     this.parseStream.on('data', function(entry) {
     this.parseStream.on('data', function(entry) {
+      let mediaGroup;
+      let rendition;
+
       ({
       ({
         tag() {
         tag() {
           // switch based on the tag type
           // switch based on the tag type
@@ -96,7 +113,6 @@ export default class Parser extends Stream {
               }
               }
 
 
               this.manifest.segments = uris;
               this.manifest.segments = uris;
-
             },
             },
             key() {
             key() {
               if (!entry.attributes) {
               if (!entry.attributes) {
@@ -149,6 +165,7 @@ export default class Parser extends Stream {
                 return;
                 return;
               }
               }
               this.manifest.discontinuitySequence = entry.number;
               this.manifest.discontinuitySequence = entry.number;
+              currentTimeline = entry.number;
             },
             },
             'playlist-type'() {
             'playlist-type'() {
               if (!(/VOD|EVENT/).test(entry.playlistType)) {
               if (!(/VOD|EVENT/).test(entry.playlistType)) {
@@ -161,6 +178,8 @@ export default class Parser extends Stream {
             },
             },
             'stream-inf'() {
             'stream-inf'() {
               this.manifest.playlists = uris;
               this.manifest.playlists = uris;
+              this.manifest.mediaGroups =
+                this.manifest.mediaGroups || defaultMediaGroups;
 
 
               if (!entry.attributes) {
               if (!entry.attributes) {
                 this.trigger('warn', {
                 this.trigger('warn', {
@@ -175,7 +194,48 @@ export default class Parser extends Stream {
               currentUri.attributes = mergeOptions(currentUri.attributes,
               currentUri.attributes = mergeOptions(currentUri.attributes,
                                                    entry.attributes);
                                                    entry.attributes);
             },
             },
+            media() {
+              this.manifest.mediaGroups =
+                this.manifest.mediaGroups || defaultMediaGroups;
+
+              if (!(entry.attributes &&
+                    entry.attributes.TYPE &&
+                    entry.attributes['GROUP-ID'] &&
+                    entry.attributes.NAME)) {
+                this.trigger('warn', {
+                  message: 'ignoring incomplete or missing media group'
+                });
+                return;
+              }
+
+              // find the media group, creating defaults as necessary
+              let mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
+
+              mediaGroupType[entry.attributes['GROUP-ID']] =
+                mediaGroupType[entry.attributes['GROUP-ID']] || {};
+              mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']];
+
+              // collect the rendition metadata
+              rendition = {
+                default: (/yes/i).test(entry.attributes.DEFAULT)
+              };
+              if (rendition.default) {
+                rendition.autoselect = true;
+              } else {
+                rendition.autoselect = (/yes/i).test(entry.attributes.AUTOSELECT);
+              }
+              if (entry.attributes.LANGUAGE) {
+                rendition.language = entry.attributes.LANGUAGE;
+              }
+              if (entry.attributes.URI) {
+                rendition.uri = entry.attributes.URI;
+              }
+
+              // insert the new rendition
+              mediaGroup[entry.attributes.NAME] = rendition;
+            },
             discontinuity() {
             discontinuity() {
+              currentTimeline += 1;
               currentUri.discontinuity = true;
               currentUri.discontinuity = true;
               this.manifest.discontinuityStarts.push(uris.length);
               this.manifest.discontinuityStarts.push(uris.length);
             },
             },
@@ -215,6 +275,7 @@ export default class Parser extends Stream {
           if (key) {
           if (key) {
             currentUri.key = key;
             currentUri.key = key;
           }
           }
+          currentUri.timeline = currentTimeline;
 
 
           // prepare for the next URI
           // prepare for the next URI
           currentUri = {};
           currentUri = {};
@@ -229,7 +290,8 @@ export default class Parser extends Stream {
 
 
   /**
   /**
    * Parse the input string and update the manifest object.
    * Parse the input string and update the manifest object.
-   * @param chunk {string} a potentially incomplete portion of the manifest
+   *
+   * @param {String} chunk a potentially incomplete portion of the manifest
    */
    */
   push(chunk) {
   push(chunk) {
     this.lineStream.push(chunk);
     this.lineStream.push(chunk);
@@ -246,4 +308,3 @@ export default class Parser extends Stream {
   }
   }
 
 
 }
 }
-

+/**
+ * @file master-playlist-controller.js
+ */
+import PlaylistLoader from './playlist-loader';
+import SegmentLoader from './segment-loader';
+import Ranges from './ranges';
+import videojs from 'video.js';
+import HlsAudioTrack from './hls-audio-track';
+
+// 5 minute blacklist
+const BLACKLIST_DURATION = 5 * 60 * 1000;
+let Hls;
+
+const parseCodecs = function(codecs) {
+  let result = {
+    codecCount: 0,
+    videoCodec: null,
+    audioProfile: null
+  };
+
+  result.codecCount = codecs.split(',').length;
+  result.codecCount = result.codecCount || 2;
+
+  // parse the video codec but ignore the version
+  result.videoCodec = (/(^|\s|,)+(avc1)[^ ,]*/i).exec(codecs);
+  result.videoCodec = result.videoCodec && result.videoCodec[2];
+
+  // parse the last field of the audio codec
+  result.audioProfile = (/(^|\s|,)+mp4a.\d+\.(\d+)/i).exec(codecs);
+  result.audioProfile = result.audioProfile && result.audioProfile[2];
+
+  return result;
+};
+
+/**
+ * the master playlist controller controller all interactons
+ * between playlists and segmentloaders. At this time this mainly
+ * involves a master playlist and a series of audio playlists
+ * if they are available
+ *
+ * @class MasterPlaylistController
+ * @extends videojs.EventTarget
+ */
+export default class MasterPlaylistController extends videojs.EventTarget {
+  constructor({
+    url,
+    withCredentials,
+    mode,
+    tech,
+    bandwidth,
+    externHls
+  }) {
+    super();
+
+    Hls = externHls;
+
+    this.withCredentials = withCredentials;
+    this.tech_ = tech;
+    this.hls_ = tech.hls;
+    this.mode_ = mode;
+    this.audioTracks_ = [];
+
+    this.mediaSource = new videojs.MediaSource({ mode });
+    this.mediaSource.on('audioinfo', (e) => this.trigger(e));
+    // load the media source into the player
+    this.mediaSource.addEventListener('sourceopen', this.handleSourceOpen_.bind(this));
+
+    let segmentLoaderOptions = {
+      hls: this.hls_,
+      mediaSource: this.mediaSource,
+      currentTime: this.tech_.currentTime.bind(this.tech_),
+      withCredentials: this.withCredentials,
+      seekable: () => this.seekable(),
+      seeking: () => this.tech_.seeking(),
+      setCurrentTime: (a) => this.setCurrentTime(a),
+      hasPlayed: () => this.tech_.played().length !== 0,
+      bandwidth
+    };
+
+    // combined audio/video or just video when alternate audio track is selected
+    this.mainSegmentLoader_ = new SegmentLoader(segmentLoaderOptions);
+    // alternate audio track
+    this.audioSegmentLoader_ = new SegmentLoader(segmentLoaderOptions);
+
+    if (!url) {
+      throw new Error('A non-empty playlist URL is required');
+    }
+
+    this.masterPlaylistLoader_ = new PlaylistLoader(url, this.hls_, this.withCredentials);
+
+    this.masterPlaylistLoader_.on('loadedmetadata', () => {
+      let media = this.masterPlaylistLoader_.media();
+
+      // if this isn't a live video and preload permits, start
+      // downloading segments
+      if (media.endList && this.tech_.preload() !== 'none') {
+        this.mainSegmentLoader_.playlist(media);
+        this.mainSegmentLoader_.expired(this.masterPlaylistLoader_.expired_);
+        this.mainSegmentLoader_.load();
+      }
+
+      this.setupSourceBuffer_();
+      this.setupFirstPlay();
+      this.useAudio();
+    });
+
+    this.masterPlaylistLoader_.on('loadedplaylist', () => {
+      let updatedPlaylist = this.masterPlaylistLoader_.media();
+      let seekable;
+
+      if (!updatedPlaylist) {
+        // select the initial variant
+        this.initialMedia_ = this.selectPlaylist();
+        this.masterPlaylistLoader_.media(this.initialMedia_);
+        this.fillAudioTracks_();
+
+        this.trigger('selectedinitialmedia');
+        return;
+      }
+
+      this.mainSegmentLoader_.playlist(updatedPlaylist);
+      this.mainSegmentLoader_.expired(this.masterPlaylistLoader_.expired_);
+      this.updateDuration();
+
+      // update seekable
+      seekable = this.seekable();
+      if (!updatedPlaylist.endList && seekable.length !== 0) {
+        this.mediaSource.addSeekableRange_(seekable.start(0), seekable.end(0));
+      }
+    });
+
+    this.masterPlaylistLoader_.on('error', () => {
+      this.blacklistCurrentPlaylist(this.masterPlaylistLoader_.error);
+    });
+
+    this.masterPlaylistLoader_.on('mediachanging', () => {
+      this.mainSegmentLoader_.pause();
+    });
+
+    this.masterPlaylistLoader_.on('mediachange', () => {
+      this.mainSegmentLoader_.abort();
+      this.mainSegmentLoader_.load();
+      this.tech_.trigger({
+        type: 'mediachange',
+        bubbles: true
+      });
+    });
+
+    this.mainSegmentLoader_.on('progress', () => {
+      // figure out what stream the next segment should be downloaded from
+      // with the updated bandwidth information
+      this.masterPlaylistLoader_.media(this.selectPlaylist());
+
+      this.trigger('progress');
+    });
+
+    this.mainSegmentLoader_.on('error', () => {
+      this.blacklistCurrentPlaylist(this.mainSegmentLoader_.error());
+    });
+
+    this.audioSegmentLoader_.on('error', () => {
+      videojs.log.warn('Problem encountered with the current alternate audio track' +
+                       '. Switching back to default.');
+      this.audioSegmentLoader_.abort();
+      this.audioPlaylistLoader_ = null;
+      this.useAudio();
+    });
+
+    this.masterPlaylistLoader_.load();
+  }
+
+  /**
+   * fill our internal list of HlsAudioTracks with data from
+   * the master playlist or use a default
+   *
+   * @private
+   */
+  fillAudioTracks_() {
+    let master = this.master();
+    let mediaGroups = master.mediaGroups || {};
+
+    // force a default if we have none or we are not
+    // in html5 mode (the only mode to support more than one
+    // audio track)
+    if (!mediaGroups ||
+        !mediaGroups.AUDIO ||
+        Object.keys(mediaGroups.AUDIO).length === 0 ||
+        this.mode_ !== 'html5') {
+      // "main" audio group, track name "default"
+      mediaGroups = videojs.mergeOptions(mediaGroups, {AUDIO: {
+        main: {default: {default: true}}}
+      });
+    }
+
+    let tracks = {};
+
+    for (let mediaGroup in mediaGroups.AUDIO) {
+      for (let label in mediaGroups.AUDIO[mediaGroup]) {
+        let properties = mediaGroups.AUDIO[mediaGroup][label];
+
+        // if the track already exists add a new "location"
+        // since tracks in different mediaGroups are actually the same
+        // track with different locations to download them from
+        if (tracks[label]) {
+          tracks[label].addLoader(mediaGroup, properties.resolvedUri);
+          continue;
+        }
+
+        let track = new HlsAudioTrack(videojs.mergeOptions(properties, {
+          hls: this.hls_,
+          withCredentials: this.withCredential,
+          mediaGroup,
+          label
+        }));
+
+        tracks[label] = track;
+        this.audioTracks_.push(track);
+      }
+    }
+  }
+
+  /**
+   * Call load on our SegmentLoaders
+   */
+  load() {
+    this.mainSegmentLoader_.load();
+    if (this.audioPlaylistLoader_) {
+      this.audioSegmentLoader_.load();
+    }
+  }
+
+  /**
+   * Get the current active Media Group for Audio
+   * given the selected playlist and its attributes
+   */
+  activeAudioGroup() {
+    let media = this.masterPlaylistLoader_.media();
+    let mediaGroup = 'main';
+
+    if (media && media.attributes && media.attributes.AUDIO) {
+      mediaGroup = media.attributes.AUDIO;
+    }
+
+    return mediaGroup;
+  }
+
+  /**
+   * Use any audio track that we have, and start to load it
+   */
+  useAudio() {
+    let track;
+
+    this.audioTracks_.forEach((t) => {
+      if (!track && t.enabled) {
+        track = t;
+      }
+    });
+
+    // called too early or no track is enabled
+    if (!track) {
+      return;
+    }
+
+    // Pause any alternative audio
+    if (this.audioPlaylistLoader_) {
+      this.audioPlaylistLoader_.pause();
+      this.audioPlaylistLoader_ = null;
+      this.audioSegmentLoader_.pause();
+    }
+
+    // If the audio track for the active audio group has
+    // a playlist loader than it is an alterative audio track
+    // otherwise it is a part of the mainSegmenLoader
+    let loader = track.getLoader(this.activeAudioGroup());
+
+    if (!loader) {
+      this.mainSegmentLoader_.clearBuffer();
+      return;
+    }
+
+    // TODO: it may be better to create the playlist loader here
+    // when we can change an audioPlaylistLoaders src
+    this.audioPlaylistLoader_ = loader;
+
+    if (this.audioPlaylistLoader_.started) {
+      this.audioPlaylistLoader_.load();
+      this.audioSegmentLoader_.load();
+      this.audioSegmentLoader_.clearBuffer();
+      return;
+    }
+
+    this.audioPlaylistLoader_.on('loadedmetadata', () => {
+      /* eslint-disable no-shadow */
+      let media = this.audioPlaylistLoader_.media();
+      /* eslint-enable no-shadow */
+
+      this.audioSegmentLoader_.playlist(media);
+      this.addMimeType_(this.audioSegmentLoader_, 'mp4a.40.2', media);
+
+      // if the video is already playing, or if this isn't a live video and preload
+      // permits, start downloading segments
+      if (!this.tech_.paused() ||
+          (media.endList && this.tech_.preload() !== 'none')) {
+        this.audioSegmentLoader_.load();
+      }
+
+      if (!media.endList) {
+        // trigger the playlist loader to start "expired time"-tracking
+        this.audioPlaylistLoader_.trigger('firstplay');
+      }
+    });
+
+    this.audioPlaylistLoader_.on('loadedplaylist', () => {
+      let updatedPlaylist;
+
+      if (this.audioPlaylistLoader_) {
+        updatedPlaylist = this.audioPlaylistLoader_.media();
+      }
+
+      if (!updatedPlaylist) {
+        // only one playlist to select
+        this.audioPlaylistLoader_.media(
+          this.audioPlaylistLoader_.playlists.master.playlists[0]);
+        return;
+      }
+
+      this.audioSegmentLoader_.playlist(updatedPlaylist);
+    });
+
+    this.audioPlaylistLoader_.on('error', () => {
+      videojs.log.warn('Problem encountered loading the alternate audio track' +
+                       '. Switching back to default.');
+      this.audioSegmentLoader_.abort();
+      this.audioPlaylistLoader_ = null;
+      this.useAudio();
+    });
+
+    this.audioSegmentLoader_.clearBuffer();
+    this.audioPlaylistLoader_.start();
+  }
+
+  /**
+   * Re-tune playback quality level for the current player
+   * conditions. This method may perform destructive actions, like
+   * removing already buffered content, to readjust the currently
+   * active playlist quickly.
+   *
+   * @private
+   */
+  fastQualityChange_() {
+    let media = this.selectPlaylist();
+
+    if (media !== this.masterPlaylistLoader_.media()) {
+      this.masterPlaylistLoader_.media(media);
+      this.mainSegmentLoader_.sourceUpdater_.remove(this.currentTimeFunc() + 5, Infinity);
+    }
+  }
+
+  /**
+   * Begin playback.
+   */
+  play() {
+    if (this.setupFirstPlay()) {
+      return;
+    }
+
+    if (this.tech_.ended()) {
+      this.tech_.setCurrentTime(0);
+    }
+
+    this.load();
+
+    // if the viewer has paused and we fell out of the live window,
+    // seek forward to the earliest available position
+    if (this.tech_.duration() === Infinity) {
+      if (this.tech_.currentTime() < this.tech_.seekable().start(0)) {
+        return this.tech_.setCurrentTime(this.tech_.seekable().start(0));
+      }
+    }
+
+  }
+
+  /**
+   * Seek to the latest media position if this is a live video and the
+   * player and video are loaded and initialized.
+   */
+  setupFirstPlay() {
+    let seekable;
+    let media = this.masterPlaylistLoader_.media();
+
+    // check that everything is ready to begin buffering
+    // 1) the active media playlist is available
+    if (media &&
+        // 2) the video is a live stream
+        !media.endList &&
+
+        // 3) the player is not paused
+        !this.tech_.paused() &&
+
+        // 4) the player has not started playing
+        !this.hasPlayed_) {
+
+      this.load();
+
+      // trigger the playlist loader to start "expired time"-tracking
+      this.masterPlaylistLoader_.trigger('firstplay');
+      this.hasPlayed_ = true;
+
+      // seek to the latest media position for live videos
+      seekable = this.seekable();
+      if (seekable.length) {
+        this.tech_.setCurrentTime(seekable.end(0));
+      }
+
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * handle the sourceopen event on the MediaSource
+   *
+   * @private
+   */
+  handleSourceOpen_() {
+    // Only attempt to create the source buffer if none already exist.
+    // handleSourceOpen is also called when we are "re-opening" a source buffer
+    // after `endOfStream` has been called (in response to a seek for instance)
+    this.setupSourceBuffer_();
+
+    // if autoplay is enabled, begin playback. This is duplicative of
+    // code in video.js but is required because play() must be invoked
+    // *after* the media source has opened.
+    if (this.tech_.autoplay()) {
+      this.tech_.play();
+    }
+
+    this.trigger('sourceopen');
+  }
+
+  /**
+   * Blacklists a playlist when an error occurs for a set amount of time
+   * making it unavailable for selection by the rendition selection algorithm
+   * and then forces a new playlist (rendition) selection.
+   *
+   * @param {Object=} error an optional error that may include the playlist
+   * to blacklist
+   */
+  blacklistCurrentPlaylist(error = {}) {
+    let currentPlaylist;
+    let nextPlaylist;
+
+    // If the `error` was generated by the playlist loader, it will contain
+    // the playlist we were trying to load (but failed) and that should be
+    // blacklisted instead of the currently selected playlist which is likely
+    // out-of-date in this scenario
+    currentPlaylist = error.playlist || this.masterPlaylistLoader_.media();
+
+    // If there is no current playlist, then an error occurred while we were
+    // trying to load the master OR while we were disposing of the tech
+    if (!currentPlaylist) {
+      this.error = error;
+      return this.mediaSource.endOfStream('network');
+    }
+
+    // Blacklist this playlist
+    currentPlaylist.excludeUntil = Date.now() + BLACKLIST_DURATION;
+
+    // Select a new playlist
+    nextPlaylist = this.selectPlaylist();
+
+    if (nextPlaylist) {
+      videojs.log.warn('Problem encountered with the current ' +
+                       'HLS playlist. Switching to another playlist.');
+
+      return this.masterPlaylistLoader_.media(nextPlaylist);
+    }
+    videojs.log.warn('Problem encountered with the current ' +
+                     'HLS playlist. No suitable alternatives found.');
+    // We have no more playlists we can select so we must fail
+    this.error = error;
+    return this.mediaSource.endOfStream('network');
+  }
+
+  /**
+   * Pause all segment loaders
+   */
+  pauseLoading() {
+    this.mainSegmentLoader_.pause();
+    if (this.audioPlaylistLoader_) {
+      this.audioSegmentLoader_.pause();
+    }
+  }
+
+  /**
+   * set the current time on all segment loaders
+   *
+   * @param {TimeRange} currentTime the current time to set
+   * @return {TimeRange} the current time
+   */
+  setCurrentTime(currentTime) {
+    let buffered = Ranges.findRange(this.tech_.buffered(), currentTime);
+
+    if (!(this.masterPlaylistLoader_ && this.masterPlaylistLoader_.media())) {
+      // return immediately if the metadata is not ready yet
+      return 0;
+    }
+
+    // it's clearly an edge-case but don't thrown an error if asked to
+    // seek within an empty playlist
+    if (!this.masterPlaylistLoader_.media().segments) {
+      return 0;
+    }
+
+    // if the seek location is already buffered, continue buffering as
+    // usual
+    if (buffered && buffered.length) {
+      return currentTime;
+    }
+
+    // cancel outstanding requests so we begin buffering at the new
+    // location
+    this.mainSegmentLoader_.abort();
+    if (this.audioPlaylistLoader_) {
+      this.audioSegmentLoader_.abort();
+    }
+
+    if (!this.tech_.paused()) {
+      this.mainSegmentLoader_.load();
+      if (this.audioPlaylistLoader_) {
+        this.audioSegmentLoader_.load();
+      }
+    }
+  }
+
+  /**
+   * get the current duration
+   *
+   * @return {TimeRange} the duration
+   */
+  duration() {
+    if (!this.masterPlaylistLoader_) {
+      return 0;
+    }
+
+    if (this.mediaSource) {
+      return this.mediaSource.duration;
+    }
+
+    return Hls.Playlist.duration(this.masterPlaylistLoader_.media());
+  }
+
+  /**
+   * check the seekable range
+   *
+   * @return {TimeRange} the seekable range
+   */
+  seekable() {
+    let media;
+    let mainSeekable;
+    let audioSeekable;
+
+    if (!this.masterPlaylistLoader_) {
+      return videojs.createTimeRanges();
+    }
+    media = this.masterPlaylistLoader_.media();
+    if (!media) {
+      return videojs.createTimeRanges();
+    }
+
+    mainSeekable = Hls.Playlist.seekable(media,
+                                         this.masterPlaylistLoader_.expired_);
+    if (mainSeekable.length === 0) {
+      return mainSeekable;
+    }
+
+    if (this.audioPlaylistLoader_) {
+      audioSeekable = Hls.Playlist.seekable(this.audioPlaylistLoader_.media(),
+                                            this.audioPlaylistLoader_.expired_);
+      if (audioSeekable.length === 0) {
+        return audioSeekable;
+      }
+    }
+
+    if (!audioSeekable) {
+      // seekable has been calculated based on buffering video data so it
+      // can be returned directly
+      return mainSeekable;
+    }
+
+    return videojs.createTimeRanges([[
+      (audioSeekable.start(0) > mainSeekable.start(0)) ? audioSeekable.start(0) :
+                                                         mainSeekable.start(0),
+      (audioSeekable.end(0) < mainSeekable.end(0)) ? audioSeekable.end(0) :
+                                                     mainSeekable.end(0)
+    ]]);
+  }
+
+  /**
+   * Update the player duration
+   */
+  updateDuration() {
+    let oldDuration = this.mediaSource.duration;
+    let newDuration = Hls.Playlist.duration(this.masterPlaylistLoader_.media());
+    let buffered = this.tech_.buffered();
+    let setDuration = () => {
+      this.mediaSource.duration = newDuration;
+      this.tech_.trigger('durationchange');
+
+      this.mediaSource.removeEventListener('sourceopen', setDuration);
+    };
+
+    if (buffered.length > 0) {
+      newDuration = Math.max(newDuration, buffered.end(buffered.length - 1));
+    }
+
+    // if the duration has changed, invalidate the cached value
+    if (oldDuration !== newDuration) {
+      // update the duration
+      if (this.mediaSource.readyState !== 'open') {
+        this.mediaSource.addEventListener('sourceopen', setDuration);
+      } else {
+        setDuration();
+      }
+    }
+  }
+
+  /**
+   * dispose of the MasterPlaylistController and everything
+   * that it controls
+   */
+  dispose() {
+    this.masterPlaylistLoader_.dispose();
+    this.audioTracks_.forEach((track) => {
+      track.dispose();
+    });
+    this.audioTracks_.length = 0;
+    this.mainSegmentLoader_.dispose();
+    this.audioSegmentLoader_.dispose();
+  }
+
+  /**
+   * return the master playlist object if we have one
+   *
+   * @return {Object} the master playlist object that we parsed
+   */
+  master() {
+    return this.masterPlaylistLoader_.master;
+  }
+
+  /**
+   * return the currently selected playlist
+   *
+   * @return {Object} the currently selected playlist object that we parsed
+   */
+  media() {
+    // playlist loader will not return media if it has not been fully loaded
+    return this.masterPlaylistLoader_.media() || this.initialMedia_;
+  }
+
+  /**
+   * setup our internal source buffers on our segment Loaders
+   *
+   * @private
+   */
+  setupSourceBuffer_() {
+    let media = this.masterPlaylistLoader_.media();
+
+    // wait until a media playlist is available and the Media Source is
+    // attached
+    if (!media || this.mediaSource.readyState !== 'open') {
+      return;
+    }
+
+    this.addMimeType_(this.mainSegmentLoader_, 'avc1.4d400d, mp4a.40.2', media);
+
+    // exclude any incompatible variant streams from future playlist
+    // selection
+    this.excludeIncompatibleVariants_(media);
+  }
+
+  /**
+   * add a time type to a segmentLoader
+   *
+   * @param {SegmentLoader} segmentLoader the segmentloader to work on
+   * @param {String} codecs to use by default
+   * @param {Object} the parsed media object
+   * @private
+   */
+  addMimeType_(segmentLoader, defaultCodecs, media) {
+    let mimeType = 'video/mp2t';
+
+    // if the codecs were explicitly specified, pass them along to the
+    // source buffer
+    if (media.attributes && media.attributes.CODECS) {
+      mimeType += '; codecs="' + media.attributes.CODECS + '"';
+    } else {
+      mimeType += '; codecs="' + defaultCodecs + '"';
+    }
+    segmentLoader.mimeType(mimeType);
+  }
+
+  /**
+   * Blacklist playlists that are known to be codec or
+   * stream-incompatible with the SourceBuffer configuration. For
+   * instance, Media Source Extensions would cause the video element to
+   * stall waiting for video data if you switched from a variant with
+   * video and audio to an audio-only one.
+   *
+   * @param {Object} media a media playlist compatible with the current
+   * set of SourceBuffers. Variants in the current master playlist that
+   * do not appear to have compatible codec or stream configurations
+   * will be excluded from the default playlist selection algorithm
+   * indefinitely.
+   * @private
+   */
+  excludeIncompatibleVariants_(media) {
+    let master = this.masterPlaylistLoader_.master;
+    let codecCount = 2;
+    let videoCodec = null;
+    let audioProfile = null;
+    let codecs;
+
+    if (media.attributes && media.attributes.CODECS) {
+      codecs = parseCodecs(media.attributes.CODECS);
+      videoCodec = codecs.videoCodec;
+      audioProfile = codecs.audioProfile;
+      codecCount = codecs.codecCount;
+    }
+    master.playlists.forEach(function(variant) {
+      let variantCodecs = {
+        codecCount: 2,
+        videoCodec: null,
+        audioProfile: null
+      };
+
+      if (variant.attributes && variant.attributes.CODECS) {
+        variantCodecs = parseCodecs(variant.attributes.CODECS);
+      }
+
+      // if the streams differ in the presence or absence of audio or
+      // video, they are incompatible
+      if (variantCodecs.codecCount !== codecCount) {
+        variant.excludeUntil = Infinity;
+      }
+
+      // if h.264 is specified on the current playlist, some flavor of
+      // it must be specified on all compatible variants
+      if (variantCodecs.videoCodec !== videoCodec) {
+        variant.excludeUntil = Infinity;
+      }
+      // HE-AAC ("mp4a.40.5") is incompatible with all other versions of
+      // AAC audio in Chrome 46. Don't mix the two.
+      if ((variantCodecs.audioProfile === '5' && audioProfile !== '5') ||
+          (audioProfile === '5' && variantCodecs.audioProfile !== '5')) {
+        variant.excludeUntil = Infinity;
+      }
+    });
+  }
+}

 /**
 /**
- * playlist-loader
+ * @file playlist-loader.js
  *
  *
  * A state machine that manages the loading, caching, and updating of
  * A state machine that manages the loading, caching, and updating of
  * M3U8 playlists.
  * M3U8 playlists.
@@ -11,21 +11,53 @@ import Stream from './stream';
 import m3u8 from './m3u8';
 import m3u8 from './m3u8';
 
 
 /**
 /**
- * Returns a new master playlist that is the result of merging an
- * updated media playlist into the original version. If the
- * updated media playlist does not match any of the playlist
- * entries in the original master playlist, null is returned.
- * @param master {object} a parsed master M3U8 object
- * @param media {object} a parsed media M3U8 object
- * @return {object} a new object that represents the original
- * master playlist with the updated media playlist merged in, or
- * null if the merge produced no change.
- */
+  * Returns a new array of segments that is the result of merging
+  * properties from an older list of segments onto an updated
+  * list. No properties on the updated playlist will be overridden.
+  *
+  * @param {Array} original the outdated list of segments
+  * @param {Array} update the updated list of segments
+  * @param {Number=} offset the index of the first update
+  * segment in the original segment list. For non-live playlists,
+  * this should always be zero and does not need to be
+  * specified. For live playlists, it should be the difference
+  * between the media sequence numbers in the original and updated
+  * playlists.
+  * @return a list of merged segment objects
+  */
+const updateSegments = function(original, update, offset) {
+  let result = update.slice();
+  let length;
+  let i;
+
+  offset = offset || 0;
+  length = Math.min(original.length, update.length + offset);
+
+  for (i = offset; i < length; i++) {
+    result[i - offset] = mergeOptions(original[i], result[i - offset]);
+  }
+  return result;
+};
+
+/**
+  * Returns a new master playlist that is the result of merging an
+  * updated media playlist into the original version. If the
+  * updated media playlist does not match any of the playlist
+  * entries in the original master playlist, null is returned.
+  *
+  * @param {Object} master a parsed master M3U8 object
+  * @param {Object} media a parsed media M3U8 object
+  * @return {Object} a new object that represents the original
+  * master playlist with the updated media playlist merged in, or
+  * null if the merge produced no change.
+  */
 const updateMaster = function(master, media) {
 const updateMaster = function(master, media) {
   let changed = false;
   let changed = false;
   let result = mergeOptions(master, {});
   let result = mergeOptions(master, {});
   let i = master.playlists.length;
   let i = master.playlists.length;
   let playlist;
   let playlist;
+  let segment;
+  let j;
 
 
   while (i--) {
   while (i--) {
     playlist = result.playlists[i];
     playlist = result.playlists[i];
@@ -45,10 +77,25 @@ const updateMaster = function(master, media) {
       // if the update could overlap existing segment information,
       // if the update could overlap existing segment information,
       // merge the two lists
       // merge the two lists
       if (playlist.segments) {
       if (playlist.segments) {
-        result.playlists[i].segments = updateSegments(playlist.segments,
-                                                      media.segments,
-                                                      media.mediaSequence -
-                                                      playlist.mediaSequence);
+        result.playlists[i].segments = updateSegments(
+          playlist.segments,
+          media.segments,
+          media.mediaSequence - playlist.mediaSequence
+        );
+      }
+      // resolve any missing segment and key URIs
+      j = 0;
+      if (result.playlists[i].segments) {
+        j = result.playlists[i].segments.length;
+      }
+      while (j--) {
+        segment = result.playlists[i].segments[j];
+        if (!segment.resolvedUri) {
+          segment.resolvedUri = resolveUrl(playlist.resolvedUri, segment.uri);
+        }
+        if (segment.key && !segment.key.resolvedUri) {
+          segment.key.resolvedUri = resolveUrl(playlist.resolvedUri, segment.key.uri);
+        }
       }
       }
       changed = true;
       changed = true;
     }
     }
@@ -57,258 +104,297 @@ const updateMaster = function(master, media) {
 };
 };
 
 
 /**
 /**
- * Returns a new array of segments that is the result of merging
- * properties from an older list of segments onto an updated
- * list. No properties on the updated playlist will be overridden.
- * @param original {array} the outdated list of segments
- * @param update {array} the updated list of segments
- * @param offset {number} (optional) the index of the first update
- * segment in the original segment list. For non-live playlists,
- * this should always be zero and does not need to be
- * specified. For live playlists, it should be the difference
- * between the media sequence numbers in the original and updated
- * playlists.
- * @return a list of merged segment objects
+ * Load a playlist from a remote loacation
+ *
+ * @class PlaylistLoader
+ * @extends Stream
+ * @param {String} srcUrl the url to start with
+ * @param {Boolean} withCredentials the withCredentials xhr option
+ * @constructor
  */
  */
-const updateSegments = function(original, update, offset) {
-  let result = update.slice();
-  let length;
-  let i;
+const PlaylistLoader = function(srcUrl, hls, withCredentials) {
+  /* eslint-disable consistent-this */
+  let loader = this;
+  /* eslint-enable consistent-this */
+  let dispose;
+  let mediaUpdateTimeout;
+  let request;
+  let playlistRequestError;
+  let haveMetadata;
+
+  PlaylistLoader.prototype.constructor.call(this);
+
+  this.hls_ = hls;
+
+  // a flag that disables "expired time"-tracking this setting has
+  // no effect when not playing a live stream
+  this.trackExpiredTime_ = false;
+
+  if (!srcUrl) {
+    throw new Error('A non-empty playlist URL is required');
+  }
 
 
-  offset = offset || 0;
-  length = Math.min(original.length, update.length + offset);
+  playlistRequestError = function(xhr, url, startingState) {
+    loader.setBandwidth(request || xhr);
 
 
-  for (i = offset; i < length; i++) {
-    result[i - offset] = mergeOptions(original[i], result[i - offset]);
-  }
-  return result;
-};
+    // any in-flight request is now finished
+    request = null;
 
 
-export default class PlaylistLoader extends Stream {
-  constructor(srcUrl, hls, withCredentials) {
-    super();
-    let loader = this;
-    let dispose;
-    let mediaUpdateTimeout;
-    let request;
-    let playlistRequestError;
-    let haveMetadata;
+    if (startingState) {
+      loader.state = startingState;
+    }
 
 
-    this.hls_ = hls;
+    loader.error = {
+      playlist: loader.master.playlists[url],
+      status: xhr.status,
+      message: 'HLS playlist request error at URL: ' + url,
+      responseText: xhr.responseText,
+      code: (xhr.status >= 500) ? 4 : 2
+    };
 
 
-    // a flag that disables "expired time"-tracking this setting has
-    // no effect when not playing a live stream
-    this.trackExpiredTime_ = false;
+    loader.trigger('error');
+  };
 
 
-    if (!srcUrl) {
-      throw new Error('A non-empty playlist URL is required');
-    }
+  // update the playlist loader's state in response to a new or
+  // updated playlist.
+  haveMetadata = function(xhr, url) {
+    let parser;
+    let refreshDelay;
+    let update;
 
 
-    playlistRequestError = function(xhr, url, startingState) {
-      loader.setBandwidth(request || xhr);
+    loader.setBandwidth(request || xhr);
 
 
-      // any in-flight request is now finished
-      request = null;
+    // any in-flight request is now finished
+    request = null;
 
 
-      if (startingState) {
-        loader.state = startingState;
-      }
+    loader.state = 'HAVE_METADATA';
 
 
-      loader.error = {
-        playlist: loader.master.playlists[url],
-        status: xhr.status,
-        message: 'HLS playlist request error at URL: ' + url,
-        responseText: xhr.responseText,
-        code: (xhr.status >= 500) ? 4 : 2
-      };
-      loader.trigger('error');
-    };
+    parser = new m3u8.Parser();
+    parser.push(xhr.responseText);
+    parser.end();
+    parser.manifest.uri = url;
 
 
-    // update the playlist loader's state in response to a new or
-    // updated playlist.
+    // merge this playlist into the master
+    update = updateMaster(loader.master, parser.manifest);
+    refreshDelay = (parser.manifest.targetDuration || 10) * 1000;
+    if (update) {
+      loader.master = update;
+      loader.updateMediaPlaylist_(parser.manifest);
+    } else {
+      // if the playlist is unchanged since the last reload,
+      // try again after half the target duration
+      refreshDelay /= 2;
+    }
 
 
-    haveMetadata = function(xhr, url) {
-      let parser;
-      let refreshDelay;
-      let update;
+    // refresh live playlists after a target duration passes
+    if (!loader.media().endList) {
+      window.clearTimeout(mediaUpdateTimeout);
+      mediaUpdateTimeout = window.setTimeout(function() {
+        loader.trigger('mediaupdatetimeout');
+      }, refreshDelay);
+    }
 
 
-      loader.setBandwidth(request || xhr);
+    loader.trigger('loadedplaylist');
+  };
 
 
-      // any in-flight request is now finished
-      request = null;
-      loader.state = 'HAVE_METADATA';
+  // initialize the loader state
+  loader.state = 'HAVE_NOTHING';
 
 
-      parser = new m3u8.Parser();
-      parser.push(xhr.responseText);
-      parser.end();
-      parser.manifest.uri = url;
-
-      // merge this playlist into the master
-      update = updateMaster(loader.master, parser.manifest);
-      refreshDelay = (parser.manifest.targetDuration || 10) * 1000;
-      if (update) {
-        loader.master = update;
-        loader.updateMediaPlaylist_(parser.manifest);
-      } else {
-        // if the playlist is unchanged since the last reload,
-        // try again after half the target duration
-        refreshDelay /= 2;
-      }
+  // track the time that has expired from the live window
+  // this allows the seekable start range to be calculated even if
+  // all segments with timing information have expired
+  this.expired_ = 0;
 
 
-      // refresh live playlists after a target duration passes
-      if (!loader.media().endList) {
-        window.clearTimeout(mediaUpdateTimeout);
-        mediaUpdateTimeout = window.setTimeout(function() {
-          loader.trigger('mediaupdatetimeout');
-        }, refreshDelay);
-      }
+  // capture the prototype dispose function
+  dispose = this.dispose;
 
 
-      loader.trigger('loadedplaylist');
-    };
+   /**
+    * Abort any outstanding work and clean up.
+    */
+  loader.dispose = function() {
+    loader.stopRequest();
+    window.clearTimeout(mediaUpdateTimeout);
+    dispose.call(this);
+  };
 
 
-    // initialize the loader state
-    loader.state = 'HAVE_NOTHING';
+  loader.stopRequest = () => {
+    if (request) {
+      let oldRequest = request;
 
 
-    // track the time that has expired from the live window
-    // this allows the seekable start range to be calculated even if
-    // all segments with timing information have expired
-    this.expired_ = 0;
+      request = null;
+      oldRequest.onreadystatechange = null;
+      oldRequest.abort();
+    }
+  };
+
+   /**
+    * When called without any arguments, returns the currently
+    * active media playlist. When called with a single argument,
+    * triggers the playlist loader to asynchronously switch to the
+    * specified media playlist. Calling this method while the
+    * loader is in the HAVE_NOTHING causes an error to be emitted
+    * but otherwise has no effect.
+    *
+    * @param {Object=} playlis tthe parsed media playlist
+    * object to switch to
+    * @return {Playlist} the current loaded media
+    */
+  loader.media = function(playlist) {
+    let startingState = loader.state;
+    let mediaChange;
+
+    // getter
+    if (!playlist) {
+      return loader.media_;
+    }
 
 
-    // capture the prototype dispose function
-    dispose = this.dispose;
+    // setter
+    if (loader.state === 'HAVE_NOTHING') {
+      throw new Error('Cannot switch media playlist from ' + loader.state);
+    }
 
 
-    /**
-      * Abort any outstanding work and clean up.
-      */
-    loader.dispose = function() {
+    // find the playlist object if the target playlist has been
+    // specified by URI
+    if (typeof playlist === 'string') {
+      if (!loader.master.playlists[playlist]) {
+        throw new Error('Unknown playlist URI: ' + playlist);
+      }
+      playlist = loader.master.playlists[playlist];
+    }
+
+    mediaChange = !loader.media_ || playlist.uri !== loader.media_.uri;
+
+    // switch to fully loaded playlists immediately
+    if (loader.master.playlists[playlist.uri].endList) {
+      // abort outstanding playlist requests
       if (request) {
       if (request) {
         request.onreadystatechange = null;
         request.onreadystatechange = null;
         request.abort();
         request.abort();
         request = null;
         request = null;
       }
       }
-      window.clearTimeout(mediaUpdateTimeout);
-      dispose.call(this);
-    };
-
-    /**
-      * When called without any arguments, returns the currently
-      * active media playlist. When called with a single argument,
-      * triggers the playlist loader to asynchronously switch to the
-      * specified media playlist. Calling this method while the
-      * loader is in the HAVE_NOTHING causes an error to be emitted
-      * but otherwise has no effect.
-      * @param playlist (optional) {object} the parsed media playlist
-      * object to switch to
-      */
-    loader.media = function(playlist) {
-      let startingState = loader.state;
-      let mediaChange;
-      // getter
-      if (!playlist) {
-        return loader.media_;
-      }
+      loader.state = 'HAVE_METADATA';
+      loader.media_ = playlist;
 
 
-      // setter
-      if (loader.state === 'HAVE_NOTHING') {
-        throw new Error('Cannot switch media playlist from ' + loader.state);
-      }
-
-      // find the playlist object if the target playlist has been
-      // specified by URI
-      if (typeof playlist === 'string') {
-        if (!loader.master.playlists[playlist]) {
-          throw new Error('Unknown playlist URI: ' + playlist);
-        }
-        playlist = loader.master.playlists[playlist];
+      // trigger media change if the active media has been updated
+      if (mediaChange) {
+        loader.trigger('mediachanging');
+        loader.trigger('mediachange');
       }
       }
+      return;
+    }
 
 
-      mediaChange = !loader.media_ || playlist.uri !== loader.media_.uri;
+    // switching to the active playlist is a no-op
+    if (!mediaChange) {
+      return;
+    }
 
 
-      // switch to fully loaded playlists immediately
-      if (loader.master.playlists[playlist.uri].endList) {
-        // abort outstanding playlist requests
-        if (request) {
-          request.onreadystatechange = null;
-          request.abort();
-          request = null;
-        }
-        loader.state = 'HAVE_METADATA';
-        loader.media_ = playlist;
+    loader.state = 'SWITCHING_MEDIA';
 
 
-        // trigger media change if the active media has been updated
-        if (mediaChange) {
-          loader.trigger('mediachange');
-        }
+    // there is already an outstanding playlist request
+    if (request) {
+      if (resolveUrl(loader.master.uri, playlist.uri) === request.url) {
+        // requesting to switch to the same playlist multiple times
+        // has no effect after the first
         return;
         return;
       }
       }
+      request.onreadystatechange = null;
+      request.abort();
+      request = null;
+    }
 
 
-      // switching to the active playlist is a no-op
-      if (!mediaChange) {
+    // request the new playlist
+    if (this.media_) {
+      this.trigger('mediachanging');
+    }
+    request = this.hls_.xhr({
+      uri: resolveUrl(loader.master.uri, playlist.uri),
+      withCredentials
+    }, function(error, req) {
+      // disposed
+      if (!request) {
         return;
         return;
       }
       }
 
 
-      loader.state = 'SWITCHING_MEDIA';
-
-      // there is already an outstanding playlist request
-      if (request) {
-        if (resolveUrl(loader.master.uri, playlist.uri) === request.url) {
-          // requesting to switch to the same playlist multiple times
-          // has no effect after the first
-          return;
-        }
-        request.onreadystatechange = null;
-        request.abort();
-        request = null;
+      if (error) {
+        return playlistRequestError(request, playlist.uri, startingState);
       }
       }
 
 
-      // request the new playlist
-      request = this.hls_.xhr({
-        uri: resolveUrl(loader.master.uri, playlist.uri),
-        withCredentials
-      }, function(error, request) {
-        if (error) {
-          return playlistRequestError(request, playlist.uri, startingState);
-        }
+      haveMetadata(req, playlist.uri);
 
 
-        haveMetadata(request, playlist.uri);
+      // fire loadedmetadata the first time a media playlist is loaded
+      if (startingState === 'HAVE_MASTER') {
+        loader.trigger('loadedmetadata');
+      } else {
+        loader.trigger('mediachange');
+      }
+    });
+  };
 
 
-        // fire loadedmetadata the first time a media playlist is loaded
-        if (startingState === 'HAVE_MASTER') {
-          loader.trigger('loadedmetadata');
-        } else {
-          loader.trigger('mediachange');
-        }
-      });
-    };
+  /**
+   * set the bandwidth on an xhr to the bandwidth on the playlist
+   */
+  loader.setBandwidth = function(xhr) {
+    loader.bandwidth = xhr.bandwidth;
+  };
+
+  // In a live playlist, don't keep track of the expired time
+  // until HLS tells us that "first play" has commenced
+  loader.on('firstplay', function() {
+    this.trackExpiredTime_ = true;
+  });
+
+  // live playlist staleness timeout
+  loader.on('mediaupdatetimeout', function() {
+    if (loader.state !== 'HAVE_METADATA') {
+      // only refresh the media playlist if no other activity is going on
+      return;
+    }
 
 
-    loader.setBandwidth = function(xhr) {
-      loader.bandwidth = xhr.bandwidth;
-    };
+    loader.state = 'HAVE_CURRENT_METADATA';
+    request = this.hls_.xhr({
+      uri: resolveUrl(loader.master.uri, loader.media().uri),
+      withCredentials
+    }, function(error, req) {
+      // disposed
+      if (!request) {
+        return;
+      }
 
 
-    // In a live list, don't keep track of the expired time until
-    // HLS tells us that "first play" has commenced
-    loader.on('firstplay', function() {
-      this.trackExpiredTime_ = true;
+      if (error) {
+        return playlistRequestError(request, loader.media().uri);
+      }
+      haveMetadata(request, loader.media().uri);
     });
     });
+  });
 
 
-    // live playlist staleness timeout
-    loader.on('mediaupdatetimeout', function() {
-      if (loader.state !== 'HAVE_METADATA') {
-        // only refresh the media playlist if no other activity is going on
-        return;
+  /**
+   * pause loading of the playlist
+   */
+  loader.pause = () => {
+    loader.stopRequest();
+    window.clearTimeout(mediaUpdateTimeout);
+  };
+
+  /**
+   * start loading of the playlist
+   */
+  loader.load = () => {
+    if (loader.started) {
+      if (!loader.media().endList) {
+        loader.trigger('mediaupdatetimeout');
+      } else {
+        loader.trigger('loadedplaylist');
       }
       }
+    } else {
+      loader.start();
+    }
+  };
 
 
-      loader.state = 'HAVE_CURRENT_METADATA';
-      request = this.hls_.xhr({
-        uri: resolveUrl(loader.master.uri, loader.media().uri),
-        withCredentials
-      }, function(error, request) {
-        if (error) {
-          return playlistRequestError(request, loader.media().uri);
-        }
-        haveMetadata(request, loader.media().uri);
-      });
-    });
+  /**
+   * start loading of the playlist
+   */
+  loader.start = () => {
+    loader.started = true;
 
 
     // request the specified URL
     // request the specified URL
     request = this.hls_.xhr({
     request = this.hls_.xhr({
@@ -316,8 +402,14 @@ export default class PlaylistLoader extends Stream {
       withCredentials
       withCredentials
     }, function(error, req) {
     }, function(error, req) {
       let parser;
       let parser;
+      let playlist;
       let i;
       let i;
 
 
+      // disposed
+      if (!request) {
+        return;
+      }
+
       // clear the loader's request reference
       // clear the loader's request reference
       request = null;
       request = null;
 
 
@@ -344,10 +436,23 @@ export default class PlaylistLoader extends Stream {
       if (parser.manifest.playlists) {
       if (parser.manifest.playlists) {
         loader.master = parser.manifest;
         loader.master = parser.manifest;
 
 
-        // setup by-URI lookups
+        // setup by-URI lookups and resolve media playlist URIs
         i = loader.master.playlists.length;
         i = loader.master.playlists.length;
         while (i--) {
         while (i--) {
-          loader.master.playlists[loader.master.playlists[i].uri] = loader.master.playlists[i];
+          playlist = loader.master.playlists[i];
+          loader.master.playlists[playlist.uri] = playlist;
+          playlist.resolvedUri = resolveUrl(loader.master.uri, playlist.uri);
+        }
+
+        // resolve any media group URIs
+        for (let groupKey in loader.master.mediaGroups.AUDIO) {
+          for (let labelKey in loader.master.mediaGroups.AUDIO[groupKey]) {
+            let alternateAudio = loader.master.mediaGroups.AUDIO[groupKey][labelKey];
+            if (alternateAudio.uri) {
+              alternateAudio.resolvedUri =
+                resolveUrl(loader.master.uri, alternateAudio.uri);
+            }
+          }
         }
         }
 
 
         loader.trigger('loadedplaylist');
         loader.trigger('loadedplaylist');
@@ -368,200 +473,82 @@ export default class PlaylistLoader extends Stream {
         }]
         }]
       };
       };
       loader.master.playlists[srcUrl] = loader.master.playlists[0];
       loader.master.playlists[srcUrl] = loader.master.playlists[0];
+      loader.master.playlists[0].resolvedUri = srcUrl;
       haveMetadata(req, srcUrl);
       haveMetadata(req, srcUrl);
       return loader.trigger('loadedmetadata');
       return loader.trigger('loadedmetadata');
     });
     });
-  }
-  /**
-   * Update the PlaylistLoader state to reflect the changes in an
-   * update to the current media playlist.
-   * @param update {object} the updated media playlist object
-   */
-  updateMediaPlaylist_(update) {
-    let outdated;
-    let i;
-    let segment;
-
-    outdated = this.media_;
-    this.media_ = this.master.playlists[update.uri];
-
-    if (!outdated) {
-      return;
-    }
+  };
+};
 
 
-    // don't track expired time until this flag is truthy
-    if (!this.trackExpiredTime_) {
-      return;
-    }
+PlaylistLoader.prototype = new Stream();
 
 
-    // if the update was the result of a rendition switch do not
-    // attempt to calculate expired_ since media-sequences need not
-    // correlate between renditions/variants
-    if (update.uri !== outdated.uri) {
-      return;
-    }
+ /**
+  * Update the PlaylistLoader state to reflect the changes in an
+  * update to the current media playlist.
+  *
+  * @param {Object} update the updated media playlist object
+  */
+PlaylistLoader.prototype.updateMediaPlaylist_ = function(update) {
+  let outdated;
+  let i;
+  let segment;
 
 
-    // try using precise timing from first segment of the updated
-    // playlist
-    if (update.segments.length) {
-      if (update.segments[0].start !== undefined) {
-        this.expired_ = update.segments[0].start;
-        return;
-      } else if (update.segments[0].end !== undefined) {
-        this.expired_ = update.segments[0].end - update.segments[0].duration;
-        return;
-      }
-    }
+  outdated = this.media_;
+  this.media_ = this.master.playlists[update.uri];
 
 
-    // calculate expired by walking the outdated playlist
-    i = update.mediaSequence - outdated.mediaSequence - 1;
+  if (!outdated) {
+    return;
+  }
 
 
-    for (; i >= 0; i--) {
-      segment = outdated.segments[i];
+  // don't track expired time until this flag is truthy
+  if (!this.trackExpiredTime_) {
+    return;
+  }
 
 
-      if (!segment) {
-        // we missed information on this segment completely between
-        // playlist updates so we'll have to take an educated guess
-        // once we begin buffering again, any error we introduce can
-        // be corrected
-        this.expired_ += outdated.targetDuration || 10;
-        continue;
-      }
+  // if the update was the result of a rendition switch do not
+  // attempt to calculate expired_ since media-sequences need not
+  // correlate between renditions/variants
+  if (update.uri !== outdated.uri) {
+    return;
+  }
 
 
-      if (segment.end !== undefined) {
-        this.expired_ = segment.end;
-        return;
-      }
-      if (segment.start !== undefined) {
-        this.expired_ = segment.start + segment.duration;
-        return;
-      }
-      this.expired_ += segment.duration;
+  // try using precise timing from first segment of the updated
+  // playlist
+  if (update.segments.length) {
+    if (typeof update.segments[0].start !== 'undefined') {
+      this.expired_ = update.segments[0].start;
+      return;
+    } else if (typeof update.segments[0].end !== 'undefined') {
+      this.expired_ = update.segments[0].end - update.segments[0].duration;
+      return;
     }
     }
   }
   }
 
 
-  /**
-   * Determine the index of the segment that contains a specified
-   * playback position in the current media playlist. Early versions
-   * of the HLS specification require segment durations to be rounded
-   * to the nearest integer which means it may not be possible to
-   * determine the correct segment for a playback position if that
-   * position is within .5 seconds of the segment duration. This
-   * function will always return the lower of the two possible indices
-   * in those cases.
-   *
-   * @param time {number} The number of seconds since the earliest
-   * possible position to determine the containing segment for
-   * @returns {number} The number of the media segment that contains
-   * that time position. If the specified playback position is outside
-   * the time range of the current set of media segments, the return
-   * value will be clamped to the index of the segment containing the
-   * closest playback position that is currently available.
-   */
-  getMediaIndexForTime_(time) {
-    let i;
-    let segment;
-    let originalTime = time;
-    let numSegments = this.media_.segments.length;
-    let lastSegment = numSegments - 1;
-    let startIndex;
-    let endIndex;
-    let knownStart;
-    let knownEnd;
-
-    if (!this.media_) {
-      return 0;
-    }
+  // calculate expired by walking the outdated playlist
+  i = update.mediaSequence - outdated.mediaSequence - 1;
 
 
-    // when the requested position is earlier than the current set of
-    // segments, return the earliest segment index
-    if (time < 0) {
-      return 0;
-    }
+  for (; i >= 0; i--) {
+    segment = outdated.segments[i];
 
 
-    // find segments with known timing information that bound the
-    // target time
-    for (i = 0; i < numSegments; i++) {
-      segment = this.media_.segments[i];
-      if (segment.end) {
-        if (segment.end > time) {
-          knownEnd = segment.end;
-          endIndex = i;
-          break;
-        } else {
-          knownStart = segment.end;
-          startIndex = i + 1;
-        }
-      }
+    if (!segment) {
+      // we missed information on this segment completely between
+      // playlist updates so we'll have to take an educated guess
+      // once we begin buffering again, any error we introduce can
+      // be corrected
+      this.expired_ += outdated.targetDuration || 10;
+      continue;
     }
     }
 
 
-    // use the bounds we just found and playlist information to
-    // estimate the segment that contains the time we are looking for
-    if (startIndex !== undefined) {
-      // We have a known-start point that is before our desired time so
-      // walk from that point forwards
-      time = time - knownStart;
-      for (i = startIndex; i < (endIndex || numSegments); i++) {
-        segment = this.media_.segments[i];
-        time -= segment.duration;
-
-        if (time < 0) {
-          return i;
-        }
-      }
-
-      if (i >= endIndex) {
-        // We haven't found a segment but we did hit a known end point
-        // so fallback to interpolating between the segment index
-        // based on the known span of the timeline we are dealing with
-        // and the number of segments inside that span
-        return startIndex + Math.floor(
-          ((originalTime - knownStart) / (knownEnd - knownStart)) *
-          (endIndex - startIndex));
-      }
-
-      // We _still_ haven't found a segment so load the last one
-      return lastSegment;
-    } else if (endIndex !== undefined) {
-      // We _only_ have a known-end point that is after our desired time so
-      // walk from that point backwards
-      time = knownEnd - time;
-      for (i = endIndex; i >= 0; i--) {
-        segment = this.media_.segments[i];
-        time -= segment.duration;
-
-        if (time < 0) {
-          return i;
-        }
-      }
-
-      // We haven't found a segment so load the first one if time is zero
-      if (time === 0) {
-        return 0;
-      } else {
-        return -1;
-      }
-    } else {
-      // We known nothing so walk from the front of the playlist,
-      // subtracting durations until we find a segment that contains
-      // time and return it
-      time = time - this.expired_;
-
-      if (time < 0) {
-        return -1;
-      }
-
-      for (i = 0; i < numSegments; i++) {
-        segment = this.media_.segments[i];
-        time -= segment.duration;
-        if (time < 0) {
-          return i;
-        }
-      }
-      // We are out of possible candidates so load the last one...
-      // The last one is the least likely to overlap a buffer and therefore
-      // the one most likely to tell us something about the timeline
-      return lastSegment;
+    if (typeof segment.end !== 'undefined') {
+      this.expired_ = segment.end;
+      return;
+    }
+    if (typeof segment.start !== 'undefined') {
+      this.expired_ = segment.start + segment.duration;
+      return;
     }
     }
+    this.expired_ += segment.duration;
   }
   }
-}
+};
+
+export default PlaylistLoader;

 /**
 /**
+ * @file playlist.js
+ *
  * Playlist related utilities.
  * Playlist related utilities.
  */
  */
 import {createTimeRange} from 'video.js';
 import {createTimeRange} from 'video.js';
@@ -13,6 +15,14 @@ let Playlist = {
   UNSAFE_LIVE_SEGMENTS: 3
   UNSAFE_LIVE_SEGMENTS: 3
 };
 };
 
 
+/**
+ * walk backward until we find a duration we can use
+ * or return a failure
+ *
+ * @param {Playlist} playlist the playlist to walk through
+ * @param {Number} endSequence the mediaSequence to stop walking on
+ */
+
 const backwardDuration = function(playlist, endSequence) {
 const backwardDuration = function(playlist, endSequence) {
   let result = 0;
   let result = 0;
   let i = endSequence - playlist.mediaSequence;
   let i = endSequence - playlist.mediaSequence;
@@ -48,6 +58,13 @@ const backwardDuration = function(playlist, endSequence) {
   return { result, precise: false };
   return { result, precise: false };
 };
 };
 
 
+/**
+ * walk forward until we find a duration we can use
+ * or return a failure
+ *
+ * @param {Playlist} playlist the playlist to walk through
+ * @param {Number} endSequence the mediaSequence to stop walking on
+ */
 const forwardDuration = function(playlist, endSequence) {
 const forwardDuration = function(playlist, endSequence) {
   let result = 0;
   let result = 0;
   let segment;
   let segment;
@@ -83,13 +100,15 @@ const forwardDuration = function(playlist, endSequence) {
   * playlist. The duration of a subinterval of the available segments
   * playlist. The duration of a subinterval of the available segments
   * may be calculated by specifying an end index.
   * may be calculated by specifying an end index.
   *
   *
-  * @param playlist {object} a media playlist object
-  * @param endSequence {number} (optional) an exclusive upper boundary
+  * @param {Object} playlist a media playlist object
+  * @param {Number=} endSequence an exclusive upper boundary
   * for the playlist.  Defaults to playlist length.
   * for the playlist.  Defaults to playlist length.
-  * @return {number} the duration between the first available segment
+  * @param {Number} expired the amount of time that has dropped
+  * off the front of the playlist in a live scenario
+  * @return {Number} the duration between the first available segment
   * and end index.
   * and end index.
   */
   */
-const intervalDuration = function(playlist, endSequence) {
+const intervalDuration = function(playlist, endSequence, expired) {
   let backward;
   let backward;
   let forward;
   let forward;
 
 
@@ -120,7 +139,7 @@ const intervalDuration = function(playlist, endSequence) {
   }
   }
 
 
   // return the less-precise, playlist-based duration estimate
   // return the less-precise, playlist-based duration estimate
-  return backward.result;
+  return backward.result + expired;
 };
 };
 
 
 /**
 /**
@@ -128,23 +147,23 @@ const intervalDuration = function(playlist, endSequence) {
   * are specified, the duration will be for the subset of the media
   * are specified, the duration will be for the subset of the media
   * timeline between those two indices. The total duration for live
   * timeline between those two indices. The total duration for live
   * playlists is always Infinity.
   * playlists is always Infinity.
-  * @param playlist {object} a media playlist object
-  * @param endSequence {number} (optional) an exclusive upper
-  * boundary for the playlist.  Defaults to the playlist media
+  *
+  * @param {Object} playlist a media playlist object
+  * @param {Number=} endSequence an exclusive upper
+  * boundary for the playlist. Defaults to the playlist media
   * sequence number plus its length.
   * sequence number plus its length.
-  * @param includeTrailingTime {boolean} (optional) if false, the
-  * interval between the final segment and the subsequent segment
-  * will not be included in the result
-  * @return {number} the duration between the start index and end
+  * @param {Number=} expired the amount of time that has
+  * dropped off the front of the playlist in a live scenario
+  * @return {Number} the duration between the start index and end
   * index.
   * index.
   */
   */
-export const duration = function(playlist, endSequence, includeTrailingTime) {
+export const duration = function(playlist, endSequence, expired) {
   if (!playlist) {
   if (!playlist) {
     return 0;
     return 0;
   }
   }
 
 
-  if (typeof includeTrailingTime === 'undefined') {
-    includeTrailingTime = true;
+  if (typeof expired !== 'number') {
+    expired = 0;
   }
   }
 
 
   // if a slice of the total duration is not requested, use
   // if a slice of the total duration is not requested, use
@@ -164,7 +183,7 @@ export const duration = function(playlist, endSequence, includeTrailingTime) {
   // calculate the total duration based on the segment durations
   // calculate the total duration based on the segment durations
   return intervalDuration(playlist,
   return intervalDuration(playlist,
                           endSequence,
                           endSequence,
-                          includeTrailingTime);
+                          expired);
 };
 };
 
 
 /**
 /**
@@ -174,16 +193,24 @@ export const duration = function(playlist, endSequence, includeTrailingTime) {
   * seekable implementation for live streams would need to offset
   * seekable implementation for live streams would need to offset
   * these values by the duration of content that has expired from the
   * these values by the duration of content that has expired from the
   * stream.
   * stream.
-  * @param playlist {object} a media playlist object
+  *
+  * @param {Object} playlist a media playlist object
+  * @param {Number=} expired the amount of time that has
+  * dropped off the front of the playlist in a live scenario
   * @return {TimeRanges} the periods of time that are valid targets
   * @return {TimeRanges} the periods of time that are valid targets
   * for seeking
   * for seeking
   */
   */
-export const seekable = function(playlist) {
+export const seekable = function(playlist, expired) {
   let start;
   let start;
   let end;
   let end;
+  let endSequence;
+
+  if (typeof expired !== 'number') {
+    expired = 0;
+  }
 
 
   // without segments, there are no seekable ranges
   // without segments, there are no seekable ranges
-  if (!playlist.segments) {
+  if (!playlist || !playlist.segments) {
     return createTimeRange();
     return createTimeRange();
   }
   }
   // when the playlist is complete, the entire duration is seekable
   // when the playlist is complete, the entire duration is seekable
@@ -194,15 +221,142 @@ export const seekable = function(playlist) {
   // live playlists should not expose three segment durations worth
   // live playlists should not expose three segment durations worth
   // of content from the end of the playlist
   // of content from the end of the playlist
   // https://tools.ietf.org/html/draft-pantos-http-live-streaming-16#section-6.3.3
   // https://tools.ietf.org/html/draft-pantos-http-live-streaming-16#section-6.3.3
-  start = intervalDuration(playlist, playlist.mediaSequence);
+  start = intervalDuration(playlist, playlist.mediaSequence, expired);
+  endSequence = Math.max(0, playlist.segments.length - Playlist.UNSAFE_LIVE_SEGMENTS);
   end = intervalDuration(playlist,
   end = intervalDuration(playlist,
-                         playlist.mediaSequence +
-                         Math.max(0, playlist.segments.length - Playlist.UNSAFE_LIVE_SEGMENTS));
+                         playlist.mediaSequence + endSequence,
+                         expired);
   return createTimeRange(start, end);
   return createTimeRange(start, end);
 };
 };
 
 
+/**
+ * Determine the index of the segment that contains a specified
+ * playback position in a media playlist.
+ *
+ * @param {Object} playlist the media playlist to query
+ * @param {Number} time The number of seconds since the earliest
+ * possible position to determine the containing segment for
+ * @param {Number=} expired the duration of content, in
+ * seconds, that has been removed from this playlist because it
+ * expired
+ * @return {Number} The number of the media segment that contains
+ * that time position.
+ */
+export const getMediaIndexForTime_ = function(playlist, time, expired) {
+  let i;
+  let segment;
+  let originalTime = time;
+  let numSegments = playlist.segments.length;
+  let lastSegment = numSegments - 1;
+  let startIndex;
+  let endIndex;
+  let knownStart;
+  let knownEnd;
+
+  if (!playlist) {
+    return 0;
+  }
+
+  // when the requested position is earlier than the current set of
+  // segments, return the earliest segment index
+  if (time < 0) {
+    return 0;
+  }
+
+  expired = expired || 0;
+
+  // find segments with known timing information that bound the
+  // target time
+  for (i = 0; i < numSegments; i++) {
+    segment = playlist.segments[i];
+    if (segment.end) {
+      if (segment.end > time) {
+        knownEnd = segment.end;
+        endIndex = i;
+        break;
+      } else {
+        knownStart = segment.end;
+        startIndex = i + 1;
+      }
+    }
+  }
+
+  // time was equal to or past the end of the last segment in the playlist
+  if (startIndex === numSegments) {
+    return numSegments;
+  }
+
+  // use the bounds we just found and playlist information to
+  // estimate the segment that contains the time we are looking for
+  if (typeof startIndex !== 'undefined') {
+    // We have a known-start point that is before our desired time so
+    // walk from that point forwards
+    time = time - knownStart;
+    for (i = startIndex; i < (endIndex || numSegments); i++) {
+      segment = playlist.segments[i];
+      time -= segment.duration;
+
+      if (time < 0) {
+        return i;
+      }
+    }
+
+    if (i >= endIndex) {
+      // We haven't found a segment but we did hit a known end point
+      // so fallback to interpolating between the segment index
+      // based on the known span of the timeline we are dealing with
+      // and the number of segments inside that span
+      return startIndex + Math.floor(
+        ((originalTime - knownStart) / (knownEnd - knownStart)) *
+        (endIndex - startIndex));
+    }
+
+    // We _still_ haven't found a segment so load the last one
+    return lastSegment;
+  } else if (typeof endIndex !== 'undefined') {
+    // We _only_ have a known-end point that is after our desired time so
+    // walk from that point backwards
+    time = knownEnd - time;
+    for (i = endIndex; i >= 0; i--) {
+      segment = playlist.segments[i];
+      time -= segment.duration;
+
+      if (time < 0) {
+        return i;
+      }
+    }
+
+    // We haven't found a segment so load the first one if time is zero
+    if (time === 0) {
+      return 0;
+    }
+    return -1;
+  }
+  // We known nothing so walk from the front of the playlist,
+  // subtracting durations until we find a segment that contains
+  // time and return it
+  time = time - expired;
+
+  if (time < 0) {
+    return -1;
+  }
+
+  for (i = 0; i < numSegments; i++) {
+    segment = playlist.segments[i];
+    time -= segment.duration;
+    if (time < 0) {
+      return i;
+    }
+  }
+  // We are out of possible candidates so load the last one...
+  // The last one is the least likely to overlap a buffer and therefore
+  // the one most likely to tell us something about the timeline
+  return lastSegment;
+};
+
 Playlist.duration = duration;
 Playlist.duration = duration;
 Playlist.seekable = seekable;
 Playlist.seekable = seekable;
+Playlist.getMediaIndexForTime_ = getMediaIndexForTime_;
 
 
 // exports
 // exports
 export default Playlist;
 export default Playlist;

+/**
+ * ranges
+ *
+ * Utilities for working with TimeRanges.
+ *
+ */
+
+import videojs from 'video.js';
+
+// Fudge factor to account for TimeRanges rounding
+const TIME_FUDGE_FACTOR = 1 / 30;
+
+const filterRanges = function(timeRanges, predicate) {
+  let results = [];
+  let i;
+
+  if (timeRanges && timeRanges.length) {
+    // Search for ranges that match the predicate
+    for (i = 0; i < timeRanges.length; i++) {
+      if (predicate(timeRanges.start(i), timeRanges.end(i))) {
+        results.push([timeRanges.start(i), timeRanges.end(i)]);
+      }
+    }
+  }
+
+  return videojs.createTimeRanges(results);
+};
+
+/**
+ * Attempts to find the buffered TimeRange that contains the specified
+ * time.
+ * @param {TimeRanges} buffered - the TimeRanges object to query
+ * @param {number} time  - the time to filter on.
+ * @returns {TimeRanges} a new TimeRanges object
+ */
+const findRange = function(buffered, time) {
+  return filterRanges(buffered, function(start, end) {
+    return start - TIME_FUDGE_FACTOR <= time &&
+      end + TIME_FUDGE_FACTOR >= time;
+  });
+};
+
+/**
+ * Returns the TimeRanges that begin at or later than the specified
+ * time.
+ * @param {TimeRanges} timeRanges - the TimeRanges object to query
+ * @param {number} time - the time to filter on.
+ * @returns {TimeRanges} a new TimeRanges object.
+ */
+const findNextRange = function(timeRanges, time) {
+  return filterRanges(timeRanges, function(start) {
+    return start - TIME_FUDGE_FACTOR >= time;
+  });
+};
+
+/**
+ * Search for a likely end time for the segment that was just appened
+ * based on the state of the `buffered` property before and after the
+ * append. If we fin only one such uncommon end-point return it.
+ * @param {TimeRanges} original - the buffered time ranges before the update
+ * @param {TimeRanges} update - the buffered time ranges after the update
+ * @returns {Number|null} the end time added between `original` and `update`,
+ * or null if one cannot be unambiguously determined.
+ */
+const findSoleUncommonTimeRangesEnd = function(original, update) {
+  let i;
+  let start;
+  let end;
+  let result = [];
+  let edges = [];
+
+  // In order to qualify as a possible candidate, the end point must:
+  //  1) Not have already existed in the `original` ranges
+  //  2) Not result from the shrinking of a range that already existed
+  //     in the `original` ranges
+  //  3) Not be contained inside of a range that existed in `original`
+  const overlapsCurrentEnd = function(span) {
+    return (span[0] <= end && span[1] >= end);
+  };
+
+  if (original) {
+    // Save all the edges in the `original` TimeRanges object
+    for (i = 0; i < original.length; i++) {
+      start = original.start(i);
+      end = original.end(i);
+
+      edges.push([start, end]);
+    }
+  }
+
+  if (update) {
+    // Save any end-points in `update` that are not in the `original`
+    // TimeRanges object
+    for (i = 0; i < update.length; i++) {
+      start = update.start(i);
+      end = update.end(i);
+
+      if (edges.some(overlapsCurrentEnd)) {
+        continue;
+      }
+
+      // at this point it must be a unique non-shrinking end edge
+      result.push(end);
+    }
+  }
+
+  // we err on the side of caution and return null if didn't find
+  // exactly *one* differing end edge in the search above
+  if (result.length !== 1) {
+    return null;
+  }
+
+  return result[0];
+};
+
+/**
+ * Calculate the intersection of two TimeRanges
+ * @param {TimeRanges} bufferA
+ * @param {TimeRanges} bufferB
+ * @returns {TimeRanges} The interesection of `bufferA` with `bufferB`
+ */
+const bufferIntersection = function(bufferA, bufferB) {
+  let start = null;
+  let end = null;
+  let arity = 0;
+  let extents = [];
+  let ranges = [];
+
+  if (!bufferA || !bufferA.length || !bufferB || !bufferB.length) {
+    return videojs.createTimeRange();
+  }
+
+  // Handle the case where we have both buffers and create an
+  // intersection of the two
+  let count = bufferA.length;
+
+  // A) Gather up all start and end times
+  while (count--) {
+    extents.push({time: bufferA.start(count), type: 'start'});
+    extents.push({time: bufferA.end(count), type: 'end'});
+  }
+  count = bufferB.length;
+  while (count--) {
+    extents.push({time: bufferB.start(count), type: 'start'});
+    extents.push({time: bufferB.end(count), type: 'end'});
+  }
+  // B) Sort them by time
+  extents.sort(function(a, b) {
+    return a.time - b.time;
+  });
+
+  // C) Go along one by one incrementing arity for start and decrementing
+  //    arity for ends
+  for (count = 0; count < extents.length; count++) {
+    if (extents[count].type === 'start') {
+      arity++;
+
+      // D) If arity is ever incremented to 2 we are entering an
+      //    overlapping range
+      if (arity === 2) {
+        start = extents[count].time;
+      }
+    } else if (extents[count].type === 'end') {
+      arity--;
+
+      // E) If arity is ever decremented to 1 we leaving an
+      //    overlapping range
+      if (arity === 1) {
+        end = extents[count].time;
+      }
+    }
+
+    // F) Record overlapping ranges
+    if (start !== null && end !== null) {
+      ranges.push([start, end]);
+      start = null;
+      end = null;
+    }
+  }
+
+  return videojs.createTimeRanges(ranges);
+};
+
+/**
+ * Calculates the percentage of `segmentRange` that overlaps the
+ * `buffered` time ranges.
+ * @param {TimeRanges} segmentRange - the time range that the segment covers
+ * @param {TimeRanges} buffered - the currently buffered time ranges
+ * @returns {Number} percent of the segment currently buffered
+ */
+const calculateBufferedPercent = function(segmentRange, buffered) {
+  let segmentDuration = segmentRange.end(0) - segmentRange.start(0);
+  let intersection = bufferIntersection(segmentRange, buffered);
+  let overlapDuration = 0;
+  let count = intersection.length;
+
+  while (count--) {
+    overlapDuration += intersection.end(count) - intersection.start(count);
+  }
+
+  return (overlapDuration / segmentDuration) * 100;
+};
+
+export default {
+  findRange,
+  findNextRange,
+  findSoleUncommonTimeRangesEnd,
+  calculateBufferedPercent,
+  TIME_FUDGE_FACTOR
+};

+/**
+ * @file resolve-url.js
+ */
 import document from 'global/document';
 import document from 'global/document';
-/* eslint-disable max-len */
 /**
 /**
  * Constructs a new URI by interpreting a path relative to another
  * Constructs a new URI by interpreting a path relative to another
  * URI.
  * URI.
- * @param basePath {string} a relative or absolute URI
- * @param path {string} a path part to combine with the base
- * @return {string} a URI that is equivalent to composing `base`
- * with `path`
+ *
  * @see http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
  * @see http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
+ * @param {String} basePath a relative or absolute URI
+ * @param {String} path a path part to combine with the base
+ * @return {String} a URI that is equivalent to composing `base`
+ * with `path`
  */
  */
-/* eslint-enable max-len */
 const resolveUrl = function(basePath, path) {
 const resolveUrl = function(basePath, path) {
   // use the base element to get the browser to handle URI resolution
   // use the base element to get the browser to handle URI resolution
   let oldBase = document.querySelector('base');
   let oldBase = document.querySelector('base');

+/**
+ * @file segment-loader.js
+ */
+import Ranges from './ranges';
+import {getMediaIndexForTime_ as getMediaIndexForTime, duration} from './playlist';
+import videojs from 'video.js';
+import SourceUpdater from './source-updater';
+import {Decrypter} from './decrypter';
+
+// in ms
+const CHECK_BUFFER_DELAY = 500;
+
+// the desired length of video to maintain in the buffer, in seconds
+export const GOAL_BUFFER_LENGTH = 30;
+
+/**
+ * Updates segment with information about its end-point in time and, optionally,
+ * the segment duration if we have enough information to determine a segment duration
+ * accurately.
+ *
+ * @param {Object} playlist a media playlist object
+ * @param {Number} segmentIndex the index of segment we last appended
+ * @param {Number} segmentEnd the known of the segment referenced by segmentIndex
+ */
+const updateSegmentMetadata = function(playlist, segmentIndex, segmentEnd) {
+  if (!playlist) {
+    return false;
+  }
+
+  let segment = playlist.segments[segmentIndex];
+  let previousSegment = playlist.segments[segmentIndex - 1];
+
+  if (segmentEnd && segment) {
+    segment.end = segmentEnd;
+
+    // fix up segment durations based on segment end data
+    if (!previousSegment) {
+      // first segment is always has a start time of 0 making its duration
+      // equal to the segment end
+      segment.duration = segment.end;
+    } else if (previousSegment.end) {
+      segment.duration = segment.end - previousSegment.end;
+    }
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Determines if we should call endOfStream on the media source based
+ * on the state of the buffer or if appened segment was the final
+ * segment in the playlist.
+ *
+ * @param {Object} playlist a media playlist object
+ * @param {Object} mediaSource the MediaSource object
+ * @param {Number} segmentIndex the index of segment we last appended
+ * @param {Object} currentBuffered buffered region that currentTime resides in
+ * @returns {Boolean} do we need to call endOfStream on the MediaSource
+ */
+const detectEndOfStream = function(playlist, mediaSource, segmentIndex, currentBuffered) {
+  if (!playlist) {
+    return false;
+  }
+
+  let segments = playlist.segments;
+
+  // determine a few boolean values to help make the branch below easier
+  // to read
+  let appendedLastSegment = (segmentIndex === segments.length - 1);
+  let bufferedToEnd = (currentBuffered.length &&
+    segments[segments.length - 1].end <= currentBuffered.end(0));
+
+  // if we've buffered to the end of the video, we need to call endOfStream
+  // so that MediaSources can trigger the `ended` event when it runs out of
+  // buffered data instead of waiting for me
+  return playlist.endList &&
+    mediaSource.readyState === 'open' &&
+    (appendedLastSegment || bufferedToEnd);
+};
+
+/*  Turns segment byterange into a string suitable for use in
+ *  HTTP Range requests
+ */
+const byterangeStr = function(byterange) {
+  let byterangeStart;
+  let byterangeEnd;
+
+  // `byterangeEnd` is one less than `offset + length` because the HTTP range
+  // header uses inclusive ranges
+  byterangeEnd = byterange.offset + byterange.length - 1;
+  byterangeStart = byterange.offset;
+  return 'bytes=' + byterangeStart + '-' + byterangeEnd;
+};
+
+/*  Defines headers for use in the xhr request for a particular segment.
+ */
+const segmentXhrHeaders = function(segment) {
+  let headers = {};
+
+  if ('byterange' in segment) {
+    headers.Range = byterangeStr(segment.byterange);
+  }
+  return headers;
+};
+
+/**
+ * An object that manages segment loading and appending.
+ *
+ * @class SegmentLoader
+ * @param {Object} options required and optional options
+ * @extends videojs.EventTarget
+ */
+export default class SegmentLoader extends videojs.EventTarget {
+  constructor(options) {
+    super();
+    let settings;
+
+    // check pre-conditions
+    if (!options) {
+      throw new TypeError('Initialization options are required');
+    }
+    if (typeof options.currentTime !== 'function') {
+      throw new TypeError('No currentTime getter specified');
+    }
+    if (!options.mediaSource) {
+      throw new TypeError('No MediaSource specified');
+    }
+    settings = videojs.mergeOptions(videojs.options.hls, options);
+
+    // public properties
+    this.state = 'INIT';
+    this.bandwidth = settings.bandwidth;
+    this.roundTrip = NaN;
+    this.bytesReceived = 0;
+
+    // private properties
+    this.hasPlayed_ = settings.hasPlayed;
+    this.currentTime_ = settings.currentTime;
+    this.seekable_ = settings.seekable;
+    this.seeking_ = settings.seeking;
+    this.setCurrentTime_ = settings.setCurrentTime;
+    this.mediaSource_ = settings.mediaSource;
+    this.withCredentials_ = settings.withCredentials;
+    this.checkBufferTimeout_ = null;
+    this.error_ = void 0;
+    this.expired_ = 0;
+    this.timeCorrection_ = 0;
+    this.currentTimeline_ = -1;
+    this.xhr_ = null;
+    this.pendingSegment_ = null;
+    this.sourceUpdater_ = null;
+    this.hls_ = settings.hls;
+  }
+
+  /**
+   * dispose of the SegmentLoader and reset to the default state
+   */
+  dispose() {
+    this.state = 'DISPOSED';
+    this.abort_();
+    if (this.sourceUpdater_) {
+      this.sourceUpdater_.dispose();
+    }
+  }
+
+  /**
+   * abort anything that is currently doing on with the SegmentLoader
+   * and reset to a default state
+   */
+  abort() {
+    if (this.state !== 'WAITING') {
+      return;
+    }
+
+    this.abort_();
+
+    // don't wait for buffer check timeouts to begin fetching the
+    // next segment
+    if (!this.paused()) {
+      this.state = 'READY';
+      this.fillBuffer_();
+    }
+  }
+
+  /**
+   * set an error on the segment loader and null out any pending segements
+   *
+   * @param {Error} error the error to set on the SegmentLoader
+   * @return {Error} the error that was set or that is currently set
+   */
+  error(error) {
+    if (typeof error !== 'undefined') {
+      this.error_ = error;
+    }
+
+    this.pendingSegment_ = null;
+    return this.error_;
+  }
+
+  /**
+   * load a playlist and start to fill the buffer
+   */
+  load() {
+    this.monitorBuffer_();
+
+    // if we don't have a playlist yet, keep waiting for one to be
+    // specified
+    if (!this.playlist_) {
+      return;
+    }
+
+    // if we're in the middle of processing a segment already, don't
+    // kick off an additional segment request
+    if (!this.sourceUpdater_ ||
+        (this.state !== 'READY' &&
+        this.state !== 'INIT')) {
+      return;
+    }
+
+    this.state = 'READY';
+    this.fillBuffer_();
+  }
+
+  /**
+   * set a playlist on the segment loader
+   *
+   * @param {PlaylistLoader} media the playlist to set on the segment loader
+   */
+  playlist(media) {
+    this.playlist_ = media;
+    // if we were unpaused but waiting for a playlist, start
+    // buffering now
+    if (this.sourceUpdater_ &&
+        media &&
+        this.state === 'INIT' &&
+        !this.paused()) {
+      this.state = 'READY';
+      return this.fillBuffer_();
+    }
+  }
+
+  /**
+   * Prevent the loader from fetching additional segments. If there
+   * is a segment request outstanding, it will finish processing
+   * before the loader halts. A segment loader can be unpaused by
+   * calling load().
+   */
+  pause() {
+    if (this.checkBufferTimeout_) {
+      window.clearTimeout(this.checkBufferTimeout_);
+
+      this.checkBufferTimeout_ = null;
+    }
+  }
+
+  /**
+   * Returns whether the segment loader is fetching additional
+   * segments when given the opportunity. This property can be
+   * modified through calls to pause() and load().
+   */
+  paused() {
+    return this.checkBufferTimeout_ === null;
+  }
+
+  /**
+   * setter for expired time on the SegmentLoader
+   *
+   * @param {Number} expired the exired time to set
+   */
+  expired(expired) {
+    this.expired_ = expired;
+  }
+
+  /**
+   * create/set the following mimetype on the SourceBuffer through a
+   * SourceUpdater
+   *
+   * @param {String} mimeType the mime type string to use
+   */
+  mimeType(mimeType) {
+    // TODO Allow source buffers to be re-created with different mime-types
+    if (!this.sourceUpdater_) {
+      this.sourceUpdater_ = new SourceUpdater(this.mediaSource_, mimeType);
+      this.clearBuffer();
+
+      // if we were unpaused but waiting for a sourceUpdater, start
+      // buffering now
+      if (this.playlist_ &&
+          this.state === 'INIT' &&
+          !this.paused()) {
+        this.state = 'READY';
+        return this.fillBuffer_();
+      }
+    }
+  }
+
+  /**
+   * asynchronously/recursively monitor the buffer
+   *
+   * @private
+   */
+  monitorBuffer_() {
+    if (this.state === 'READY') {
+      this.fillBuffer_();
+    }
+    this.checkBufferTimeout_ = window.setTimeout(this.monitorBuffer_.bind(this),
+                                                 CHECK_BUFFER_DELAY);
+  }
+
+  /**
+   * Return the amount of a segment specified by the mediaIndex overlaps
+   * the current buffered content.
+   *
+   * @param {Object} playlist the playlist object to fetch segments from
+   * @param {Number} mediaIndex the index of the segment in the playlist
+   * @param {TimeRanges} buffered the state of the buffer
+   * @returns {Number} percentage of the segment's time range that is
+   * already in `buffered`
+   */
+  getSegmentBufferedPercent_(playlist, mediaIndex, currentTime, buffered) {
+    let segment = playlist.segments[mediaIndex];
+    let startOfSegment = duration(playlist,
+                                  playlist.mediaSequence + mediaIndex,
+                                  this.expired_);
+    let segmentRange = videojs.createTimeRanges([[
+      Math.max(currentTime, startOfSegment),
+      startOfSegment + segment.duration
+    ]]);
+
+    return Ranges.calculateBufferedPercent(segmentRange, buffered);
+  }
+
+  /**
+   * Determines what segment request should be made, given current
+   * playback state.
+   *
+   * @param {TimeRanges} buffered - the state of the buffer
+   * @param {Object} playlist - the playlist object to fetch segments from
+   * @param {Number} currentTime - the playback position in seconds
+   * @returns {Object} a segment info object that describes the
+   * request that should be made or null if no request is necessary
+   */
+  checkBuffer_(buffered, playlist, currentTime) {
+    let currentBuffered = Ranges.findRange(buffered, currentTime);
+
+    // There are times when MSE reports the first segment as starting a
+    // little after 0-time so add a fudge factor to try and fix those cases
+    // or we end up fetching the same first segment over and over
+    if (currentBuffered.length === 0 && currentTime === 0) {
+      currentBuffered = Ranges.findRange(buffered,
+                                         currentTime + Ranges.TIME_FUDGE_FACTOR);
+    }
+
+    let bufferedTime;
+    let currentBufferedEnd;
+    let timestampOffset = this.sourceUpdater_.timestampOffset();
+    let segment;
+    let mediaIndex;
+
+    if (!playlist.segments.length) {
+      return;
+    }
+
+    if (currentBuffered.length === 0) {
+      // find the segment containing currentTime
+      mediaIndex = getMediaIndexForTime(playlist,
+                                        currentTime,
+                                        this.expired_ + this.timeCorrection_);
+    } else {
+      // find the segment adjacent to the end of the current
+      // buffered region
+      currentBufferedEnd = currentBuffered.end(0);
+      bufferedTime = Math.max(0, currentBufferedEnd - currentTime);
+
+      // if the video has not yet played only, and we already have
+      // one segment downloaded do nothing
+      if (!this.hasPlayed_() && bufferedTime >= 1) {
+        return null;
+      }
+
+      // if there is plenty of content buffered, and the video has
+      // been played before relax for awhile
+      if (this.hasPlayed_() && bufferedTime >= GOAL_BUFFER_LENGTH) {
+        return null;
+      }
+      mediaIndex = getMediaIndexForTime(playlist,
+                                        currentBufferedEnd,
+                                        this.expired_ + this.timeCorrection_);
+    }
+
+    if (mediaIndex < 0 || mediaIndex === playlist.segments.length) {
+      return null;
+    }
+
+    // Sanity check the segment-index determining logic above but calcuating
+    // the percentage of the chosen segment that is buffered. If more than 90%
+    // of the segment is buffered then fetching it will likely not help in any
+    // way
+    let percentBuffered = this.getSegmentBufferedPercent_(playlist,
+                                                          mediaIndex,
+                                                          currentTime,
+                                                          buffered);
+
+    if (percentBuffered >= 90) {
+      // Retry the buffered calculation with the next segment if there is another
+      // segment after the currently selected segment
+      if (mediaIndex + 1 < playlist.segments.length) {
+        percentBuffered = this.getSegmentBufferedPercent_(playlist,
+                                                          mediaIndex + 1,
+                                                          currentTime,
+                                                          buffered);
+      }
+
+      // If both checks failed return and don't load anything
+      if (percentBuffered >= 90) {
+        return;
+      }
+
+      // Otherwise, continue with the next segment
+      mediaIndex += 1;
+    }
+
+    segment = playlist.segments[mediaIndex];
+    let startOfSegment = duration(playlist,
+                                  playlist.mediaSequence + mediaIndex,
+                                  this.expired_);
+
+    // We will need to change timestampOffset of the sourceBuffer if either of
+    // the following conditions are true:
+    // - The segment.timeline !== this.currentTimeline
+    //   (we are crossing a discontinuity somehow)
+    // - The "timestampOffset" for the start of this segment is less than
+    //   the currently set timestampOffset
+    if (segment.timeline !== this.currentTimeline_ ||
+        startOfSegment < this.sourceUpdater_.timestampOffset()) {
+      timestampOffset = startOfSegment;
+    }
+
+    return {
+      // resolve the segment URL relative to the playlist
+      uri: segment.resolvedUri,
+      // the segment's mediaIndex at the time it was requested
+      mediaIndex,
+      // the segment's playlist
+      playlist,
+      // unencrypted bytes of the segment
+      bytes: null,
+      // when a key is defined for this segment, the encrypted bytes
+      encryptedBytes: null,
+      // the state of the buffer before a segment is appended will be
+      // stored here so that the actual segment duration can be
+      // determined after it has been appended
+      buffered: null,
+      // The target timestampOffset for this segment when we append it
+      // to the source buffer
+      timestampOffset,
+      // The timeline that the segment is in
+      timeline: segment.timeline
+    };
+  }
+
+  /**
+   * abort all pending xhr requests and null any pending segements
+   *
+   * @private
+   */
+  abort_() {
+    if (this.xhr_) {
+      this.xhr_.abort();
+    }
+
+    // clear out the segment being processed
+    this.pendingSegment_ = null;
+  }
+
+  /**
+   * fill the buffer with segements unless the
+   * sourceBuffers are currently updating
+   *
+   * @private
+   */
+  fillBuffer_() {
+    if (this.sourceUpdater_.updating()) {
+      return;
+    }
+
+    // see if we need to begin loading immediately
+    let request = this.checkBuffer_(this.sourceUpdater_.buffered(),
+                                    this.playlist_,
+                                    this.currentTime_(),
+                                    this.timestampOffset_);
+
+    if (request) {
+      this.loadSegment_(request);
+    }
+  }
+
+  /**
+   * load a specific segment from a request into the buffer
+   *
+   * @private
+   */
+  loadSegment_(segmentInfo) {
+    let segment;
+    let requestTimeout;
+    let keyXhr;
+    let segmentXhr;
+    let seekable = this.seekable_();
+    let currentTime = this.currentTime_();
+    let removeToTime = 0;
+
+    // Chrome has a hard limit of 150mb of
+    // buffer and a very conservative "garbage collector"
+    // We manually clear out the old buffer to ensure
+    // we don't trigger the QuotaExceeded error
+    // on the source buffer during subsequent appends
+
+    // If we have a seekable range use that as the limit for what can be removed safely
+    // otherwise remove anything older than 1 minute before the current play head
+    if (seekable.length &&
+        seekable.start(0) > 0 &&
+        seekable.start(0) < currentTime) {
+      removeToTime = seekable.start(0);
+    } else {
+      removeToTime = currentTime - 60;
+    }
+
+    if (removeToTime > 0) {
+      this.sourceUpdater_.remove(0, removeToTime);
+    }
+
+    segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
+    // Set xhr timeout to 150% of the segment duration to allow us
+    // some time to switch renditions in the event of a catastrophic
+    // decrease in network performance or a server issue.
+    requestTimeout = (segment.duration * 1.5) * 1000;
+
+    if (segment.key) {
+      keyXhr = this.hls_.xhr({
+        uri: segment.key.resolvedUri,
+        responseType: 'arraybuffer',
+        withCredentials: this.withCredentials_,
+        timeout: requestTimeout
+      }, this.handleResponse_.bind(this));
+    }
+    this.pendingSegment_ = segmentInfo;
+    segmentXhr = this.hls_.xhr({
+      uri: segmentInfo.uri,
+      responseType: 'arraybuffer',
+      withCredentials: this.withCredentials_,
+      timeout: requestTimeout,
+      headers: segmentXhrHeaders(segment)
+    }, this.handleResponse_.bind(this));
+
+    this.xhr_ = {
+      keyXhr,
+      segmentXhr,
+      abort() {
+        if (this.segmentXhr) {
+          // Prevent error handler from running.
+          this.segmentXhr.onreadystatechange = null;
+          this.segmentXhr.abort();
+          this.segmentXhr = null;
+        }
+        if (this.keyXhr) {
+          // Prevent error handler from running.
+          this.keyXhr.onreadystatechange = null;
+          this.keyXhr.abort();
+          this.keyXhr = null;
+        }
+      }
+    };
+
+    this.state = 'WAITING';
+  }
+
+  /**
+   * triggered when a segment response is received
+   *
+   * @private
+   */
+  handleResponse_(error, request) {
+    let segmentInfo;
+    let segment;
+    let keyXhrRequest;
+    let view;
+
+    // timeout of previously aborted request
+    if (!this.xhr_ ||
+        (request !== this.xhr_.segmentXhr && request !== this.xhr_.keyXhr)) {
+      return;
+    }
+
+    segmentInfo = this.pendingSegment_;
+    segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
+
+    // if a request times out, reset bandwidth tracking
+    if (request.timedout) {
+      this.abort_();
+      this.bandwidth = 1;
+      this.roundTrip = NaN;
+      this.state = 'READY';
+      return this.trigger('progress');
+    }
+
+    // trigger an event for other errors
+    if (!request.aborted && error) {
+      // abort will clear xhr_
+      keyXhrRequest = this.xhr_.keyXhr;
+      this.abort_();
+      this.error({
+        status: request.status,
+        message: request === keyXhrRequest ?
+          'HLS key request error at URL: ' + segment.key.uri :
+          'HLS segment request error at URL: ' + segmentInfo.uri,
+        code: 2,
+        xhr: request
+      });
+      this.state = 'READY';
+      this.pause();
+      return this.trigger('error');
+    }
+
+    // stop processing if the request was aborted
+    if (!request.response) {
+      this.abort_();
+      return;
+    }
+
+    if (request === this.xhr_.segmentXhr) {
+      // the segment request is no longer outstanding
+      this.xhr_.segmentXhr = null;
+
+      // calculate the download bandwidth based on segment request
+      this.roundTrip = request.roundTripTime;
+      this.bandwidth = request.bandwidth;
+      this.bytesReceived += request.bytesReceived || 0;
+
+      if (segment.key) {
+        segmentInfo.encryptedBytes = new Uint8Array(request.response);
+      } else {
+        segmentInfo.bytes = new Uint8Array(request.response);
+      }
+    }
+
+    if (request === this.xhr_.keyXhr) {
+      keyXhrRequest = this.xhr_.segmentXhr;
+      // the key request is no longer outstanding
+      this.xhr_.keyXhr = null;
+
+      if (request.response.byteLength !== 16) {
+        this.abort_();
+        this.error({
+          status: request.status,
+          message: 'Invalid HLS key at URL: ' + segment.key.uri,
+          code: 2,
+          xhr: request
+        });
+        this.state = 'READY';
+        this.pause();
+        return this.trigger('error');
+      }
+
+      view = new DataView(request.response);
+      segment.key.bytes = new Uint32Array([
+        view.getUint32(0),
+        view.getUint32(4),
+        view.getUint32(8),
+        view.getUint32(12)
+      ]);
+
+      // if the media sequence is greater than 2^32, the IV will be incorrect
+      // assuming 10s segments, that would be about 1300 years
+      segment.key.iv = segment.key.iv || new Uint32Array([
+        0, 0, 0, segmentInfo.mediaIndex + segmentInfo.playlist.mediaSequence
+      ]);
+    }
+
+    if (!this.xhr_.segmentXhr && !this.xhr_.keyXhr) {
+      this.xhr_ = null;
+      this.processResponse_();
+    }
+  }
+
+  /**
+   * clear anything that is currently in the buffer and throw it away
+   */
+  clearBuffer() {
+    if (this.sourceUpdater_ &&
+        this.sourceUpdater_.buffered().length) {
+      this.sourceUpdater_.remove(0, Infinity);
+    }
+  }
+
+  /**
+   * Decrypt the segment that is being loaded if necessary
+   *
+   * @private
+   */
+  processResponse_() {
+    let segmentInfo;
+    let segment;
+
+    this.state = 'DECRYPTING';
+
+    segmentInfo = this.pendingSegment_;
+    segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
+
+    if (segment.key) {
+      // this is an encrypted segment
+      // incrementally decrypt the segment
+      /* eslint-disable no-new, handle-callback-err */
+      new Decrypter(segmentInfo.encryptedBytes,
+                    segment.key.bytes,
+                    segment.key.iv,
+                    (function(err, bytes) {
+                      // err always null
+                      segmentInfo.bytes = bytes;
+                      this.handleSegment_();
+                    }).bind(this));
+      /* eslint-enable */
+    } else {
+      this.handleSegment_();
+    }
+  }
+
+  /**
+   * append a decrypted segement to the SourceBuffer through a SourceUpdater
+   *
+   * @private
+   */
+  handleSegment_() {
+    let segmentInfo;
+
+    this.state = 'APPENDING';
+    segmentInfo = this.pendingSegment_;
+    segmentInfo.buffered = this.sourceUpdater_.buffered();
+    this.currentTimeline_ = segmentInfo.timeline;
+
+    if (segmentInfo.timestampOffset !== this.sourceUpdater_.timestampOffset()) {
+      this.sourceUpdater_.timestampOffset(segmentInfo.timestampOffset);
+    }
+
+    this.sourceUpdater_.appendBuffer(segmentInfo.bytes,
+                                     this.handleUpdateEnd_.bind(this));
+  }
+
+  /**
+   * callback to run when appendBuffer is finished. detects if we are
+   * in a good state to do things with the data we got, or if we need
+   * to wait for more
+   *
+   * @private
+   */
+  handleUpdateEnd_() {
+    let segmentInfo = this.pendingSegment_;
+    let currentTime = this.currentTime_();
+
+    this.pendingSegment_ = null;
+    // add segment timeline information if we're still using the
+    // same playlist
+    if (segmentInfo && segmentInfo.playlist.uri === this.playlist_.uri) {
+      this.updateTimeline_(segmentInfo);
+      this.trigger('progress');
+    }
+
+    let currentMediaIndex = segmentInfo.mediaIndex;
+
+    currentMediaIndex +=
+      segmentInfo.playlist.mediaSequence - this.playlist_.mediaSequence;
+
+    let currentBuffered = Ranges.findRange(this.sourceUpdater_.buffered(), currentTime);
+
+    // any time an update finishes and the last segment is in the
+    // buffer, end the stream. this ensures the "ended" event will
+    // fire if playback reaches that point.
+    let isEndOfStream = detectEndOfStream(segmentInfo.playlist,
+                                          this.mediaSource_,
+                                          currentMediaIndex,
+                                          currentBuffered);
+
+    if (isEndOfStream) {
+      this.mediaSource_.endOfStream();
+    }
+
+    // when seeking to the beginning of the seekable range, it's
+    // possible that imprecise timing information may cause the seek to
+    // end up earlier than the start of the range
+    // in that case, seek again
+    let seekable = this.seekable_();
+    let next = Ranges.findNextRange(this.sourceUpdater_.buffered(), currentTime);
+
+    if (this.seeking_() &&
+        currentBuffered.length === 0) {
+      if (seekable.length &&
+          currentTime < seekable.start(0)) {
+
+        if (next.length) {
+          videojs.log('tried seeking to', currentTime,
+                      'but that was too early, retrying at', next.start(0));
+          this.setCurrentTime_(next.start(0) + Ranges.TIME_FUDGE_FACTOR);
+        }
+      }
+    }
+
+    this.state = 'READY';
+
+    if (!this.paused()) {
+      this.fillBuffer_();
+    }
+  }
+
+  /**
+   * annotate the segment with any start and end time information
+   * added by the media processing
+   *
+   * @private
+   * @param {Object} segmentInfo annotate a segment with time info
+   */
+  updateTimeline_(segmentInfo) {
+    let segment;
+    let timelineUpdate;
+    let playlist = segmentInfo.playlist;
+    let currentMediaIndex = segmentInfo.mediaIndex;
+
+    currentMediaIndex += playlist.mediaSequence - this.playlist_.mediaSequence;
+    segment = playlist.segments[currentMediaIndex];
+
+    if (!segment) {
+      return;
+    }
+
+    timelineUpdate = Ranges.findSoleUncommonTimeRangesEnd(segmentInfo.buffered,
+                                                          this.sourceUpdater_.buffered());
+
+    // Update segment meta-data (duration and end-point) based on timeline
+    let timelineUpdated = updateSegmentMetadata(playlist,
+                                                currentMediaIndex,
+                                                timelineUpdate);
+
+    // the last segment append must have been entirely in the
+    // already buffered time ranges. adjust the timeCorrection
+    // offset to fetch forward until we find a segment that adds
+    // to the buffered time ranges and improves subsequent media
+    // index calculations.
+    if (!timelineUpdated) {
+      this.timeCorrection_ -= segment.duration;
+    } else {
+      this.timeCorrection_ = 0;
+    }
+  }
+}

+/**
+ * @file source-updater.js
+ */
+import videojs from 'video.js';
+
+/**
+ * A queue of callbacks to be serialized and applied when a
+ * MediaSource and its associated SourceBuffers are not in the
+ * updating state. It is used by the segment loader to update the
+ * underlying SourceBuffers when new data is loaded, for instance.
+ *
+ * @class SourceUpdater
+ * @param {MediaSource} mediaSource the MediaSource to create the
+ * SourceBuffer from
+ * @param {String} mimeType the desired MIME type of the underlying
+ * SourceBuffer
+ */
+export default class SourceUpdater {
+  constructor(mediaSource, mimeType) {
+    let createSourceBuffer = () => {
+      this.sourceBuffer_ = mediaSource.addSourceBuffer(mimeType);
+
+      // run completion handlers and process callbacks as updateend
+      // events fire
+      this.sourceBuffer_.addEventListener('updateend', () => {
+        let pendingCallback = this.pendingCallback_;
+
+        this.pendingCallback_ = null;
+
+        if (pendingCallback) {
+          pendingCallback();
+        }
+      });
+      this.sourceBuffer_.addEventListener('updateend',
+                                          this.runCallback_.bind(this));
+
+      this.runCallback_();
+    };
+
+    this.callbacks_ = [];
+    this.pendingCallback_ = null;
+    this.timestampOffset_ = 0;
+    this.mediaSource = mediaSource;
+
+    if (mediaSource.readyState === 'closed') {
+      mediaSource.addEventListener('sourceopen', createSourceBuffer);
+    } else {
+      createSourceBuffer();
+    }
+  }
+
+  /**
+   * Aborts the current segment and resets the segment parser.
+   *
+   * @param {Function} done function to call when done
+   * @see http://w3c.github.io/media-source/#widl-SourceBuffer-abort-void
+   */
+  abort(done) {
+    this.queueCallback_(() => {
+      this.sourceBuffer_.abort();
+    }, done);
+  }
+
+  /**
+   * Queue an update to append an ArrayBuffer.
+   *
+   * @param {ArrayBuffer} bytes
+   * @param {Function} done the function to call when done
+   * @see http://www.w3.org/TR/media-source/#widl-SourceBuffer-appendBuffer-void-ArrayBuffer-data
+   */
+  appendBuffer(bytes, done) {
+    this.queueCallback_(() => {
+      this.sourceBuffer_.appendBuffer(bytes);
+    }, done);
+  }
+
+  /**
+   * Indicates what TimeRanges are buffered in the managed SourceBuffer.
+   *
+   * @see http://www.w3.org/TR/media-source/#widl-SourceBuffer-buffered
+   */
+  buffered() {
+    if (!this.sourceBuffer_) {
+      return videojs.createTimeRanges();
+    }
+    return this.sourceBuffer_.buffered;
+  }
+
+  /**
+   * Queue an update to set the duration.
+   *
+   * @param {Double} duration what to set the duration to
+   * @see http://www.w3.org/TR/media-source/#widl-MediaSource-duration
+   */
+  duration(duration) {
+    this.queueCallback_(() => {
+      this.sourceBuffer_.duration = duration;
+    });
+  }
+
+  /**
+   * Queue an update to remove a time range from the buffer.
+   *
+   * @param {Number} start where to start the removal
+   * @param {Number} end where to end the removal
+   * @see http://www.w3.org/TR/media-source/#widl-SourceBuffer-remove-void-double-start-unrestricted-double-end
+   */
+  remove(start, end) {
+    this.queueCallback_(() => {
+      this.sourceBuffer_.remove(start, end);
+    });
+  }
+
+  /**
+   * wether the underlying sourceBuffer is updating or not
+   *
+   * @return {Boolean} the updating status of the SourceBuffer
+   */
+  updating() {
+    return !this.sourceBuffer_ || this.sourceBuffer_.updating;
+  }
+
+  /**
+   * Set/get the timestampoffset on the SourceBuffer
+   *
+   * @return {Number} the timestamp offset
+   */
+  timestampOffset(offset) {
+    if (typeof offset !== 'undefined') {
+      this.queueCallback_(() => {
+        this.sourceBuffer_.timestampOffset = offset;
+      });
+      this.timestampOffset_ = offset;
+    }
+    return this.timestampOffset_;
+  }
+
+  /**
+   * que a callback to run
+   */
+  queueCallback_(callback, done) {
+    this.callbacks_.push([callback.bind(this), done]);
+    this.runCallback_();
+  }
+
+  /**
+   * run a queued callback
+   */
+  runCallback_() {
+    let callbacks;
+
+    if (this.sourceBuffer_ &&
+        !this.sourceBuffer_.updating &&
+        this.callbacks_.length) {
+      callbacks = this.callbacks_.shift();
+      this.pendingCallback_ = callbacks[1];
+      callbacks[0]();
+    }
+  }
+
+  /**
+   * dispose of the source updater and the underlying sourceBuffer
+   */
+  dispose() {
+    if (this.sourceBuffer_ && this.mediaSource.readyState === 'open') {
+      this.sourceBuffer_.abort();
+    }
+  }
+}

 /**
 /**
+ * @file stream.js
+ */
+/**
  * A lightweight readable stream implemention that handles event dispatching.
  * A lightweight readable stream implemention that handles event dispatching.
+ *
+ * @class Stream
  */
  */
 export default class Stream {
 export default class Stream {
   constructor() {
   constructor() {
@@ -8,8 +13,9 @@ export default class Stream {
 
 
   /**
   /**
    * Add a listener for a specified event type.
    * 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
+   *
+   * @param {String} type the event name
+   * @param {Function} listener the callback to be invoked when an event of
    * the specified type occurs
    * the specified type occurs
    */
    */
   on(type, listener) {
   on(type, listener) {
@@ -21,9 +27,11 @@ export default class Stream {
 
 
   /**
   /**
    * Remove a listener for a specified event type.
    * Remove a listener for a specified event type.
-   * @param type {string} the event name
-   * @param listener {function} a function previously registered for this
+   *
+   * @param {String} type the event name
+   * @param {Function} listener  a function previously registered for this
    * type of event through `on`
    * type of event through `on`
+   * @return {Boolean} if we could turn it off or not
    */
    */
   off(type, listener) {
   off(type, listener) {
     let index;
     let index;
@@ -39,7 +47,8 @@ export default class Stream {
   /**
   /**
    * Trigger an event of the specified type on this stream. Any additional
    * Trigger an event of the specified type on this stream. Any additional
    * arguments to this function are passed as parameters to event listeners.
    * arguments to this function are passed as parameters to event listeners.
-   * @param type {string} the event name
+   *
+   * @param {String} type the event name
    */
    */
   trigger(type) {
   trigger(type) {
     let callbacks;
     let callbacks;
@@ -79,7 +88,8 @@ export default class Stream {
    * Forwards all `data` events on this stream to the destination stream. The
    * Forwards all `data` events on this stream to the destination stream. The
    * destination stream should provide a method `push` to receive the data
    * destination stream should provide a method `push` to receive the data
    * events as they arrive.
    * events as they arrive.
-   * @param destination {stream} the stream that will receive all `data` events
+   *
+   * @param {Stream} destination the stream that will receive all `data` events
    * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
    * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
    */
    */
   pipe(destination) {
   pipe(destination) {

 /**
 /**
- * videojs-hls
+ * @file videojs-contrib-hls.js
+ *
  * The main file for the HLS project.
  * The main file for the HLS project.
  * License: https://github.com/videojs/videojs-contrib-hls/blob/master/LICENSE
  * License: https://github.com/videojs/videojs-contrib-hls/blob/master/LICENSE
  */
  */
+import document from 'global/document';
 import PlaylistLoader from './playlist-loader';
 import PlaylistLoader from './playlist-loader';
 import Playlist from './playlist';
 import Playlist from './playlist';
 import xhrFactory from './xhr';
 import xhrFactory from './xhr';
@@ -11,7 +13,34 @@ import utils from './bin-utils';
 import {MediaSource, URL} from 'videojs-contrib-media-sources';
 import {MediaSource, URL} from 'videojs-contrib-media-sources';
 import m3u8 from './m3u8';
 import m3u8 from './m3u8';
 import videojs from 'video.js';
 import videojs from 'video.js';
-import resolveUrl from './resolve-url';
+import MasterPlaylistController from './master-playlist-controller';
+
+/**
+ * determine if an object a is differnt from
+ * and object b. both only having one dimensional
+ * properties
+ *
+ * @param {Object} a object one
+ * @param {Object} b object two
+ * @return {Boolean} if the object has changed or not
+ */
+const objectChanged = function(a, b) {
+  if (typeof a !== typeof b) {
+    return true;
+  }
+  // if we have a different number of elements
+  // something has changed
+  if (Object.keys(a).length !== Object.keys(b).length) {
+    return true;
+  }
+
+  for (let prop in a) {
+    if (!b[prop] || a[prop] !== b[prop]) {
+      return true;
+    }
+  }
+  return false;
+};
 
 
 const Hls = {
 const Hls = {
   PlaylistLoader,
   PlaylistLoader,
@@ -26,183 +55,19 @@ const Hls = {
 // the desired length of video to maintain in the buffer, in seconds
 // the desired length of video to maintain in the buffer, in seconds
 Hls.GOAL_BUFFER_LENGTH = 30;
 Hls.GOAL_BUFFER_LENGTH = 30;
 
 
-// HLS is a source handler, not a tech. Make sure attempts to use it
-// as one do not cause exceptions.
-Hls.canPlaySource = function() {
-  return videojs.log.warn('HLS is no longer a tech. Please remove it from ' +
-                          'your player\'s techOrder.');
-};
-
-// Search for a likely end time for the segment that was just appened
-// based on the state of the `buffered` property before and after the
-// append.
-// If we found only one such uncommon end-point return it.
-Hls.findSoleUncommonTimeRangesEnd_ = function(original, update) {
-  let i;
-  let start;
-  let end;
-  let result = [];
-  let edges = [];
-
-  // In order to qualify as a possible candidate, the end point must:
-  //  1) Not have already existed in the `original` ranges
-  //  2) Not result from the shrinking of a range that already existed
-  //     in the `original` ranges
-  //  3) Not be contained inside of a range that existed in `original`
-  let overlapsCurrentEnd = function(span) {
-    return (span[0] <= end && span[1] >= end);
-  };
-
-  if (original) {
-    // Save all the edges in the `original` TimeRanges object
-    for (i = 0; i < original.length; i++) {
-      start = original.start(i);
-      end = original.end(i);
-
-      edges.push([start, end]);
-    }
-  }
-
-  if (update) {
-    // Save any end-points in `update` that are not in the `original`
-    // TimeRanges object
-    for (i = 0; i < update.length; i++) {
-      start = update.start(i);
-      end = update.end(i);
-
-      if (edges.some(overlapsCurrentEnd)) {
-        continue;
-      }
-
-      // at this point it must be a unique non-shrinking end edge
-      result.push(end);
-    }
-  }
-
-  // we err on the side of caution and return null if didn't find
-  // exactly *one* differing end edge in the search above
-  if (result.length !== 1) {
-    return null;
-  }
-
-  return result[0];
-};
-
-/**
- * Whether the browser has built-in HLS support.
- */
-Hls.supportsNativeHls = (function() {
-  let video = document.createElement('video');
-  let xMpegUrl;
-  let vndMpeg;
-
-  // native HLS is definitely not supported if HTML5 video isn't
-  if (!videojs.getComponent('Html5').isSupported()) {
-    return false;
-  }
-
-  xMpegUrl = video.canPlayType('application/x-mpegURL');
-  vndMpeg = video.canPlayType('application/vnd.apple.mpegURL');
-  return (/probably|maybe/).test(xMpegUrl) ||
-    (/probably|maybe/).test(vndMpeg);
-}());
-
-// HLS is a source handler, not a tech. Make sure attempts to use it
-// as one do not cause exceptions.
-Hls.isSupported = function() {
-  return videojs.log.warn('HLS is no longer a tech. Please remove it from ' +
-                          'your player\'s techOrder.');
-};
-
-/**
- * A comparator function to sort two playlist object by bandwidth.
- * @param left {object} a media playlist object
- * @param right {object} a media playlist object
- * @return {number} Greater than zero if the bandwidth attribute of
- * left is greater than the corresponding attribute of right. Less
- * than zero if the bandwidth of right is greater than left and
- * exactly zero if the two are equal.
- */
-Hls.comparePlaylistBandwidth = function(left, right) {
-  let leftBandwidth;
-  let rightBandwidth;
-
-  if (left.attributes && left.attributes.BANDWIDTH) {
-    leftBandwidth = left.attributes.BANDWIDTH;
-  }
-  leftBandwidth = leftBandwidth || window.Number.MAX_VALUE;
-  if (right.attributes && right.attributes.BANDWIDTH) {
-    rightBandwidth = right.attributes.BANDWIDTH;
-  }
-  rightBandwidth = rightBandwidth || window.Number.MAX_VALUE;
-
-  return leftBandwidth - rightBandwidth;
-};
-
-/**
- * A comparator function to sort two playlist object by resolution (width).
- * @param left {object} a media playlist object
- * @param right {object} a media playlist object
- * @return {number} Greater than zero if the resolution.width attribute of
- * left is greater than the corresponding attribute of right. Less
- * than zero if the resolution.width of right is greater than left and
- * exactly zero if the two are equal.
- */
-Hls.comparePlaylistResolution = function(left, right) {
-  let leftWidth;
-  let rightWidth;
-
-  if (left.attributes &&
-      left.attributes.RESOLUTION &&
-      left.attributes.RESOLUTION.width) {
-    leftWidth = left.attributes.RESOLUTION.width;
-  }
-
-  leftWidth = leftWidth || window.Number.MAX_VALUE;
-
-  if (right.attributes &&
-      right.attributes.RESOLUTION &&
-      right.attributes.RESOLUTION.width) {
-    rightWidth = right.attributes.RESOLUTION.width;
-  }
-
-  rightWidth = rightWidth || window.Number.MAX_VALUE;
-
-  // NOTE - Fallback to bandwidth sort as appropriate in cases where multiple renditions
-  // have the same media dimensions/ resolution
-  if (leftWidth === rightWidth &&
-      left.attributes.BANDWIDTH &&
-      right.attributes.BANDWIDTH) {
-    return left.attributes.BANDWIDTH - right.attributes.BANDWIDTH;
-  }
-  return leftWidth - rightWidth;
-};
-
 // A fudge factor to apply to advertised playlist bitrates to account for
 // A fudge factor to apply to advertised playlist bitrates to account for
 // temporary flucations in client bandwidth
 // temporary flucations in client bandwidth
-const bandwidthVariance = 1.2;
-
-// 5 minute blacklist
-const blacklistDuration = 5 * 60 * 1000;
-
-// Fudge factor to account for TimeRanges rounding
-const TIME_FUDGE_FACTOR = 1 / 30;
-const Component = videojs.getComponent('Component');
-
-// The amount of time to wait between checking the state of the buffer
-const bufferCheckInterval = 500;
-
-// returns true if a key has failed to download within a certain amount of retries
-const keyFailed = function(key) {
-  return key.retries && key.retries >= 2;
-};
+const BANDWIDTH_VARIANCE = 1.2;
 
 
 /**
 /**
  * Returns the CSS value for the specified property on an element
  * Returns the CSS value for the specified property on an element
  * using `getComputedStyle`. Firefox has a long-standing issue where
  * using `getComputedStyle`. Firefox has a long-standing issue where
  * getComputedStyle() may return null when running in an iframe with
  * getComputedStyle() may return null when running in an iframe with
  * `display: none`.
  * `display: none`.
+ *
  * @see https://bugzilla.mozilla.org/show_bug.cgi?id=548397
  * @see https://bugzilla.mozilla.org/show_bug.cgi?id=548397
+ * @param {HTMLElement} el the htmlelement to work on
+ * @param {string} the proprety to get the style for
  */
  */
 const safeGetComputedStyle = function(el, property) {
 const safeGetComputedStyle = function(el, property) {
   let result;
   let result;
@@ -220,137 +85,195 @@ const safeGetComputedStyle = function(el, property) {
 };
 };
 
 
 /**
 /**
- * Updates segment with information about its end-point in time and, optionally,
- * the segment duration if we have enough information to determine a segment duration
- * accurately.
- * @param playlist {object} a media playlist object
- * @param segmentIndex {number} the index of segment we last appended
- * @param segmentEnd {number} the known of the segment referenced by segmentIndex
+ * Chooses the appropriate media playlist based on the current
+ * bandwidth estimate and the player size.
+ *
+ * @return {Playlist} the highest bitrate playlist less than the currently detected
+ * bandwidth, accounting for some amount of bandwidth variance
  */
  */
-const updateSegmentMetadata = function(playlist, segmentIndex, segmentEnd) {
-  if (!playlist) {
-    return;
-  }
+Hls.STANDARD_PLAYLIST_SELECTOR = function() {
+  let effectiveBitrate;
+  let sortedPlaylists = this.playlists.master.playlists.slice();
+  let bandwidthPlaylists = [];
+  let now = +new Date();
+  let i;
+  let variant;
+  let bandwidthBestVariant;
+  let resolutionPlusOne;
+  let resolutionPlusOneAttribute;
+  let resolutionBestVariant;
+  let width;
+  let height;
+
+  sortedPlaylists.sort(Hls.comparePlaylistBandwidth);
+
+  // filter out any playlists that have been excluded due to
+  // incompatible configurations or playback errors
+  sortedPlaylists = sortedPlaylists.filter((localVariant) => {
+    if (typeof localVariant.excludeUntil !== 'undefined') {
+      return now >= localVariant.excludeUntil;
+    }
+    return true;
+  });
+
+  // filter out any variant that has greater effective bitrate
+  // than the current estimated bandwidth
+  i = sortedPlaylists.length;
+  while (i--) {
+    variant = sortedPlaylists[i];
+
+    // ignore playlists without bandwidth information
+    if (!variant.attributes || !variant.attributes.BANDWIDTH) {
+      continue;
+    }
 
 
-  let segment = playlist.segments[segmentIndex];
-  let previousSegment = playlist.segments[segmentIndex - 1];
+    effectiveBitrate = variant.attributes.BANDWIDTH * BANDWIDTH_VARIANCE;
 
 
-  if (segmentEnd && segment) {
-    segment.end = segmentEnd;
+    if (effectiveBitrate < this.bandwidth) {
+      bandwidthPlaylists.push(variant);
 
 
-    // fix up segment durations based on segment end data
-    if (!previousSegment) {
-      // first segment is always has a start time of 0 making its duration
-      // equal to the segment end
-      segment.duration = segment.end;
-    } else if (previousSegment.end) {
-      segment.duration = segment.end - previousSegment.end;
+      // since the playlists are sorted in ascending order by
+      // bandwidth, the first viable variant is the best
+      if (!bandwidthBestVariant) {
+        bandwidthBestVariant = variant;
+      }
     }
     }
   }
   }
-};
 
 
-/**
- * Determines if we should call endOfStream on the media source based on the state
- * of the buffer or if appened segment was the final segment in the playlist.
- * @param playlist {object} a media playlist object
- * @param mediaSource {object} the MediaSource object
- * @param segmentIndex {number} the index of segment we last appended
- * @param currentBuffered {object} the buffered region that currentTime resides in
- * @return {boolean} whether the calling function should call endOfStream on the MediaSource
- */
-const detectEndOfStream = function(playlist, mediaSource, segmentIndex, currentBuffered) {
-  if (!playlist) {
-    return false;
-  }
+  i = bandwidthPlaylists.length;
 
 
-  let segments = playlist.segments;
+  // sort variants by resolution
+  bandwidthPlaylists.sort(Hls.comparePlaylistResolution);
 
 
-  // determine a few boolean values to help make the branch below easier
-  // to read
-  let appendedLastSegment = (segmentIndex === segments.length - 1);
-  let bufferedToEnd = (currentBuffered.length &&
-    segments[segments.length - 1].end <= currentBuffered.end(0));
+  // forget our old variant from above,
+  // or we might choose that in high-bandwidth scenarios
+  // (this could be the lowest bitrate rendition as  we go through all of them above)
+  variant = null;
 
 
-  // if we've buffered to the end of the video, we need to call endOfStream
-  // so that MediaSources can trigger the `ended` event when it runs out of
-  // buffered data instead of waiting for me
-  return playlist.endList &&
-    mediaSource.readyState === 'open' &&
-    (appendedLastSegment || bufferedToEnd);
-};
+  width = parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10);
+  height = parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10);
 
 
-const parseCodecs = function(codecs) {
-  let result = {
-    codecCount: 0,
-    videoCodec: null,
-    audioProfile: null
-  };
+  // iterate through the bandwidth-filtered playlists and find
+  // best rendition by player dimension
+  while (i--) {
+    variant = bandwidthPlaylists[i];
 
 
-  result.codecCount = codecs.split(',').length;
-  result.codecCount = result.codecCount || 2;
+    // ignore playlists without resolution information
+    if (!variant.attributes ||
+        !variant.attributes.RESOLUTION ||
+        !variant.attributes.RESOLUTION.width ||
+        !variant.attributes.RESOLUTION.height) {
+      continue;
+    }
+
+    // since the playlists are sorted, the first variant that has
+    // dimensions less than or equal to the player size is the best
+    let variantResolution = variant.attributes.RESOLUTION;
 
 
-  // parse the video codec but ignore the version
-  result.videoCodec = (/(^|\s|,)+(avc1)[^ ,]*/i).exec(codecs);
-  result.videoCodec = result.videoCodec && result.videoCodec[2];
+    if (variantResolution.width === width &&
+        variantResolution.height === height) {
+      // if we have the exact resolution as the player use it
+      resolutionPlusOne = null;
+      resolutionBestVariant = variant;
+      break;
+    } else if (variantResolution.width < width &&
+               variantResolution.height < height) {
+      // if both dimensions are less than the player use the
+      // previous (next-largest) variant
+      break;
+    } else if (!resolutionPlusOne ||
+               (variantResolution.width < resolutionPlusOneAttribute.width &&
+                variantResolution.height < resolutionPlusOneAttribute.height)) {
+      // If we still haven't found a good match keep a
+      // reference to the previous variant for the next loop
+      // iteration
 
 
-  // parse the last field of the audio codec
-  result.audioProfile = (/(^|\s|,)+mp4a.\d+\.(\d+)/i).exec(codecs);
-  result.audioProfile = result.audioProfile && result.audioProfile[2];
+      // By only saving variants if they are smaller than the
+      // previously saved variant, we ensure that we also pick
+      // the highest bandwidth variant that is just-larger-than
+      // the video player
+      resolutionPlusOne = variant;
+      resolutionPlusOneAttribute = resolutionPlusOne.attributes.RESOLUTION;
+    }
+  }
 
 
-  return result;
+  // fallback chain of variants
+  return resolutionPlusOne ||
+    resolutionBestVariant ||
+    bandwidthBestVariant ||
+    sortedPlaylists[0];
 };
 };
 
 
-const filterBufferedRanges = function(predicate) {
-  return function(time) {
-    let i;
-    let ranges = [];
-    let tech = this.tech_;
-
-    // !!The order of the next two assignments is important!!
-    // `currentTime` must be equal-to or greater-than the start of the
-    // buffered range. Flash executes out-of-process so, every value can
-    // change behind the scenes from line-to-line. By reading `currentTime`
-    // after `buffered`, we ensure that it is always a current or later
-    // value during playback.
-    let buffered = tech.buffered();
-
-    if (typeof time === 'undefined') {
-      time = tech.currentTime();
-    }
+// HLS is a source handler, not a tech. Make sure attempts to use it
+// as one do not cause exceptions.
+Hls.canPlaySource = function() {
+  return videojs.log.warn('HLS is no longer a tech. Please remove it from ' +
+                          'your player\'s techOrder.');
+};
 
 
-    // IE 11 has a bug where it will report a the video as fully buffered
-    // before any data has been loaded. This is a work around where we
-    // report a fully empty buffer until SourceBuffers have been created
-    // which is after a segment has been loaded and transmuxed.
-    if (!this.mediaSource ||
-        (this.mediaSource.mediaSource_ &&
-        !this.mediaSource.mediaSource_.sourceBuffers.length)) {
-      return videojs.createTimeRanges([]);
-    }
+/**
+ * Whether the browser has built-in HLS support.
+ */
+Hls.supportsNativeHls = (function() {
+  let video = document.createElement('video');
 
 
-    if (buffered && buffered.length) {
-      // Search for a range containing the play-head
-      for (i = 0; i < buffered.length; i++) {
-        if (predicate(buffered.start(i), buffered.end(i), time)) {
-          ranges.push([buffered.start(i), buffered.end(i)]);
-        }
-      }
-    }
+  // native HLS is definitely not supported if HTML5 video isn't
+  if (!videojs.getComponent('Html5').isSupported()) {
+    return false;
+  }
 
 
-    return videojs.createTimeRanges(ranges);
-  };
+  // HLS manifests can go by many mime-types
+  let canPlay = [
+    // Apple santioned
+    'application/vnd.apple.mpegurl',
+    // Apple sanctioned for backwards compatibility
+    'audio/mpegurl',
+    // Very common
+    'audio/x-mpegurl',
+    // Very common
+    'application/x-mpegurl',
+    // Included for completeness
+    'video/x-mpegurl',
+    'video/mpegurl',
+    'application/mpegurl'
+  ];
+
+  return canPlay.some(function(canItPlay) {
+    return (/maybe|probably/i).test(video.canPlayType(canItPlay));
+  });
+}());
+
+/**
+ * HLS is a source handler, not a tech. Make sure attempts to use it
+ * as one do not cause exceptions.
+ */
+Hls.isSupported = function() {
+  return videojs.log.warn('HLS is no longer a tech. Please remove it from ' +
+                          'your player\'s techOrder.');
 };
 };
 
 
-export default class HlsHandler extends Component {
-  constructor(tech, options) {
+const Component = videojs.getComponent('Component');
+
+/**
+ * The Hls Handler object, where we orchestrate all of the parts
+ * of HLS to interact with video.js
+ *
+ * @class HlsHandler
+ * @extends videojs.Component
+ * @param {Object} source the soruce object
+ * @param {Tech} tech the parent tech object
+ * @param {Object} options optional and required options
+ */
+class HlsHandler extends Component {
+  constructor(source, tech, options) {
     super(tech);
     super(tech);
-    let _player;
 
 
     // tech.player() is deprecated but setup a reference to HLS for
     // tech.player() is deprecated but setup a reference to HLS for
     // backwards-compatibility
     // backwards-compatibility
     if (tech.options_ && tech.options_.playerId) {
     if (tech.options_ && tech.options_.playerId) {
-      _player = videojs(tech.options_.playerId);
-      if (!_player.hls) {
+      let _player = videojs(tech.options_.playerId);
+
+      if (!_player.hasOwnProperty('hls')) {
         Object.defineProperty(_player, 'hls', {
         Object.defineProperty(_player, 'hls', {
           get: () => {
           get: () => {
             videojs.log.warn('player.hls is deprecated. Use player.tech.hls instead.');
             videojs.log.warn('player.hls is deprecated. Use player.tech.hls instead.');
@@ -359,1188 +282,228 @@ export default class HlsHandler extends Component {
         });
         });
       }
       }
     }
     }
+
+    this.options_ = videojs.mergeOptions(videojs.options.hls || {}, options.hls);
     this.tech_ = tech;
     this.tech_ = tech;
-    this.source_ = options.source;
-    this.mode_ = options.mode;
-    // the segment info object for a segment that is in the process of
-    // being downloaded or processed
-    this.pendingSegment_ = null;
+    this.source_ = source;
 
 
     // start playlist selection at a reasonable bandwidth for
     // start playlist selection at a reasonable bandwidth for
     // broadband internet
     // broadband internet
     // 0.5 Mbps
     // 0.5 Mbps
-    this.bandwidth = options.bandwidth || 4194304;
+    this.bandwidth = this.options_.bandwidth || 4194304;
     this.bytesReceived = 0;
     this.bytesReceived = 0;
 
 
-    // loadingState_ tracks how far along the buffering process we
-    // have been given permission to proceed. There are three possible
-    // values:
-    // - none: do not load playlists or segments
-    // - meta: load playlists but not segments
-    // - segments: load everything
-    this.loadingState_ = 'none';
-    if (this.tech_.preload() !== 'none') {
-      this.loadingState_ = 'meta';
-    }
+    // listen for fullscreenchange events for this player so that we
+    // can adjust our quality selection quickly
+    this.on(document, [
+      'fullscreenchange', 'webkitfullscreenchange',
+      'mozfullscreenchange', 'MSFullscreenChange'
+    ], (event) => {
+      let fullscreenElement = document.fullscreenElement ||
+          document.webkitFullscreenElement ||
+          document.mozFullScreenElement ||
+          document.msFullscreenElement;
 
 
-    // periodically check if new data needs to be downloaded or
-    // buffered data should be appended to the source buffer
-    this.startCheckingBuffer_();
+      if (fullscreenElement && fullscreenElement.contains(this.tech_.el())) {
+        this.masterPlaylistController_.fastQualityChange_();
+      }
+    });
 
 
     this.on(this.tech_, 'seeking', function() {
     this.on(this.tech_, 'seeking', function() {
       this.setCurrentTime(this.tech_.currentTime());
       this.setCurrentTime(this.tech_.currentTime());
     });
     });
     this.on(this.tech_, 'error', function() {
     this.on(this.tech_, 'error', function() {
-      this.stopCheckingBuffer_();
+      if (this.masterPlaylistController_) {
+        this.masterPlaylistController_.pauseLoading();
+      }
     });
     });
 
 
+    this.audioTrackChange_ = () => {
+      this.masterPlaylistController_.useAudio();
+    };
+
     this.on(this.tech_, 'play', this.play);
     this.on(this.tech_, 'play', this.play);
   }
   }
-  src(src) {
-    let oldMediaPlaylist;
 
 
+  /**
+   * called when player.src gets called, handle a new source
+   *
+   * @param {Object} src the source object to handle
+   */
+  src(src) {
     // do nothing if the src is falsey
     // do nothing if the src is falsey
     if (!src) {
     if (!src) {
       return;
       return;
     }
     }
 
 
-    this.mediaSource = new videojs.MediaSource({ mode: this.mode_ });
-
-    // load the MediaSource into the player
-    this.mediaSource.addEventListener('sourceopen', this.handleSourceOpen.bind(this));
-
-    this.options_ = {};
-    if (typeof this.source_.withCredentials !== 'undefined') {
-      this.options_.withCredentials = this.source_.withCredentials;
-    } else if (videojs.options.hls) {
-      this.options_.withCredentials = videojs.options.hls.withCredentials;
-    }
-    this.playlists = new Hls.PlaylistLoader(this.source_.src,
-                                            this.tech_.hls,
-                                            this.options_.withCredentials);
-
-    this.tech_.one('canplay', this.setupFirstPlay.bind(this));
-
-    this.playlists.on('loadedmetadata', () => {
-      oldMediaPlaylist = this.playlists.media();
-
-      // if this isn't a live video and preload permits, start
-      // downloading segments
-      if (oldMediaPlaylist.endList &&
-          this.tech_.preload() !== 'metadata' &&
-          this.tech_.preload() !== 'none') {
-        this.loadingState_ = 'segments';
+    ['withCredentials', 'bandwidth'].forEach((option) => {
+      if (typeof this.source_[option] !== 'undefined') {
+        this.options_[option] = this.source_[option];
       }
       }
-
-      this.setupSourceBuffer_();
-      this.setupFirstPlay();
-      this.fillBuffer();
-      this.tech_.trigger('loadedmetadata');
     });
     });
-
-    this.playlists.on('error', () => {
-      this.blacklistCurrentPlaylist_(this.playlists.error);
+    this.options_.url = this.source_.src;
+    this.options_.tech = this.tech_;
+    this.options_.externHls = Hls;
+    this.options_.bandwidth = this.bandwidth;
+    this.masterPlaylistController_ = new MasterPlaylistController(this.options_);
+    // `this` in selectPlaylist should be the HlsHandler for backwards
+    // compatibility with < v2
+    this.masterPlaylistController_.selectPlaylist =
+      Hls.STANDARD_PLAYLIST_SELECTOR.bind(this);
+
+    // re-expose some internal objects for backwards compatibility with < v2
+    this.playlists = this.masterPlaylistController_.masterPlaylistLoader_;
+    this.mediaSource = this.masterPlaylistController_.mediaSource;
+
+    // Proxy assignment of some properties to the master playlist
+    // controller. Using a custom property for backwards compatibility
+    // with < v2
+    Object.defineProperties(this, {
+      selectPlaylist: {
+        get() {
+          return this.masterPlaylistController_.selectPlaylist;
+        },
+        set(selectPlaylist) {
+          this.masterPlaylistController_.selectPlaylist = selectPlaylist.bind(this);
+        }
+      },
+      bandwidth: {
+        get() {
+          return this.masterPlaylistController_.mainSegmentLoader_.bandwidth;
+        },
+        set(bandwidth) {
+          this.masterPlaylistController_.mainSegmentLoader_.bandwidth = bandwidth;
+        }
+      }
     });
     });
 
 
-    this.playlists.on('loadedplaylist', () => {
-      let updatedPlaylist = this.playlists.media();
-      let seekable;
+    this.tech_.one('canplay',
+      this.masterPlaylistController_.setupFirstPlay.bind(this.masterPlaylistController_));
+
+    this.masterPlaylistController_.on('sourceopen', () => {
+      this.tech_.audioTracks().addEventListener('change', this.audioTrackChange_);
+    });
 
 
-      if (!updatedPlaylist) {
-        // select the initial variant
-        this.playlists.media(this.selectPlaylist());
+    this.masterPlaylistController_.on('audioinfo', (e) => {
+      if (!videojs.browser.IS_FIREFOX ||
+          !this.audioInfo_ ||
+          !objectChanged(this.audioInfo_, e.info)) {
+        this.audioInfo_ = e.info;
         return;
         return;
       }
       }
 
 
-      this.updateDuration(this.playlists.media());
+      let error = 'had different audio properties (channels, sample rate, etc.) ' +
+                  'or changed in some other way.  This behavior is currently ' +
+                  'unsupported in Firefox due to an issue: \n\n' +
+                  'https://bugzilla.mozilla.org/show_bug.cgi?id=1247138\n\n';
+
+      let enabledTrack;
+      let defaultTrack;
+
+      this.masterPlaylistController_.audioTracks_.forEach((t) => {
+        if (!defaultTrack && t.default) {
+          defaultTrack = t;
+        }
+
+        if (!enabledTrack && t.enabled) {
+          enabledTrack = t;
+        }
+      });
 
 
-      // update seekable
-      seekable = this.seekable();
-      if (this.duration() === Infinity &&
-          seekable.length !== 0) {
-        this.mediaSource.addSeekableRange_(seekable.start(0), seekable.end(0));
+      // they did not switch audiotracks
+      // blacklist the current playlist
+      if (!enabledTrack.getLoader(this.activeAudioGroup_())) {
+        error = `The rendition that we tried to switch to ${error}` +
+                'Unfortunately that means we will have to blacklist ' +
+                'the current playlist and switch to another. Sorry!';
+        this.masterPlaylistController_.blacklistCurrentPlaylist();
+      } else {
+        error = `The audio track '${enabledTrack.label}' that we tried to ` +
+                `switch to ${error} Unfortunately this means we will have to ` +
+                `return you to the main track '${defaultTrack.label}'. Sorry!`;
+        defaultTrack.enabled = true;
+        this.tech_.audioTracks().removeTrack(enabledTrack);
       }
       }
 
 
-      oldMediaPlaylist = updatedPlaylist;
+      videojs.log.warn(error);
+      this.masterPlaylistController_.useAudio();
     });
     });
-
-    this.playlists.on('mediachange', () => {
-      this.tech_.trigger({
-        type: 'mediachange',
-        bubbles: true
+    this.masterPlaylistController_.on('selectedinitialmedia', () => {
+      // clear current audioTracks
+      this.tech_.clearTracks('audio');
+      this.masterPlaylistController_.audioTracks_.forEach((track) => {
+        this.tech_.audioTracks().addTrack(track);
       });
       });
     });
     });
 
 
+    // the bandwidth of the primary segment loader is our best
+    // estimate of overall bandwidth
+    this.on(this.masterPlaylistController_, 'progress', function() {
+      this.bandwidth = this.masterPlaylistController_.mainSegmentLoader_.bandwidth;
+      this.tech_.trigger('progress');
+    });
+
     // do nothing if the tech has been disposed already
     // do nothing if the tech has been disposed already
     // this can occur if someone sets the src in player.ready(), for instance
     // this can occur if someone sets the src in player.ready(), for instance
     if (!this.tech_.el()) {
     if (!this.tech_.el()) {
       return;
       return;
     }
     }
 
 
-    this.tech_.src(videojs.URL.createObjectURL(this.mediaSource));
-  }
-  handleSourceOpen() {
-    // Only attempt to create the source buffer if none already exist.
-    // handleSourceOpen is also called when we are "re-opening" a source buffer
-    // after `endOfStream` has been called (in response to a seek for instance)
-    if (!this.sourceBuffer) {
-      this.setupSourceBuffer_();
-    }
-
-    // if autoplay is enabled, begin playback. This is duplicative of
-    // code in video.js but is required because play() must be invoked
-    // *after* the media source has opened.
-    // NOTE: moving this invocation of play() after
-    // sourceBuffer.appendBuffer() below caused live streams with
-    // autoplay to stall
-    if (this.tech_.autoplay()) {
-      this.play();
-    }
+    this.tech_.src(videojs.URL.createObjectURL(
+      this.masterPlaylistController_.mediaSource));
   }
   }
 
 
   /**
   /**
-   * Blacklist playlists that are known to be codec or
-   * stream-incompatible with the SourceBuffer configuration. For
-   * instance, Media Source Extensions would cause the video element to
-   * stall waiting for video data if you switched from a variant with
-   * video and audio to an audio-only one.
+   * a helper for grabbing the active audio group from MasterPlaylistController
    *
    *
-   * @param media {object} a media playlist compatible with the current
-   * set of SourceBuffers. Variants in the current master playlist that
-   * do not appear to have compatible codec or stream configurations
-   * will be excluded from the default playlist selection algorithm
-   * indefinitely.
+   * @private
    */
    */
-  excludeIncompatibleVariants_(media) {
-    let master = this.playlists.master;
-    let codecCount = 2;
-    let videoCodec = null;
-    let audioProfile = null;
-    let codecs;
-
-    if (media.attributes && media.attributes.CODECS) {
-      codecs = parseCodecs(media.attributes.CODECS);
-      videoCodec = codecs.videoCodec;
-      audioProfile = codecs.audioProfile;
-      codecCount = codecs.codecCount;
-    }
-    master.playlists.forEach(function(variant) {
-      let variantCodecs = {
-        codecCount: 2,
-        videoCodec: null,
-        audioProfile: null
-      };
-
-      if (variant.attributes && variant.attributes.CODECS) {
-        variantCodecs = parseCodecs(variant.attributes.CODECS);
-      }
-
-      // if the streams differ in the presence or absence of audio or
-      // video, they are incompatible
-      if (variantCodecs.codecCount !== codecCount) {
-        variant.excludeUntil = Infinity;
-      }
-
-      // if h.264 is specified on the current playlist, some flavor of
-      // it must be specified on all compatible variants
-      if (variantCodecs.videoCodec !== videoCodec) {
-        variant.excludeUntil = Infinity;
-      }
-      // HE-AAC ("mp4a.40.5") is incompatible with all other versions of
-      // AAC audio in Chrome 46. Don't mix the two.
-      if ((variantCodecs.audioProfile === '5' && audioProfile !== '5') ||
-          (audioProfile === '5' && variantCodecs.audioProfile !== '5')) {
-        variant.excludeUntil = Infinity;
-      }
-    });
+  activeAudioGroup_() {
+    return this.masterPlaylistController_.activeAudioGroup();
   }
   }
 
 
-  setupSourceBuffer_() {
-    let media = this.playlists.media();
-    let mimeType;
-
-    // wait until a media playlist is available and the Media Source is
-    // attached
-    if (!media || this.mediaSource.readyState !== 'open') {
-      return;
-    }
-
-    // if the codecs were explicitly specified, pass them along to the
-    // source buffer
-    mimeType = 'video/mp2t';
-    if (media.attributes && media.attributes.CODECS) {
-      mimeType += '; codecs="' + media.attributes.CODECS + '"';
-    }
-    this.sourceBuffer = this.mediaSource.addSourceBuffer(mimeType);
-
-    // exclude any incompatible variant streams from future playlist
-    // selection
-    this.excludeIncompatibleVariants_(media);
-
-    // transition the sourcebuffer to the ended state if we've hit the end of
-    // the playlist
-    this.sourceBuffer.addEventListener('updateend', this.updateEndHandler_.bind(this));
+  /**
+   * Begin playing the video.
+   */
+  play() {
+    this.masterPlaylistController_.play();
   }
   }
 
 
   /**
   /**
-   * Seek to the latest media position if this is a live video and the
-   * player and video are loaded and initialized.
+   * a wrapper around the function in MasterPlaylistController
    */
    */
-  setupFirstPlay() {
-    let seekable;
-    let media = this.playlists.media();
-
-    // check that everything is ready to begin buffering
-
-    // 1) the video is a live stream of unknown duration
-    if (this.duration() === Infinity &&
-
-        // 2) the player has not played before and is not paused
-        this.tech_.played().length === 0 &&
-        !this.tech_.paused() &&
-
-        // 3) the Media Source and Source Buffers are ready
-        this.sourceBuffer &&
-
-        // 4) the active media playlist is available
-        media &&
-
-        // 5) the video element or flash player is in a readyState of
-        // at least HAVE_FUTURE_DATA
-        this.tech_.readyState() >= 1) {
-
-      // trigger the playlist loader to start "expired time"-tracking
-      this.playlists.trigger('firstplay');
-
-      // seek to the latest media position for live videos
-      seekable = this.seekable();
-      if (seekable.length) {
-        this.tech_.setCurrentTime(seekable.end(0));
-      }
-    }
+  setCurrentTime(currentTime) {
+    this.masterPlaylistController_.setCurrentTime(currentTime);
   }
   }
 
 
   /**
   /**
-   * Begin playing the video.
+   * a wrapper around the function in MasterPlaylistController
    */
    */
-  play() {
-    this.loadingState_ = 'segments';
+  duration() {
+    return this.masterPlaylistController_.duration();
+  }
 
 
-    if (this.tech_.ended()) {
-      this.tech_.setCurrentTime(0);
-    }
+  /**
+   * a wrapper around the function in MasterPlaylistController
+   */
+  seekable() {
+    return this.masterPlaylistController_.seekable();
+  }
 
 
-    if (this.tech_.played().length === 0) {
-      return this.setupFirstPlay();
+  /**
+  * Abort all outstanding work and cleanup.
+  */
+  dispose() {
+    if (this.masterPlaylistController_) {
+      this.masterPlaylistController_.dispose();
     }
     }
+    this.tech_.audioTracks().removeEventListener('change', this.audioTrackChange_);
 
 
-    // if the viewer has paused and we fell out of the live window,
-    // seek forward to the earliest available position
-    if (this.duration() === Infinity) {
-      if (this.tech_.currentTime() < this.seekable().start(0)) {
-        this.tech_.setCurrentTime(this.seekable().start(0));
-      }
-    }
-  }
-
-  setCurrentTime(currentTime) {
-    let buffered = this.findBufferedRange_();
-
-    if (!(this.playlists && this.playlists.media())) {
-      // return immediately if the metadata is not ready yet
-      return 0;
-    }
-
-    // it's clearly an edge-case but don't thrown an error if asked to
-    // seek within an empty playlist
-    if (!this.playlists.media().segments) {
-      return 0;
-    }
-
-    // if the seek location is already buffered, continue buffering as
-    // usual
-    if (buffered && buffered.length) {
-      return currentTime;
-    }
-
-    // if we are in the middle of appending a segment, let it finish up
-    if (this.pendingSegment_ && this.pendingSegment_.buffered) {
-      return currentTime;
-    }
-
-    this.lastSegmentLoaded_ = null;
-
-    // cancel outstanding requests and buffer appends
-    this.cancelSegmentXhr();
-
-    // abort outstanding key requests, if necessary
-    if (this.keyXhr_) {
-      this.keyXhr_.aborted = true;
-      this.cancelKeyXhr();
-    }
-
-    // begin filling the buffer at the new position
-    this.fillBuffer(this.playlists.getMediaIndexForTime_(currentTime));
-  }
-
-  duration() {
-    let playlists = this.playlists;
-
-    if (!playlists) {
-      return 0;
-    }
-
-    if (this.mediaSource) {
-      return this.mediaSource.duration;
-    }
-
-    return Hls.Playlist.duration(playlists.media());
-  }
-
-  seekable() {
-    let media;
-    let seekable;
-
-    if (!this.playlists) {
-      return videojs.createTimeRanges();
-    }
-    media = this.playlists.media();
-    if (!media) {
-      return videojs.createTimeRanges();
-    }
-
-    seekable = Hls.Playlist.seekable(media);
-    if (seekable.length === 0) {
-      return seekable;
-    }
-
-    // if the seekable start is zero, it may be because the player has
-    // been paused for a long time and stopped buffering. in that case,
-    // fall back to the playlist loader's running estimate of expired
-    // time
-    if (seekable.start(0) === 0) {
-      return videojs.createTimeRanges([[this.playlists.expired_,
-                                        this.playlists.expired_ + seekable.end(0)]]);
-    }
-
-    // seekable has been calculated based on buffering video data so it
-    // can be returned directly
-    return seekable;
-  }
-
-  /**
-   * Update the player duration
-   */
-  updateDuration(playlist) {
-    let oldDuration = this.mediaSource.duration;
-    let newDuration = Hls.Playlist.duration(playlist);
-    let buffered = this.tech_.buffered();
-    let setDuration = () => {
-      this.mediaSource.duration = newDuration;
-      this.tech_.trigger('durationchange');
-
-      this.mediaSource.removeEventListener('sourceopen', setDuration);
-    };
-
-    if (buffered.length > 0) {
-      newDuration = Math.max(newDuration, buffered.end(buffered.length - 1));
-    }
-
-    // if the duration has changed, invalidate the cached value
-    if (oldDuration !== newDuration) {
-      // update the duration
-      if (this.mediaSource.readyState !== 'open') {
-        this.mediaSource.addEventListener('sourceopen', setDuration);
-      } else if (!this.sourceBuffer || !this.sourceBuffer.updating) {
-        this.mediaSource.duration = newDuration;
-        this.tech_.trigger('durationchange');
-      }
-    }
-  }
-
-  /**
-   * Clear all buffers and reset any state relevant to the current
-   * source. After this function is called, the tech should be in a
-   * state suitable for switching to a different video.
-   */
-  resetSrc_() {
-    this.cancelSegmentXhr();
-    this.cancelKeyXhr();
-
-    if (this.sourceBuffer && this.mediaSource.readyState === 'open') {
-      this.sourceBuffer.abort();
-    }
-  }
-
-  cancelKeyXhr() {
-    if (this.keyXhr_) {
-      this.keyXhr_.onreadystatechange = null;
-      this.keyXhr_.abort();
-      this.keyXhr_ = null;
-    }
-  }
-
-  cancelSegmentXhr() {
-    if (this.segmentXhr_) {
-      // Prevent error handler from running.
-      this.segmentXhr_.onreadystatechange = null;
-      this.segmentXhr_.abort();
-      this.segmentXhr_ = null;
-    }
-
-    // clear out the segment being processed
-    this.pendingSegment_ = null;
-  }
-
-  /**
-  * Abort all outstanding work and cleanup.
-  */
-  dispose() {
-    this.stopCheckingBuffer_();
-
-    if (this.playlists) {
-      this.playlists.dispose();
-    }
-
-    this.resetSrc_();
-    super.dispose();
-  }
-
-  /**
-   * Chooses the appropriate media playlist based on the current
-   * bandwidth estimate and the player size.
-   * @return the highest bitrate playlist less than the currently detected
-   * bandwidth, accounting for some amount of bandwidth variance
-   */
-  selectPlaylist() {
-    let effectiveBitrate;
-    let sortedPlaylists = this.playlists.master.playlists.slice();
-    let bandwidthPlaylists = [];
-    let now = +new Date();
-    let i;
-    let variant;
-    let bandwidthBestVariant;
-    let resolutionPlusOne;
-    let resolutionPlusOneAttribute;
-    let resolutionBestVariant;
-    let width;
-    let height;
-
-    sortedPlaylists.sort(Hls.comparePlaylistBandwidth);
-
-    // filter out any playlists that have been excluded due to
-    // incompatible configurations or playback errors
-    sortedPlaylists = sortedPlaylists.filter((localVariant) => {
-      if (typeof localVariant.excludeUntil !== 'undefined') {
-        return now >= localVariant.excludeUntil;
-      }
-      return true;
-    });
-
-    // filter out any variant that has greater effective bitrate
-    // than the current estimated bandwidth
-    i = sortedPlaylists.length;
-    while (i--) {
-      variant = sortedPlaylists[i];
-
-      // ignore playlists without bandwidth information
-      if (!variant.attributes || !variant.attributes.BANDWIDTH) {
-        continue;
-      }
-
-      effectiveBitrate = variant.attributes.BANDWIDTH * bandwidthVariance;
-
-      if (effectiveBitrate < this.bandwidth) {
-        bandwidthPlaylists.push(variant);
-
-        // since the playlists are sorted in ascending order by
-        // bandwidth, the first viable variant is the best
-        if (!bandwidthBestVariant) {
-          bandwidthBestVariant = variant;
-        }
-      }
-    }
-
-    i = bandwidthPlaylists.length;
-
-    // sort variants by resolution
-    bandwidthPlaylists.sort(Hls.comparePlaylistResolution);
-
-    // forget our old variant from above,
-    // or we might choose that in high-bandwidth scenarios
-    // (this could be the lowest bitrate rendition as  we go through all of them above)
-    variant = null;
-
-    width = parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10);
-    height = parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10);
-
-    // iterate through the bandwidth-filtered playlists and find
-    // best rendition by player dimension
-    while (i--) {
-      variant = bandwidthPlaylists[i];
-
-      // ignore playlists without resolution information
-      if (!variant.attributes ||
-          !variant.attributes.RESOLUTION ||
-          !variant.attributes.RESOLUTION.width ||
-          !variant.attributes.RESOLUTION.height) {
-        continue;
-      }
-
-      // since the playlists are sorted, the first variant that has
-      // dimensions less than or equal to the player size is the best
-
-      let variantResolution = variant.attributes.RESOLUTION;
-
-      if (variantResolution.width === width &&
-          variantResolution.height === height) {
-        // if we have the exact resolution as the player use it
-        resolutionPlusOne = null;
-        resolutionBestVariant = variant;
-        break;
-      } else if (variantResolution.width < width &&
-                 variantResolution.height < height) {
-        // if both dimensions are less than the player use the
-        // previous (next-largest) variant
-        break;
-      } else if (!resolutionPlusOne ||
-                 (variantResolution.width < resolutionPlusOneAttribute.width &&
-                  variantResolution.height < resolutionPlusOneAttribute.height)) {
-        // If we still haven't found a good match keep a
-        // reference to the previous variant for the next loop
-        // iteration
-
-        // By only saving variants if they are smaller than the
-        // previously saved variant, we ensure that we also pick
-        // the highest bandwidth variant that is just-larger-than
-        // the video player
-        resolutionPlusOne = variant;
-        resolutionPlusOneAttribute = resolutionPlusOne.attributes.RESOLUTION;
-      }
-    }
-
-    // fallback chain of variants
-    return resolutionPlusOne ||
-      resolutionBestVariant ||
-      bandwidthBestVariant ||
-      sortedPlaylists[0];
-  }
-
-  /**
-   * Periodically request new segments and append video data.
-   */
-  checkBuffer_() {
-    // calling this method directly resets any outstanding buffer checks
-    if (this.checkBufferTimeout_) {
-      window.clearTimeout(this.checkBufferTimeout_);
-      this.checkBufferTimeout_ = null;
-    }
-
-    this.fillBuffer();
-    this.drainBuffer();
-
-    // wait awhile and try again
-    this.checkBufferTimeout_ = window.setTimeout((this.checkBuffer_).bind(this),
-                                                  bufferCheckInterval);
-  }
-
-  /**
-   * Setup a periodic task to request new segments if necessary and
-   * append bytes into the SourceBuffer.
-   */
-  startCheckingBuffer_() {
-    this.checkBuffer_();
-  }
-
-  /**
-   * Stop the periodic task requesting new segments and feeding the
-   * SourceBuffer.
-   */
-  stopCheckingBuffer_() {
-    if (this.checkBufferTimeout_) {
-      window.clearTimeout(this.checkBufferTimeout_);
-      this.checkBufferTimeout_ = null;
-    }
-  }
-
-  /**
-   * Determines whether there is enough video data currently in the buffer
-   * and downloads a new segment if the buffered time is less than the goal.
-   * @param seekToTime (optional) {number} the offset into the downloaded segment
-   * to seek to, in seconds
-   */
-  fillBuffer(mediaIndex) {
-    let tech = this.tech_;
-    let currentTime = tech.currentTime();
-    let hasBufferedContent = (this.tech_.buffered().length !== 0);
-    let currentBuffered = this.findBufferedRange_();
-    let outsideBufferedRanges = !(currentBuffered && currentBuffered.length);
-    let currentBufferedEnd = 0;
-    let bufferedTime = 0;
-    let segment;
-    let segmentInfo;
-    let segmentTimestampOffset;
-
-    // if preload is set to "none", do not download segments until playback is requested
-    if (this.loadingState_ !== 'segments') {
-      return;
-    }
-
-    // if a video has not been specified, do nothing
-    if (!tech.currentSrc() || !this.playlists) {
-      return;
-    }
-
-    // if there is a request already in flight, do nothing
-    if (this.segmentXhr_) {
-      return;
-    }
-
-    // wait until the buffer is up to date
-    if (this.pendingSegment_) {
-      return;
-    }
-
-    // if no segments are available, do nothing
-    if (this.playlists.state === 'HAVE_NOTHING' ||
-        !this.playlists.media() ||
-        !this.playlists.media().segments) {
-      return;
-    }
-
-    // if a playlist switch is in progress, wait for it to finish
-    if (this.playlists.state === 'SWITCHING_MEDIA') {
-      return;
-    }
-
-    if (typeof mediaIndex === 'undefined') {
-      if (currentBuffered && currentBuffered.length) {
-        currentBufferedEnd = currentBuffered.end(0);
-        mediaIndex = this.playlists.getMediaIndexForTime_(currentBufferedEnd);
-        bufferedTime = Math.max(0, currentBufferedEnd - currentTime);
-
-        // if there is plenty of content in the buffer and we're not
-        // seeking, relax for awhile
-        if (bufferedTime >= Hls.GOAL_BUFFER_LENGTH) {
-          return;
-        }
-      } else {
-        mediaIndex = this.playlists.getMediaIndexForTime_(this.tech_.currentTime());
-      }
-    }
-    segment = this.playlists.media().segments[mediaIndex];
-
-    // if the video has finished downloading
-    if (!segment) {
-      return;
-    }
-
-    // we have entered a state where we are fetching the same segment,
-    // try to walk forward
-    if (this.lastSegmentLoaded_ &&
-        this.playlistUriToUrl(this.lastSegmentLoaded_.uri) === this.playlistUriToUrl(segment.uri) &&
-        this.lastSegmentLoaded_.byterange === segment.byterange) {
-      return this.fillBuffer(mediaIndex + 1);
-    }
-
-    // package up all the work to append the segment
-    segmentInfo = {
-      // resolve the segment URL relative to the playlist
-      uri: this.playlistUriToUrl(segment.uri),
-      // the segment's mediaIndex & mediaSequence at the time it was requested
-      mediaIndex,
-      mediaSequence: this.playlists.media().mediaSequence,
-      // the segment's playlist
-      playlist: this.playlists.media(),
-      // The state of the buffer when this segment was requested
-      currentBufferedEnd,
-      // unencrypted bytes of the segment
-      bytes: null,
-      // when a key is defined for this segment, the encrypted bytes
-      encryptedBytes: null,
-      // optionally, the decrypter that is unencrypting the segment
-      decrypter: null,
-      // the state of the buffer before a segment is appended will be
-      // stored here so that the actual segment duration can be
-      // determined after it has been appended
-      buffered: null,
-      // The target timestampOffset for this segment when we append it
-      // to the source buffer
-      timestampOffset: null
-    };
-
-    if (mediaIndex > 0) {
-      segmentTimestampOffset = Hls.Playlist.duration(segmentInfo.playlist,
-        segmentInfo.playlist.mediaSequence + mediaIndex) + this.playlists.expired_;
-    }
-
-    if (this.tech_.seeking() && outsideBufferedRanges) {
-      // If there are discontinuities in the playlist, we can't be sure of anything
-      // related to time so we reset the timestamp offset and start appending data
-      // anew on every seek
-      if (segmentInfo.playlist.discontinuityStarts.length) {
-        segmentInfo.timestampOffset = segmentTimestampOffset;
-      }
-    } else if (segment.discontinuity && currentBuffered.length) {
-      // If we aren't seeking and are crossing a discontinuity, we should set
-      // timestampOffset for new segments to be appended the end of the current
-      // buffered time-range
-      segmentInfo.timestampOffset = currentBuffered.end(0);
-    } else if (!hasBufferedContent && this.tech_.currentTime() > 0.05) {
-      // If we are trying to play at a position that is not zero but we aren't
-      // currently seeking according to the video element
-      segmentInfo.timestampOffset = segmentTimestampOffset;
-    }
-
-    this.loadSegment(segmentInfo);
-  }
-
-  playlistUriToUrl(segmentRelativeUrl) {
-    let playListUrl;
-
-      // resolve the segment URL relative to the playlist
-    if (this.playlists.media().uri === this.source_.src) {
-      playListUrl = resolveUrl(this.source_.src, segmentRelativeUrl);
-    } else {
-      playListUrl =
-        resolveUrl(resolveUrl(this.source_.src, this.playlists.media().uri || ''),
-                   segmentRelativeUrl);
-    }
-    return playListUrl;
-  }
-
-  /*
-   * Turns segment byterange into a string suitable for use in
-   * HTTP Range requests
-   */
-  byterangeStr_(byterange) {
-    let byterangeStart;
-    let byterangeEnd;
-
-    // `byterangeEnd` is one less than `offset + length` because the HTTP range
-    // header uses inclusive ranges
-    byterangeEnd = byterange.offset + byterange.length - 1;
-    byterangeStart = byterange.offset;
-    return 'bytes=' + byterangeStart + '-' + byterangeEnd;
-  }
-
-  /*
-   * Defines headers for use in the xhr request for a particular segment.
-   */
-  segmentXhrHeaders_(segment) {
-    let headers = {};
-
-    if ('byterange' in segment) {
-      headers.Range = this.byterangeStr_(segment.byterange);
-    }
-    return headers;
-  }
-
-  /*
-   * Sets `bandwidth`, `segmentXhrTime`, and appends to the `bytesReceived.
-   * Expects an object with:
-   *  * `roundTripTime` - the round trip time for the request we're setting the time for
-   *  * `bandwidth` - the bandwidth we want to set
-   *  * `bytesReceived` - amount of bytes downloaded
-   * `bandwidth` is the only required property.
-   */
-  setBandwidth(localXhr) {
-    // calculate the download bandwidth
-    this.segmentXhrTime = localXhr.roundTripTime;
-    this.bandwidth = localXhr.bandwidth;
-    this.bytesReceived += localXhr.bytesReceived || 0;
-
-    this.tech_.trigger('bandwidthupdate');
-  }
-
-  /*
-   * Blacklists a playlist when an error occurs for a set amount of time
-   * making it unavailable for selection by the rendition selection algorithm
-   * and then forces a new playlist (rendition) selection.
-   */
-  blacklistCurrentPlaylist_(error) {
-    let currentPlaylist;
-    let nextPlaylist;
-
-    // If the `error` was generated by the playlist loader, it will contain
-    // the playlist we were trying to load (but failed) and that should be
-    // blacklisted instead of the currently selected playlist which is likely
-    // out-of-date in this scenario
-    currentPlaylist = error.playlist || this.playlists.media();
-
-    // If there is no current playlist, then an error occurred while we were
-    // trying to load the master OR while we were disposing of the tech
-    if (!currentPlaylist) {
-      this.error = error;
-      return this.mediaSource.endOfStream('network');
-    }
-
-    // Blacklist this playlist
-    currentPlaylist.excludeUntil = Date.now() + blacklistDuration;
-
-    // Select a new playlist
-    nextPlaylist = this.selectPlaylist();
-
-    if (nextPlaylist) {
-      videojs.log.warn('Problem encountered with the current ' +
-                       'HLS playlist. Switching to another playlist.');
-
-      return this.playlists.media(nextPlaylist);
-    }
-    videojs.log.warn('Problem encountered with the current ' +
-                     'HLS playlist. No suitable alternatives found.');
-    // We have no more playlists we can select so we must fail
-    this.error = error;
-    return this.mediaSource.endOfStream('network');
-  }
-
-  loadSegment(segmentInfo) {
-    let segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
-    let removeToTime = 0;
-    let seekable = this.seekable();
-    let currentTime = this.tech_.currentTime();
-
-    // Chrome has a hard limit of 150mb of
-    // buffer and a very conservative "garbage collector"
-    // We manually clear out the old buffer to ensure
-    // we don't trigger the QuotaExceeded error
-    // on the source buffer during subsequent appends
-    if (this.sourceBuffer && !this.sourceBuffer.updating) {
-      // If we have a seekable range use that as the limit for what can be removed safely
-      // otherwise remove anything older than 1 minute before the current play head
-      if (seekable.length && seekable.start(0) > 0 && seekable.start(0) < currentTime) {
-        removeToTime = seekable.start(0);
-      } else {
-        removeToTime = currentTime - 60;
-      }
-
-      if (removeToTime > 0) {
-        this.sourceBuffer.remove(0, removeToTime);
-      }
-    }
-
-    // if the segment is encrypted, request the key
-    if (segment.key) {
-      this.fetchKey_(segment);
-    }
-
-    // request the next segment
-    this.segmentXhr_ = this.tech_.hls.xhr({
-      uri: segmentInfo.uri,
-      responseType: 'arraybuffer',
-      withCredentials: this.source_.withCredentials,
-      // Set xhr timeout to 150% of the segment duration to allow us
-      // some time to switch renditions in the event of a catastrophic
-      // decrease in network performance or a server issue.
-      timeout: (segment.duration * 1.5) * 1000,
-      headers: this.segmentXhrHeaders_(segment)
-    }, (error, request) => {
-      // This is a timeout of a previously aborted segment request
-      // so simply ignore it
-      if (!this.segmentXhr_ || request !== this.segmentXhr_) {
-        return;
-      }
-
-      // the segment request is no longer outstanding
-      this.segmentXhr_ = null;
-
-      // if a segment request times out, we may have better luck with another playlist
-      if (request.timedout) {
-        this.bandwidth = 1;
-        return this.playlists.media(this.selectPlaylist());
-      }
-
-      // otherwise, trigger a network error
-      if (!request.aborted && error) {
-        return this.blacklistCurrentPlaylist_({
-          status: request.status,
-          message: 'HLS segment request error at URL: ' + segmentInfo.uri,
-          code: (request.status >= 500) ? 4 : 2
-        });
-      }
-
-      // stop processing if the request was aborted
-      if (!request.response) {
-        return;
-      }
-
-      this.lastSegmentLoaded_ = segment;
-      this.setBandwidth(request);
-
-      if (segment.key) {
-        segmentInfo.encryptedBytes = new Uint8Array(request.response);
-      } else {
-        segmentInfo.bytes = new Uint8Array(request.response);
-      }
-
-      this.pendingSegment_ = segmentInfo;
-
-      this.tech_.trigger('progress');
-      this.drainBuffer();
-
-      // figure out what stream the next segment should be downloaded from
-      // with the updated bandwidth information
-      this.playlists.media(this.selectPlaylist());
-    });
-
-  }
-
-  drainBuffer() {
-    let segmentInfo;
-    let mediaIndex;
-    let playlist;
-    let bytes;
-    let segment;
-    let decrypter;
-    let segIv;
-
-    // if the buffer is empty or the source buffer hasn't been created
-    // yet, do nothing
-    if (!this.pendingSegment_ || !this.sourceBuffer) {
-      return;
-    }
-
-    // the pending segment has already been appended and we're waiting
-    // for updateend to fire
-    if (this.pendingSegment_.buffered) {
-      return;
-    }
-
-    // we can't append more data if the source buffer is busy processing
-    // what we've already sent
-    if (this.sourceBuffer.updating) {
-      return;
-    }
-
-    segmentInfo = this.pendingSegment_;
-    mediaIndex = segmentInfo.mediaIndex;
-    playlist = segmentInfo.playlist;
-    bytes = segmentInfo.bytes;
-    segment = playlist.segments[mediaIndex];
-
-    if (segment.key && !bytes) {
-      // this is an encrypted segment
-      // if the key download failed, we want to skip this segment
-      // but if the key hasn't downloaded yet, we want to try again later
-      if (keyFailed(segment.key)) {
-        return this.blacklistCurrentPlaylist_({
-          message: 'HLS segment key request error.',
-          code: 4
-        });
-      } else if (!segment.key.bytes) {
-        // waiting for the key bytes, try again later
-        return;
-      } else if (segmentInfo.decrypter) {
-        // decryption is in progress, try again later
-        return;
-      }
-      // if the media sequence is greater than 2^32, the IV will be incorrect
-      // assuming 10s segments, that would be about 1300 years
-      segIv = segment.key.iv ||
-        new Uint32Array([0, 0, 0, mediaIndex + playlist.mediaSequence]);
-
-      // create a decrypter to incrementally decrypt the segment
-      decrypter = new Hls.Decrypter(segmentInfo.encryptedBytes,
-                                    segment.key.bytes,
-                                    segIv,
-                                    function(error, localBytes) {
-                                      if (error) {
-                                        videojs.log.warn(error);
-                                      }
-                                      segmentInfo.bytes = localBytes;
-                                    });
-      segmentInfo.decrypter = decrypter;
-      return;
-    }
-
-    this.pendingSegment_.buffered = this.tech_.buffered();
-
-    if (segmentInfo.timestampOffset !== null) {
-      this.sourceBuffer.timestampOffset = segmentInfo.timestampOffset;
-    }
-
-    // the segment is asynchronously added to the current buffered data
-    this.sourceBuffer.appendBuffer(bytes);
-  }
-
-  updateEndHandler_() {
-    let segmentInfo = this.pendingSegment_;
-    let playlist;
-    let currentMediaIndex;
-    let currentBuffered;
-    let seekable;
-    let timelineUpdate;
-    let isEndOfStream;
-
-    // stop here if the update errored or was aborted
-    if (!segmentInfo) {
-      this.pendingSegment_ = null;
-      return;
-    }
-
-    // In Firefox, the updateend event is triggered for both removing from the buffer and
-    // adding to the buffer. To prevent this code from executing on removals, we wait for
-    // segmentInfo to have a filled in buffered value before we continue processing.
-    if (!segmentInfo.buffered) {
-      return;
-    }
-
-    this.pendingSegment_ = null;
-
-    playlist = segmentInfo.playlist;
-    currentMediaIndex = segmentInfo.mediaIndex +
-      (segmentInfo.mediaSequence - playlist.mediaSequence);
-    currentBuffered = this.findBufferedRange_();
-    isEndOfStream = detectEndOfStream(playlist, this.mediaSource, currentMediaIndex, currentBuffered);
-
-    // if we switched renditions don't try to add segment timeline
-    // information to the playlist
-    if (segmentInfo.playlist.uri !== this.playlists.media().uri) {
-      if (isEndOfStream) {
-        return this.mediaSource.endOfStream();
-      }
-      return this.fillBuffer();
-    }
-
-    // when seeking to the beginning of the seekable range, it's
-    // possible that imprecise timing information may cause the seek to
-    // end up earlier than the start of the range
-    // in that case, seek again
-    seekable = this.seekable();
-    if (this.tech_.seeking() &&
-        currentBuffered.length === 0) {
-      if (seekable.length &&
-          this.tech_.currentTime() < seekable.start(0)) {
-        let next = this.findNextBufferedRange_();
-
-        if (next.length) {
-          videojs.log('tried seeking to', this.tech_.currentTime(),
-                      'but that was too early, retrying at', next.start(0));
-          this.tech_.setCurrentTime(next.start(0) + TIME_FUDGE_FACTOR);
-        }
-      }
-    }
-
-    timelineUpdate = Hls.findSoleUncommonTimeRangesEnd_(segmentInfo.buffered,
-                                                        this.tech_.buffered());
-
-    // Update segment meta-data (duration and end-point) based on timeline
-    updateSegmentMetadata(playlist, currentMediaIndex, timelineUpdate);
-
-    // If we decide to signal the end of stream, then we can return instead
-    // of trying to fetch more segments
-    if (isEndOfStream) {
-      return this.mediaSource.endOfStream();
-    }
-
-    if (timelineUpdate !== null ||
-        segmentInfo.buffered.length !== this.tech_.buffered().length) {
-      this.updateDuration(playlist);
-      // check if it's time to download the next segment
-      this.fillBuffer();
-      return;
-    }
-
-    // the last segment append must have been entirely in the
-    // already buffered time ranges. just buffer forward until we
-    // find a segment that adds to the buffered time ranges and
-    // improves subsequent media index calculations.
-    this.fillBuffer(currentMediaIndex + 1);
-    return;
-  }
-
-  /**
-   * Attempt to retrieve the key for a particular media segment.
-   */
-  fetchKey_(segment) {
-    let key;
-    let settings;
-    let receiveKey;
-
-    // if there is a pending XHR or no segments, don't do anything
-    if (this.keyXhr_) {
-      return;
-    }
-
-    settings = this.options_;
-
-    /**
-    * Handle a key XHR response.
-    */
-    receiveKey = (keyRecieved) => {
-      return (error, request) => {
-        let view;
-
-        this.keyXhr_ = null;
-
-        if (error || !request.response || request.response.byteLength !== 16) {
-          keyRecieved.retries = keyRecieved.retries || 0;
-          keyRecieved.retries++;
-          if (!request.aborted) {
-            // try fetching again
-            this.fetchKey_(segment);
-          }
-          return;
-        }
-
-        view = new DataView(request.response);
-        keyRecieved.bytes = new Uint32Array([
-          view.getUint32(0),
-          view.getUint32(4),
-          view.getUint32(8),
-          view.getUint32(12)
-        ]);
-
-        // check to see if this allows us to make progress buffering now
-        this.checkBuffer_();
-      };
-    };
-
-    key = segment.key;
-
-    // nothing to do if this segment is unencrypted
-    if (!key) {
-      return;
-    }
-
-    // request the key if the retry limit hasn't been reached
-    if (!key.bytes && !keyFailed(key)) {
-      this.keyXhr_ = this.tech_.hls.xhr({
-        uri: this.playlistUriToUrl(key.uri),
-        responseType: 'arraybuffer',
-        withCredentials: settings.withCredentials
-      }, receiveKey(key));
-      return;
-    }
+    super.dispose();
   }
   }
 }
 }
 
 
 /**
 /**
- * Attempts to find the buffered TimeRange that contains the specified
- * time, or where playback is currently happening if no specific time
- * is specified.
- * @param time (optional) {number} the time to filter on. Defaults to
- * currentTime.
- * @return a new TimeRanges object.
- */
-HlsHandler.prototype.findBufferedRange_ =
-  filterBufferedRanges(function(start, end, time) {
-    return start - TIME_FUDGE_FACTOR <= time &&
-      end + TIME_FUDGE_FACTOR >= time;
-  });
-/**
- * Returns the TimeRanges that begin at or later than the specified
- * time.
- * @param time (optional) {number} the time to filter on. Defaults to
- * currentTime.
- * @return a new TimeRanges object.
- */
-HlsHandler.prototype.findNextBufferedRange_ =
-  filterBufferedRanges(function(start, end, time) {
-    return start - TIME_FUDGE_FACTOR >= time;
-  });
-
-/**
  * The Source Handler object, which informs video.js what additional
  * The Source Handler object, which informs video.js what additional
  * MIME types are supported and sets up playback. It is registered
  * MIME types are supported and sets up playback. It is registered
  * automatically to the appropriate tech based on the capabilities of
  * automatically to the appropriate tech based on the capabilities of
@@ -1550,9 +513,16 @@ HlsHandler.prototype.findNextBufferedRange_ =
 const HlsSourceHandler = function(mode) {
 const HlsSourceHandler = function(mode) {
   return {
   return {
     canHandleSource(srcObj) {
     canHandleSource(srcObj) {
+      // this forces video.js to skip this tech/mode if its not the one we have been
+      // overriden to use, by returing that we cannot handle the source.
+      if (videojs.options.hls &&
+          videojs.options.hls.mode &&
+          videojs.options.hls.mode !== mode) {
+        return false;
+      }
       return HlsSourceHandler.canPlayType(srcObj.type);
       return HlsSourceHandler.canPlayType(srcObj.type);
     },
     },
-    handleSource(source, tech) {
+    handleSource(source, tech, options) {
       if (mode === 'flash') {
       if (mode === 'flash') {
         // We need to trigger this asynchronously to give others the chance
         // We need to trigger this asynchronously to give others the chance
         // to bind to the event when a source is set at player creation
         // to bind to the event when a source is set at player creation
@@ -1560,10 +530,10 @@ const HlsSourceHandler = function(mode) {
           tech.trigger('loadstart');
           tech.trigger('loadstart');
         }, 1);
         }, 1);
       }
       }
-      tech.hls = new HlsHandler(tech, {
-        source,
-        mode
-      });
+
+      let settings = videojs.mergeOptions(options, {hls: {mode}});
+
+      tech.hls = new HlsHandler(source, tech, settings);
 
 
       tech.hls.xhr = xhrFactory();
       tech.hls.xhr = xhrFactory();
       // Use a global `before` function if specified on videojs.Hls.xhr
       // Use a global `before` function if specified on videojs.Hls.xhr
@@ -1576,13 +546,81 @@ const HlsSourceHandler = function(mode) {
       return tech.hls;
       return tech.hls;
     },
     },
     canPlayType(type) {
     canPlayType(type) {
-      return HlsSourceHandler.canPlayType(type);
+      if (HlsSourceHandler.canPlayType(type)) {
+        return 'maybe';
+      }
+      return '';
     }
     }
   };
   };
 };
 };
 
 
+/**
+ * A comparator function to sort two playlist object by bandwidth.
+ *
+ * @param {Object} left a media playlist object
+ * @param {Object} right a media playlist object
+ * @return {Number} Greater than zero if the bandwidth attribute of
+ * left is greater than the corresponding attribute of right. Less
+ * than zero if the bandwidth of right is greater than left and
+ * exactly zero if the two are equal.
+ */
+Hls.comparePlaylistBandwidth = function(left, right) {
+  let leftBandwidth;
+  let rightBandwidth;
+
+  if (left.attributes && left.attributes.BANDWIDTH) {
+    leftBandwidth = left.attributes.BANDWIDTH;
+  }
+  leftBandwidth = leftBandwidth || window.Number.MAX_VALUE;
+  if (right.attributes && right.attributes.BANDWIDTH) {
+    rightBandwidth = right.attributes.BANDWIDTH;
+  }
+  rightBandwidth = rightBandwidth || window.Number.MAX_VALUE;
+
+  return leftBandwidth - rightBandwidth;
+};
+
+/**
+ * A comparator function to sort two playlist object by resolution (width).
+ * @param {Object} left a media playlist object
+ * @param {Object} right a media playlist object
+ * @return {Number} Greater than zero if the resolution.width attribute of
+ * left is greater than the corresponding attribute of right. Less
+ * than zero if the resolution.width of right is greater than left and
+ * exactly zero if the two are equal.
+ */
+Hls.comparePlaylistResolution = function(left, right) {
+  let leftWidth;
+  let rightWidth;
+
+  if (left.attributes &&
+      left.attributes.RESOLUTION &&
+      left.attributes.RESOLUTION.width) {
+    leftWidth = left.attributes.RESOLUTION.width;
+  }
+
+  leftWidth = leftWidth || window.Number.MAX_VALUE;
+
+  if (right.attributes &&
+      right.attributes.RESOLUTION &&
+      right.attributes.RESOLUTION.width) {
+    rightWidth = right.attributes.RESOLUTION.width;
+  }
+
+  rightWidth = rightWidth || window.Number.MAX_VALUE;
+
+  // NOTE - Fallback to bandwidth sort as appropriate in cases where multiple renditions
+  // have the same media dimensions/ resolution
+  if (leftWidth === rightWidth &&
+      left.attributes.BANDWIDTH &&
+      right.attributes.BANDWIDTH) {
+    return left.attributes.BANDWIDTH - right.attributes.BANDWIDTH;
+  }
+  return leftWidth - rightWidth;
+};
+
 HlsSourceHandler.canPlayType = function(type) {
 HlsSourceHandler.canPlayType = function(type) {
-  let mpegurlRE = /^application\/(?:x-|vnd\.apple\.)mpegurl/i;
+  let mpegurlRE = /^(audio|video|application)\/(x-|vnd\.apple\.)?mpegurl/i;
 
 
   // favor native HLS support if it's available
   // favor native HLS support if it's available
   if (Hls.supportsNativeHls) {
   if (Hls.supportsNativeHls) {
@@ -1609,6 +647,8 @@ videojs.HlsHandler = HlsHandler;
 videojs.HlsSourceHandler = HlsSourceHandler;
 videojs.HlsSourceHandler = HlsSourceHandler;
 videojs.Hls = Hls;
 videojs.Hls = Hls;
 videojs.m3u8 = m3u8;
 videojs.m3u8 = m3u8;
+videojs.registerComponent('Hls', Hls);
+videojs.options.hls = videojs.options.hls || {};
 
 
 module.exports = {
 module.exports = {
   Hls,
   Hls,

 /**
 /**
+ * @file xhr.js
+ */
+
+/**
  * A wrapper for videojs.xhr that tracks bandwidth.
  * A wrapper for videojs.xhr that tracks bandwidth.
+ *
+ * @param {Object} options options for the XHR
+ * @param {Function} callback the callback to call when done
+ * @return {Request} the xhr request that is going to be made
  */
  */
 import {xhr as videojsXHR, mergeOptions} from 'video.js';
 import {xhr as videojsXHR, mergeOptions} from 'video.js';
 
 

+import HlsAudioTrack from '../src/hls-audio-track';
+import QUnit from 'qunit';
+
+// Most of these tests will be done in video.js.AudioTrack unit tests
+QUnit.module('HlsAudioTrack - Props');
+
+QUnit.test('verify that props are readonly and can be set', function() {
+  let props = {
+    default: true,
+    language: 'en',
+    label: 'English',
+    autoselect: true,
+    withCredentials: true,
+    // below props won't be used, its used for checking
+    kind: 'main'
+  };
+
+  let track = new HlsAudioTrack(props);
+
+  for (let k in props) {
+    QUnit.equal(track[k], props[k], `${k} should be stored in track`);
+  }
+});
+
+QUnit.test('can start with a mediaGroup that has a uri', function() {
+  let props = {
+    default: true,
+    language: 'en',
+    label: 'English',
+    autoselect: true,
+    mediaGroup: 'foo',
+    withCredentials: true,
+    resolvedUri: 'http://some.test.url/playlist.m3u8',
+    // below props won't be used, its used for checking
+    enabled: true,
+    kind: 'main'
+  };
+  let track = new HlsAudioTrack(props);
+
+  QUnit.equal(track.mediaGroups_.length, 1, 'loader was created');
+  let loader = track.getLoader('foo');
+
+  QUnit.ok(loader, 'can getLoader on foo');
+
+  track.dispose();
+  QUnit.equal(track.mediaGroups_.length, 0, 'loader disposed');
+});
+
+QUnit.test('can start with a mediaGroup that has no uri', function() {
+  let props = {
+    default: true,
+    language: 'en',
+    label: 'English',
+    autoselect: true,
+    mediaGroup: 'foo',
+    withCredentials: true,
+    // below props won't be used, its used for checking
+    enabled: true,
+    kind: 'main'
+  };
+  let track = new HlsAudioTrack(props);
+
+  QUnit.equal(track.mediaGroups_.length, 1, 'mediaGroupLoader was created for foo');
+  QUnit.ok(!track.getLoader('foo'), 'can getLoader on foo, but it is undefined');
+
+  track.dispose();
+  QUnit.equal(track.mediaGroups_.length, 0, 'loaders disposed');
+});
+
+QUnit.module('HlsAudioTrack - Loader', {
+  beforeEach() {
+    this.track = new HlsAudioTrack({
+      mediaGroup: 'default',
+      default: true,
+      language: 'en',
+      label: 'English',
+      autoselect: true,
+      withCredentials: true
+    });
+  },
+  afterEach() {
+    this.track.dispose();
+    QUnit.equal(this.track.mediaGroups_.length, 0, 'zero loaders after dispose');
+  }
+});
+
+QUnit.test('can add a playlist loader', function() {
+  QUnit.equal(this.track.mediaGroups_.length, 1, '1 loader to start');
+
+  this.track.addLoader('foo', 'someurl');
+  this.track.addLoader('bar', 'someurl');
+  this.track.addLoader('baz', 'someurl');
+
+  QUnit.equal(this.track.mediaGroups_.length, 4, 'now has four loaders');
+});
+
+QUnit.test('can remove playlist loader', function() {
+  QUnit.equal(this.track.mediaGroups_.length, 1, 'one loaders to start');
+
+  this.track.addLoader('foo', 'someurl');
+  this.track.addLoader('baz', 'someurl');
+
+  QUnit.equal(this.track.mediaGroups_.length, 3, 'now has three loaders');
+
+  this.track.removeLoader('baz');
+  QUnit.equal(this.track.mediaGroups_.length, 2, 'now has two loaders');
+
+});

@@ -10,13 +10,10 @@ var DEFAULTS = {
     'node_modules/sinon/pkg/sinon-ie.js',
     'node_modules/sinon/pkg/sinon-ie.js',
     'node_modules/video.js/dist/video.js',
     'node_modules/video.js/dist/video.js',
     'node_modules/video.js/dist/video-js.css',
     'node_modules/video.js/dist/video-js.css',
-
     'test/**/*.test.js'
     'test/**/*.test.js'
   ],
   ],
 
 
-  exclude: [
-    'test/data/**'
-  ],
+  exclude: [],
 
 
   plugins: [
   plugins: [
     'karma-browserify',
     'karma-browserify',
@@ -43,6 +40,13 @@ var DEFAULTS = {
     noParse: [
     noParse: [
       'test/data/**',
       'test/data/**',
     ]
     ]
+  },
+
+  customLaunchers: {
+    travisChrome: {
+      base: 'Chrome',
+      flags: ['--no-sandbox']
+    }
   }
   }
 };
 };
 
 

@@ -4,12 +4,10 @@ var common = require('./common');
 
 
 module.exports = function(config) {
 module.exports = function(config) {
 
 
-  // Travis CI should run in its available Firefox headless browser.
   if (process.env.TRAVIS) {
   if (process.env.TRAVIS) {
-
     config.set(common({
     config.set(common({
-      browsers: ['Firefox'],
-      plugins: ['karma-firefox-launcher']
+      browsers: ['travisChrome'],
+      plugins: ['karma-chrome-launcher']
     }))
     }))
   } else {
   } else {
     config.set(common({
     config.set(common({

+import QUnit from 'qunit';
+import videojs from 'video.js';
+import {
+  useFakeEnvironment,
+  useFakeMediaSource,
+  createPlayer,
+  standardXHRResponse,
+  openMediaSource
+} from './test-helpers.js';
+import MasterPlaylistController from '../src/master-playlist-controller';
+/* eslint-disable no-unused-vars */
+// we need this so that it can register hls with videojs
+import { Hls } from '../src/videojs-contrib-hls';
+/* eslint-enable no-unused-vars */
+import Playlist from '../src/playlist';
+
+QUnit.module('MasterPlaylistController', {
+  beforeEach() {
+    this.env = useFakeEnvironment();
+    this.clock = this.env.clock;
+    this.requests = this.env.requests;
+    this.mse = useFakeMediaSource();
+
+    // force the HLS tech to run
+    this.origSupportsNativeHls = videojs.Hls.supportsNativeHls;
+    videojs.Hls.supportsNativeHls = false;
+
+    this.player = createPlayer();
+    this.player.src({
+      src: 'manifest/master.m3u8',
+      type: 'application/vnd.apple.mpegurl'
+    });
+    this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
+  },
+  afterEach() {
+    this.env.restore();
+    this.mse.restore();
+    videojs.Hls.supportsNativeHls = this.origSupportsNativeHls;
+    this.player.dispose();
+  }
+});
+
+QUnit.test('throws error when given an empty URL', function() {
+  let options = {
+    url: 'test',
+    currentTimeFunc: () => {},
+    tech: this.player.tech_
+  };
+
+  QUnit.ok(new MasterPlaylistController(options), 'can create with options');
+
+  options.url = '';
+  QUnit.throws(() => {
+    new MasterPlaylistController(options); // eslint-disable-line no-new
+  }, /A non-empty playlist URL is required/, 'requires a non empty url');
+});
+
+QUnit.test('obeys none preload option', function() {
+  this.player.preload('none');
+  // master
+  standardXHRResponse(this.requests.shift());
+  // playlist
+  standardXHRResponse(this.requests.shift());
+
+  openMediaSource(this.player, this.clock);
+
+  QUnit.equal(this.requests.length, 0, 'no segment requests');
+});
+
+QUnit.test('obeys auto preload option', function() {
+  this.player.preload('auto');
+  // master
+  standardXHRResponse(this.requests.shift());
+  // playlist
+  standardXHRResponse(this.requests.shift());
+
+  openMediaSource(this.player, this.clock);
+
+  QUnit.equal(this.requests.length, 1, '1 segment request');
+});
+
+QUnit.test('obeys metadata preload option', function() {
+  this.player.preload('metadata');
+  // master
+  standardXHRResponse(this.requests.shift());
+  // playlist
+  standardXHRResponse(this.requests.shift());
+
+  openMediaSource(this.player, this.clock);
+
+  QUnit.equal(this.requests.length, 1, '1 segment request');
+});
+
+QUnit.test('clears some of the buffer for a fast quality change', function() {
+  let removes = [];
+
+  // master
+  standardXHRResponse(this.requests.shift());
+  // media
+  standardXHRResponse(this.requests.shift());
+  this.masterPlaylistController.mediaSource.trigger('sourceopen');
+
+  let segmentLoader = this.masterPlaylistController.mainSegmentLoader_;
+
+  segmentLoader.sourceUpdater_.remove = function(start, end) {
+    removes.push({ start, end });
+  };
+  this.masterPlaylistController.selectPlaylist = () => {
+    return this.masterPlaylistController.master().playlists[0];
+  };
+  this.masterPlaylistController.currentTimeFunc = () => 7;
+
+  this.masterPlaylistController.fastQualityChange_();
+
+  QUnit.equal(removes.length, 1, 'removed buffered content');
+  QUnit.equal(removes[0].start, 7 + 5, 'removed from a bit after current time');
+  QUnit.equal(removes[0].end, Infinity, 'removed to the end');
+});
+
+QUnit.test('does not clear the buffer when no fast quality change occurs', function() {
+  let removes = [];
+
+  // master
+  standardXHRResponse(this.requests.shift());
+  // media
+  standardXHRResponse(this.requests.shift());
+  this.masterPlaylistController.mediaSource.trigger('sourceopen');
+
+  let segmentLoader = this.masterPlaylistController.mainSegmentLoader_;
+
+  segmentLoader.sourceUpdater_.remove = function(start, end) {
+    removes.push({ start, end });
+  };
+
+  this.masterPlaylistController.fastQualityChange_();
+
+  QUnit.equal(removes.length, 0, 'did not remove content');
+});
+
+QUnit.test('if buffered, will request second segment byte range', function() {
+  this.requests.length = 0;
+  this.player.src({
+    src: 'manifest/playlist.m3u8',
+    type: 'application/vnd.apple.mpegurl'
+  });
+  this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
+
+  // mock that the user has played the video before
+  this.player.tech_.triggerReady();
+  this.clock.tick(1);
+  this.player.tech_.trigger('play');
+  this.player.tech_.played = () => videojs.createTimeRanges([[0, 20]]);
+
+  openMediaSource(this.player, this.clock);
+  // playlist
+  standardXHRResponse(this.requests[0]);
+
+  this.masterPlaylistController.mainSegmentLoader_.sourceUpdater_.buffered = () => {
+    return videojs.createTimeRanges([[0, 20]]);
+  };
+
+  // segment
+  standardXHRResponse(this.requests[1]);
+  this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
+  this.clock.tick(10 * 1000);
+  QUnit.equal(this.requests[2].headers.Range, 'bytes=1823412-2299991');
+});
+
+QUnit.test('re-initializes the combined playlist loader when switching sources',
+function() {
+  openMediaSource(this.player, this.clock);
+  // master
+  standardXHRResponse(this.requests.shift());
+  // playlist
+  standardXHRResponse(this.requests.shift());
+  // segment
+  standardXHRResponse(this.requests.shift());
+  // change the source
+  this.player.src({
+    src: 'manifest/master.m3u8',
+    type: 'application/vnd.apple.mpegurl'
+  });
+  this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
+  // maybe not needed if https://github.com/videojs/video.js/issues/2326 gets fixed
+  this.clock.tick(1);
+  QUnit.ok(!this.masterPlaylistController.masterPlaylistLoader_.media(),
+           'no media playlist');
+  QUnit.equal(this.masterPlaylistController.masterPlaylistLoader_.state,
+              'HAVE_NOTHING',
+              'reset the playlist loader state');
+  QUnit.equal(this.requests.length, 1, 'requested the new src');
+
+  // buffer check
+  this.clock.tick(10 * 1000);
+  QUnit.equal(this.requests.length, 1, 'did not request a stale segment');
+
+  // sourceopen
+  openMediaSource(this.player, this.clock);
+
+  QUnit.equal(this.requests.length, 1, 'made one request');
+  QUnit.ok(
+    this.requests[0].url.indexOf('master.m3u8') >= 0,
+      'requested only the new playlist'
+  );
+});
+
+QUnit.test('updates the combined segment loader on live playlist refreshes', function() {
+  let updates = [];
+
+  openMediaSource(this.player, this.clock);
+  // master
+  standardXHRResponse(this.requests.shift());
+  // media
+  standardXHRResponse(this.requests.shift());
+
+  this.masterPlaylistController.mainSegmentLoader_.playlist = function(update) {
+    updates.push(update);
+  };
+
+  this.masterPlaylistController.masterPlaylistLoader_.trigger('loadedplaylist');
+  QUnit.equal(updates.length, 1, 'updated the segment list');
+});
+
+QUnit.test(
+'fires a progress event after downloading a segment from combined segment loader',
+function() {
+  let progressCount = 0;
+
+  openMediaSource(this.player, this.clock);
+
+  // master
+  standardXHRResponse(this.requests.shift());
+  // media
+  standardXHRResponse(this.requests.shift());
+
+  this.player.tech_.on('progress', function() {
+    progressCount++;
+  });
+
+  // segment
+  standardXHRResponse(this.requests.shift());
+  this.masterPlaylistController.mainSegmentLoader_.trigger('progress');
+  QUnit.equal(progressCount, 1, 'fired a progress event');
+});
+
+QUnit.test('blacklists switching from video+audio playlists to audio only', function() {
+  let audioPlaylist;
+
+  openMediaSource(this.player, this.clock);
+
+  this.player.tech_.hls.bandwidth = 1e10;
+
+  // master
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="mp4a.40.2"\n' +
+                                'media.m3u8\n' +
+                                '#EXT-X-STREAM-INF:BANDWIDTH=10,RESOLUTION=1x1\n' +
+                                'media1.m3u8\n');
+  // media1
+  standardXHRResponse(this.requests.shift());
+
+  QUnit.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
+              this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1],
+              'selected video+audio');
+  audioPlaylist = this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0];
+  QUnit.equal(audioPlaylist.excludeUntil, Infinity, 'excluded incompatible playlist');
+});
+
+QUnit.test('blacklists switching from audio-only playlists to video+audio', function() {
+  let videoAudioPlaylist;
+
+  openMediaSource(this.player, this.clock);
+
+  this.player.tech_.hls.bandwidth = 1;
+  // master
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="mp4a.40.2"\n' +
+                                'media.m3u8\n' +
+                                '#EXT-X-STREAM-INF:BANDWIDTH=10,RESOLUTION=1x1\n' +
+                                'media1.m3u8\n');
+
+  // media1
+  standardXHRResponse(this.requests.shift());
+  QUnit.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
+              this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0],
+              'selected audio only');
+  videoAudioPlaylist =
+    this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
+  QUnit.equal(videoAudioPlaylist.excludeUntil,
+              Infinity,
+              'excluded incompatible playlist');
+});
+
+QUnit.test('blacklists switching from video-only playlists to video+audio', function() {
+  let videoAudioPlaylist;
+
+  openMediaSource(this.player, this.clock);
+
+  this.player.tech_.hls.bandwidth = 1;
+  // master
+  this.requests.shift()
+    .respond(200, null,
+             '#EXTM3U\n' +
+             '#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="avc1.4d400d"\n' +
+             'media.m3u8\n' +
+             '#EXT-X-STREAM-INF:BANDWIDTH=10,CODECS="avc1.4d400d,mp4a.40.2"\n' +
+             'media1.m3u8\n');
+
+  // media
+  standardXHRResponse(this.requests.shift());
+  QUnit.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
+              this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0],
+              'selected video only');
+  videoAudioPlaylist =
+    this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
+  QUnit.equal(videoAudioPlaylist.excludeUntil,
+              Infinity,
+              'excluded incompatible playlist');
+});
+
+QUnit.test('blacklists switching between playlists with incompatible audio codecs',
+function() {
+  let alternatePlaylist;
+
+  openMediaSource(this.player, this.clock);
+
+  this.player.tech_.hls.bandwidth = 1;
+  // master
+  this.requests.shift()
+    .respond(200, null,
+             '#EXTM3U\n' +
+             '#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="avc1.4d400d,mp4a.40.5"\n' +
+             'media.m3u8\n' +
+             '#EXT-X-STREAM-INF:BANDWIDTH=10,CODECS="avc1.4d400d,mp4a.40.2"\n' +
+             'media1.m3u8\n');
+
+  // media
+  standardXHRResponse(this.requests.shift());
+  QUnit.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
+              this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0],
+              'selected HE-AAC stream');
+  alternatePlaylist =
+    this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
+  QUnit.equal(alternatePlaylist.excludeUntil, Infinity, 'excluded incompatible playlist');
+});
+
+QUnit.test('updates the combined segment loader on media changes', function() {
+  let updates = [];
+
+  this.masterPlaylistController.mediaSource.trigger('sourceopen');
+
+  this.masterPlaylistController.mainSegmentLoader_.bandwidth = 1;
+
+  // master
+  standardXHRResponse(this.requests.shift());
+  // media
+  standardXHRResponse(this.requests.shift());
+
+  this.masterPlaylistController.mainSegmentLoader_.playlist = function(update) {
+    updates.push(update);
+  };
+
+  // downloading the new segment will update bandwidth and cause a
+  // playlist change
+  // segment 0
+  standardXHRResponse(this.requests.shift());
+  this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
+  // media
+  standardXHRResponse(this.requests.shift());
+  QUnit.equal(updates.length, 1, 'updated the segment list');
+});
+
+QUnit.test('selects a playlist after main/combined segment downloads', function() {
+  let calls = 0;
+
+  this.masterPlaylistController.selectPlaylist = () => {
+    calls++;
+    return this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0];
+  };
+  this.masterPlaylistController.mediaSource.trigger('sourceopen');
+
+  // master
+  standardXHRResponse(this.requests.shift());
+  // media
+  standardXHRResponse(this.requests.shift());
+
+  // "downloaded" a segment
+  this.masterPlaylistController.mainSegmentLoader_.trigger('progress');
+  QUnit.strictEqual(calls, 2, 'selects after the initial segment');
+
+  // and another
+  this.masterPlaylistController.mainSegmentLoader_.trigger('progress');
+  QUnit.strictEqual(calls, 3, 'selects after additional segments');
+});
+
+QUnit.test('updates the duration after switching playlists', function() {
+  let selectedPlaylist = false;
+
+  this.masterPlaylistController.mediaSource.trigger('sourceopen');
+
+  this.masterPlaylistController.bandwidth = 1e20;
+
+  // master
+  standardXHRResponse(this.requests[0]);
+  // media
+  standardXHRResponse(this.requests[1]);
+
+  this.masterPlaylistController.selectPlaylist = () => {
+    selectedPlaylist = true;
+
+    // this duration should be overwritten by the playlist change
+    this.masterPlaylistController.mediaSource.duration = 0;
+    this.masterPlaylistController.mediaSource.readyState = 'open';
+
+    return this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
+  };
+
+  // segment 0
+  standardXHRResponse(this.requests[2]);
+  this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
+  // media1
+  standardXHRResponse(this.requests[3]);
+  QUnit.ok(selectedPlaylist, 'selected playlist');
+  QUnit.ok(this.masterPlaylistController.mediaSource.duration !== 0,
+           'updates the duration');
+});
+
+QUnit.test('seekable uses the intersection of alternate audio and combined tracks',
+function() {
+  let origSeekable = Playlist.seekable;
+  let mainMedia = {};
+  let audioMedia = {};
+  let mainTimeRanges = [];
+  let audioTimeRanges = [];
+  let assertTimeRangesEqual = (left, right, message) => {
+    if (left.length === 0 && right.length === 0) {
+      return;
+    }
+
+    QUnit.equal(left.length, 1, message);
+    QUnit.equal(right.length, 1, message);
+
+    QUnit.equal(left.start(0), right.start(0), message);
+    QUnit.equal(left.end(0), right.end(0), message);
+  };
+
+  this.masterPlaylistController.masterPlaylistLoader_.media = () => mainMedia;
+
+  Playlist.seekable = (media) => {
+    if (media === mainMedia) {
+      return videojs.createTimeRanges(mainTimeRanges);
+    }
+    return videojs.createTimeRanges(audioTimeRanges);
+  };
+
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges(),
+                        'empty when main empty');
+  mainTimeRanges = [[0, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[0, 10]]),
+                        'main when no audio');
+
+  this.masterPlaylistController.audioPlaylistLoader_ = {
+    media: () => audioMedia,
+    expired_: 0
+  };
+
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges(),
+                        'empty when both empty');
+  mainTimeRanges = [[0, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges(),
+                        'empty when audio empty');
+  mainTimeRanges = [];
+  audioTimeRanges = [[0, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges(),
+                        'empty when main empty');
+  mainTimeRanges = [[0, 10]];
+  audioTimeRanges = [[0, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[0, 10]]),
+                        'ranges equal');
+  mainTimeRanges = [[5, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[5, 10]]),
+                        'main later start');
+  mainTimeRanges = [[0, 10]];
+  audioTimeRanges = [[5, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[5, 10]]),
+                        'audio later start');
+  mainTimeRanges = [[0, 9]];
+  audioTimeRanges = [[0, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[0, 9]]),
+                        'main earlier end');
+  mainTimeRanges = [[0, 10]];
+  audioTimeRanges = [[0, 9]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[0, 9]]),
+                        'audio earlier end');
+  mainTimeRanges = [[1, 10]];
+  audioTimeRanges = [[0, 9]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[1, 9]]),
+                        'main later start, audio earlier end');
+  mainTimeRanges = [[0, 9]];
+  audioTimeRanges = [[1, 10]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[1, 9]]),
+                        'audio later start, main earlier end');
+  mainTimeRanges = [[2, 9]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[2, 9]]),
+                        'main later start, main earlier end');
+  mainTimeRanges = [[1, 10]];
+  audioTimeRanges = [[2, 9]];
+  assertTimeRangesEqual(this.masterPlaylistController.seekable(),
+                        videojs.createTimeRanges([[2, 9]]),
+                        'audio later start, audio earlier end');
+
+  Playlist.seekable = origSeekable;
+});

-import sinon from 'sinon';
 import QUnit from 'qunit';
 import QUnit from 'qunit';
 import PlaylistLoader from '../src/playlist-loader';
 import PlaylistLoader from '../src/playlist-loader';
-import videojs from 'video.js';
 import xhrFactory from '../src/xhr';
 import xhrFactory from '../src/xhr';
+import { useFakeEnvironment } from './test-helpers';
+
 // Attempts to produce an absolute URL to a given relative path
 // Attempts to produce an absolute URL to a given relative path
 // based on window.location.href
 // based on window.location.href
 const urlTo = function(path) {
 const urlTo = function(path) {
@@ -15,28 +15,15 @@ const urlTo = function(path) {
 
 
 QUnit.module('Playlist Loader', {
 QUnit.module('Playlist Loader', {
   beforeEach() {
   beforeEach() {
-    // fake XHRs
-    this.oldXHR = videojs.xhr.XMLHttpRequest;
-    this.sinonXhr = sinon.useFakeXMLHttpRequest();
-    this.requests = [];
-    this.sinonXhr.onCreate = (xhr) => {
-      // force the XHR2 timeout polyfill
-      xhr.timeout = null;
-      this.requests.push(xhr);
-    };
-
-    // fake timers
-    this.clock = sinon.useFakeTimers();
-    videojs.xhr.XMLHttpRequest = this.sinonXhr;
-
+    this.env = useFakeEnvironment();
+    this.clock = this.env.clock;
+    this.requests = this.env.requests;
     this.fakeHls = {
     this.fakeHls = {
       xhr: xhrFactory()
       xhr: xhrFactory()
     };
     };
   },
   },
   afterEach() {
   afterEach() {
-    this.sinonXhr.restore();
-    this.clock.restore();
-    videojs.xhr.XMLHttpRequest = this.oldXHR;
+    this.env.restore();
   }
   }
 });
 });
 
 
@@ -52,12 +39,16 @@ QUnit.test('throws if the playlist url is empty or undefined', function() {
 QUnit.test('starts without any metadata', function() {
 QUnit.test('starts without any metadata', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   QUnit.strictEqual(loader.state, 'HAVE_NOTHING', 'no metadata has loaded yet');
   QUnit.strictEqual(loader.state, 'HAVE_NOTHING', 'no metadata has loaded yet');
 });
 });
 
 
 QUnit.test('starts with no expired time', function() {
 QUnit.test('starts with no expired time', function() {
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXTINF:10,\n' +
                               '#EXTINF:10,\n' +
@@ -68,9 +59,9 @@ QUnit.test('starts with no expired time', function() {
 });
 });
 
 
 QUnit.test('requests the initial playlist immediately', function() {
 QUnit.test('requests the initial playlist immediately', function() {
-  /* eslint-disable no-unused-vars */
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
-  /* eslint-enable no-unused-vars */
+
+  loader.load();
 
 
   QUnit.strictEqual(this.requests.length, 1, 'made a request');
   QUnit.strictEqual(this.requests.length, 1, 'made a request');
   QUnit.strictEqual(this.requests[0].url,
   QUnit.strictEqual(this.requests[0].url,
@@ -82,6 +73,8 @@ QUnit.test('moves to HAVE_MASTER after loading a master playlist', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let state;
   let state;
 
 
+  loader.load();
+
   loader.on('loadedplaylist', function() {
   loader.on('loadedplaylist', function() {
     state = loader.state;
     state = loader.state;
   });
   });
@@ -97,6 +90,8 @@ QUnit.test('jumps to HAVE_METADATA when initialized with a media playlist', func
   let loadedmetadatas = 0;
   let loadedmetadatas = 0;
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.on('loadedmetadata', function() {
   loader.on('loadedmetadata', function() {
     loadedmetadatas++;
     loadedmetadatas++;
   });
   });
@@ -113,10 +108,156 @@ QUnit.test('jumps to HAVE_METADATA when initialized with a media playlist', func
   QUnit.strictEqual(loadedmetadatas, 1, 'fired one loadedmetadata');
   QUnit.strictEqual(loadedmetadatas, 1, 'fired one loadedmetadata');
 });
 });
 
 
+QUnit.test('resolves relative media playlist URIs', function() {
+  let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:\n' +
+                                'video/media.m3u8\n');
+  QUnit.equal(loader.master.playlists[0].resolvedUri, urlTo('video/media.m3u8'),
+              'resolved media URI');
+});
+
+QUnit.test('recognizes absolute URIs and requests them unmodified', function() {
+  let loader = new PlaylistLoader('manifest/media.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:\n' +
+                                'http://example.com/video/media.m3u8\n');
+  QUnit.equal(loader.master.playlists[0].resolvedUri,
+              'http://example.com/video/media.m3u8', 'resolved media URI');
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXTINF:10,\n' +
+                                'http://example.com/00001.ts\n' +
+                                '#EXT-X-ENDLIST\n');
+  QUnit.equal(loader.media().segments[0].resolvedUri,
+              'http://example.com/00001.ts', 'resolved segment URI');
+});
+
+QUnit.test('recognizes domain-relative URLs', function() {
+  let loader = new PlaylistLoader('manifest/media.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:\n' +
+                                '/media.m3u8\n');
+  QUnit.equal(loader.master.playlists[0].resolvedUri,
+              window.location.protocol + '//' +
+              window.location.host + '/media.m3u8',
+              'resolved media URI');
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXTINF:10,\n' +
+                                '/00001.ts\n' +
+                                '#EXT-X-ENDLIST\n');
+  QUnit.equal(loader.media().segments[0].resolvedUri,
+              window.location.protocol + '//' +
+              window.location.host + '/00001.ts',
+              'resolved segment URI');
+});
+
+QUnit.test('recognizes key URLs relative to master and playlist', function() {
+  let loader = new PlaylistLoader('/video/media-encrypted.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=17\n' +
+                                'playlist/playlist.m3u8\n' +
+                                '#EXT-X-ENDLIST\n');
+  QUnit.equal(loader.master.playlists[0].resolvedUri,
+        window.location.protocol + '//' +
+        window.location.host + '/video/playlist/playlist.m3u8',
+        'resolved media URI');
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-TARGETDURATION:15\n' +
+                                '#EXT-X-KEY:METHOD=AES-128,URI="keys/key.php"\n' +
+                                '#EXTINF:2.833,\n' +
+                                'http://example.com/000001.ts\n' +
+                                '#EXT-X-ENDLIST\n');
+  QUnit.equal(loader.media().segments[0].key.resolvedUri,
+        window.location.protocol + '//' +
+        window.location.host + '/video/playlist/keys/key.php',
+        'resolved multiple relative paths for key URI');
+});
+
+QUnit.test('trigger an error event when a media playlist 404s', function() {
+  let count = 0;
+  let loader = new PlaylistLoader('manifest/master.m3u8', this.fakeHls);
+
+  loader.load();
+
+  loader.on('error', function() {
+    count += 1;
+  });
+
+  // master
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=17\n' +
+                                'playlist/playlist.m3u8\n' +
+                                '#EXT-X-STREAM-INF:PROGRAM-ID=2,BANDWIDTH=170\n' +
+                                'playlist/playlist2.m3u8\n' +
+                                '#EXT-X-ENDLIST\n');
+  QUnit.equal(count, 0,
+    'error not triggered before requesting playlist');
+
+  // playlist
+  this.requests.shift().respond(404);
+
+  QUnit.equal(count, 1,
+    'error triggered after playlist 404');
+});
+
+QUnit.test('recognizes absolute key URLs', function() {
+  let loader = new PlaylistLoader('/video/media-encrypted.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+                                '#EXTM3U\n' +
+                                '#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=17\n' +
+                                'playlist/playlist.m3u8\n' +
+                                '#EXT-X-ENDLIST\n');
+  QUnit.equal(loader.master.playlists[0].resolvedUri,
+        window.location.protocol + '//' +
+        window.location.host + '/video/playlist/playlist.m3u8',
+        'resolved media URI');
+
+  this.requests.shift().respond(
+    200,
+    null,
+    '#EXTM3U\n' +
+    '#EXT-X-TARGETDURATION:15\n' +
+    '#EXT-X-KEY:METHOD=AES-128,URI="http://example.com/keys/key.php"\n' +
+    '#EXTINF:2.833,\n' +
+    'http://example.com/000001.ts\n' +
+    '#EXT-X-ENDLIST\n'
+  );
+  QUnit.equal(loader.media().segments[0].key.resolvedUri,
+              'http://example.com/keys/key.php', 'resolved absolute path for key URI');
+});
+
 QUnit.test('jumps to HAVE_METADATA when initialized with a live media playlist',
 QUnit.test('jumps to HAVE_METADATA when initialized with a live media playlist',
 function() {
 function() {
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXTINF:10,\n' +
                               '#EXTINF:10,\n' +
@@ -131,6 +272,8 @@ QUnit.test('moves to HAVE_METADATA after loading a media playlist', function() {
   let loadedMetadata = 0;
   let loadedMetadata = 0;
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.on('loadedplaylist', function() {
   loader.on('loadedplaylist', function() {
     loadedPlaylist++;
     loadedPlaylist++;
   });
   });
@@ -164,6 +307,8 @@ QUnit.test('moves to HAVE_METADATA after loading a media playlist', function() {
 QUnit.test('moves to HAVE_CURRENT_METADATA when refreshing the playlist', function() {
 QUnit.test('moves to HAVE_CURRENT_METADATA when refreshing the playlist', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXTINF:10,\n' +
                               '#EXTINF:10,\n' +
@@ -180,6 +325,8 @@ QUnit.test('moves to HAVE_CURRENT_METADATA when refreshing the playlist', functi
 QUnit.test('returns to HAVE_METADATA after refreshing the playlist', function() {
 QUnit.test('returns to HAVE_METADATA after refreshing the playlist', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXTINF:10,\n' +
                               '#EXTINF:10,\n' +
@@ -197,6 +344,8 @@ QUnit.test('does not increment expired seconds before firstplay is triggered',
 function() {
 function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
@@ -227,6 +376,8 @@ function() {
 QUnit.test('increments expired seconds after a segment is removed', function() {
 QUnit.test('increments expired seconds after a segment is removed', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.trigger('firstplay');
   loader.trigger('firstplay');
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
@@ -258,6 +409,8 @@ QUnit.test('increments expired seconds after a segment is removed', function() {
 QUnit.test('increments expired seconds after a discontinuity', function() {
 QUnit.test('increments expired seconds after a discontinuity', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.trigger('firstplay');
   loader.trigger('firstplay');
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
@@ -306,6 +459,8 @@ QUnit.test('tracks expired seconds properly when two discontinuities expire at o
 function() {
 function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.trigger('firstplay');
   loader.trigger('firstplay');
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
@@ -334,6 +489,8 @@ QUnit.test('estimates expired if an entire window elapses between live playlist
 function() {
 function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.trigger('firstplay');
   loader.trigger('firstplay');
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
@@ -361,6 +518,8 @@ QUnit.test('emits an error when an initial playlist request fails', function() {
   let errors = [];
   let errors = [];
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.on('error', function() {
   loader.on('error', function() {
     errors.push(loader.error);
     errors.push(loader.error);
   });
   });
@@ -374,6 +533,8 @@ QUnit.test('errors when an initial media playlist request fails', function() {
   let errors = [];
   let errors = [];
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.on('error', function() {
   loader.on('error', function() {
     errors.push(loader.error);
     errors.push(loader.error);
   });
   });
@@ -393,9 +554,9 @@ QUnit.test('errors when an initial media playlist request fails', function() {
 // http://tools.ietf.org/html/draft-pantos-http-live-streaming-12#section-6.3.4
 // http://tools.ietf.org/html/draft-pantos-http-live-streaming-12#section-6.3.4
 QUnit.test('halves the refresh timeout if a playlist is unchanged since the last reload',
 QUnit.test('halves the refresh timeout if a playlist is unchanged since the last reload',
 function() {
 function() {
-  /* eslint-disable no-unused-vars */
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
-  /* eslint-enable no-unused-vars */
+
+  loader.load();
 
 
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
@@ -422,6 +583,8 @@ QUnit.test('preserves segment metadata across playlist refreshes', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let segment;
   let segment;
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
@@ -454,6 +617,8 @@ QUnit.test('clears the update timeout when switching quality', function() {
   let loader = new PlaylistLoader('live-master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live-master.m3u8', this.fakeHls);
   let refreshes = 0;
   let refreshes = 0;
 
 
+  loader.load();
+
   // track the number of playlist refreshes triggered
   // track the number of playlist refreshes triggered
   loader.on('mediaupdatetimeout', function() {
   loader.on('mediaupdatetimeout', function() {
     refreshes++;
     refreshes++;
@@ -485,9 +650,9 @@ QUnit.test('clears the update timeout when switching quality', function() {
 });
 });
 
 
 QUnit.test('media-sequence updates are considered a playlist change', function() {
 QUnit.test('media-sequence updates are considered a playlist change', function() {
-  /* eslint-disable no-unused-vars */
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
-  /* eslint-enable no-unused-vars */
+
+  loader.load();
 
 
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
@@ -512,6 +677,8 @@ QUnit.test('emits an error if a media refresh fails', function() {
   let errorResponseText = 'custom error message';
   let errorResponseText = 'custom error message';
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.on('error', function() {
   loader.on('error', function() {
     errors++;
     errors++;
   });
   });
@@ -534,6 +701,8 @@ QUnit.test('emits an error if a media refresh fails', function() {
 QUnit.test('switches media playlists when requested', function() {
 QUnit.test('switches media playlists when requested', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -563,6 +732,8 @@ QUnit.test('switches media playlists when requested', function() {
 QUnit.test('can switch playlists immediately after the master is downloaded', function() {
 QUnit.test('can switch playlists immediately after the master is downloaded', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   loader.on('loadedplaylist', function() {
   loader.on('loadedplaylist', function() {
     loader.media('high.m3u8');
     loader.media('high.m3u8');
   });
   });
@@ -578,6 +749,8 @@ QUnit.test('can switch playlists immediately after the master is downloaded', fu
 QUnit.test('can switch media playlists based on URI', function() {
 QUnit.test('can switch media playlists based on URI', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -607,6 +780,8 @@ QUnit.test('can switch media playlists based on URI', function() {
 QUnit.test('aborts in-flight playlist refreshes when switching', function() {
 QUnit.test('aborts in-flight playlist refreshes when switching', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -629,6 +804,8 @@ QUnit.test('aborts in-flight playlist refreshes when switching', function() {
 QUnit.test('switching to the active playlist is a no-op', function() {
 QUnit.test('switching to the active playlist is a no-op', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -649,6 +826,8 @@ QUnit.test('switching to the active playlist is a no-op', function() {
 QUnit.test('switching to the active live playlist is a no-op', function() {
 QUnit.test('switching to the active live playlist is a no-op', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -668,6 +847,8 @@ QUnit.test('switching to the active live playlist is a no-op', function() {
 QUnit.test('switches back to loaded playlists without re-requesting them', function() {
 QUnit.test('switches back to loaded playlists without re-requesting them', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -697,6 +878,8 @@ QUnit.test('aborts outstanding requests if switching back to an already loaded p
 function() {
 function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -731,6 +914,8 @@ QUnit.test('does not abort requests when the same playlist is re-requested',
 function() {
 function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -753,6 +938,8 @@ function() {
 QUnit.test('throws an error if a media switch is initiated too early', function() {
 QUnit.test('throws an error if a media switch is initiated too early', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   QUnit.throws(function() {
   QUnit.throws(function() {
     loader.media('high.m3u8');
     loader.media('high.m3u8');
   }, 'threw an error from HAVE_NOTHING');
   }, 'threw an error from HAVE_NOTHING');
@@ -769,6 +956,8 @@ QUnit.test('throws an error if a switch to an unrecognized playlist is requested
 function() {
 function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -782,6 +971,8 @@ function() {
 QUnit.test('dispose cancels the refresh timeout', function() {
 QUnit.test('dispose cancels the refresh timeout', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
@@ -797,6 +988,8 @@ QUnit.test('dispose cancels the refresh timeout', function() {
 QUnit.test('dispose aborts pending refresh requests', function() {
 QUnit.test('dispose aborts pending refresh requests', function() {
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('live.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
                               '#EXT-X-MEDIA-SEQUENCE:0\n' +
@@ -815,6 +1008,8 @@ QUnit.test('errors if requests take longer than 45s', function() {
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
   let errors = 0;
   let errors = 0;
 
 
+  loader.load();
+
   loader.on('error', function() {
   loader.on('error', function() {
     errors++;
     errors++;
   });
   });
@@ -827,10 +1022,16 @@ QUnit.test('errors if requests take longer than 45s', function() {
 QUnit.test('triggers an event when the active media changes', function() {
 QUnit.test('triggers an event when the active media changes', function() {
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('master.m3u8', this.fakeHls);
   let mediaChanges = 0;
   let mediaChanges = 0;
+  let mediaChangings = 0;
+
+  loader.load();
 
 
   loader.on('mediachange', function() {
   loader.on('mediachange', function() {
     mediaChanges++;
     mediaChanges++;
   });
   });
+  loader.on('mediachanging', function() {
+    mediaChangings++;
+  });
   this.requests.pop().respond(200, null,
   this.requests.pop().respond(200, null,
                               '#EXTM3U\n' +
                               '#EXTM3U\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
                               '#EXT-X-STREAM-INF:BANDWIDTH=1\n' +
@@ -843,9 +1044,11 @@ QUnit.test('triggers an event when the active media changes', function() {
                                 '#EXTINF:10,\n' +
                                 '#EXTINF:10,\n' +
                                 'low-0.ts\n' +
                                 'low-0.ts\n' +
                                 '#EXT-X-ENDLIST\n');
                                 '#EXT-X-ENDLIST\n');
+  QUnit.strictEqual(mediaChangings, 0, 'initial selection is not a media changing');
   QUnit.strictEqual(mediaChanges, 0, 'initial selection is not a media change');
   QUnit.strictEqual(mediaChanges, 0, 'initial selection is not a media change');
 
 
   loader.media('high.m3u8');
   loader.media('high.m3u8');
+  QUnit.strictEqual(mediaChangings, 1, 'mediachanging fires immediately');
   QUnit.strictEqual(mediaChanges, 0, 'mediachange does not fire immediately');
   QUnit.strictEqual(mediaChanges, 0, 'mediachange does not fire immediately');
 
 
   this.requests.shift().respond(200, null,
   this.requests.shift().respond(200, null,
@@ -854,166 +1057,25 @@ QUnit.test('triggers an event when the active media changes', function() {
                                 '#EXTINF:10,\n' +
                                 '#EXTINF:10,\n' +
                                 'high-0.ts\n' +
                                 'high-0.ts\n' +
                                 '#EXT-X-ENDLIST\n');
                                 '#EXT-X-ENDLIST\n');
+  QUnit.strictEqual(mediaChangings, 1, 'still one mediachanging');
   QUnit.strictEqual(mediaChanges, 1, 'fired a mediachange');
   QUnit.strictEqual(mediaChanges, 1, 'fired a mediachange');
 
 
   // switch back to an already loaded playlist
   // switch back to an already loaded playlist
   loader.media('low.m3u8');
   loader.media('low.m3u8');
+  QUnit.strictEqual(mediaChangings, 2, 'mediachanging fires');
   QUnit.strictEqual(mediaChanges, 2, 'fired a mediachange');
   QUnit.strictEqual(mediaChanges, 2, 'fired a mediachange');
 
 
   // trigger a no-op switch
   // trigger a no-op switch
   loader.media('low.m3u8');
   loader.media('low.m3u8');
+  QUnit.strictEqual(mediaChangings, 2, 'mediachanging ignored the no-op');
   QUnit.strictEqual(mediaChanges, 2, 'ignored a no-op media change');
   QUnit.strictEqual(mediaChanges, 2, 'ignored a no-op media change');
 });
 });
 
 
-QUnit.test('can get media index by playback position for non-live videos', function() {
-  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
-
-  this.requests.shift().respond(200, null,
-                                '#EXTM3U\n' +
-                                '#EXT-X-MEDIA-SEQUENCE:0\n' +
-                                '#EXTINF:4,\n' +
-                                '0.ts\n' +
-                                '#EXTINF:5,\n' +
-                                '1.ts\n' +
-                                '#EXTINF:6,\n' +
-                                '2.ts\n' +
-                                '#EXT-X-ENDLIST\n');
-
-  QUnit.equal(loader.getMediaIndexForTime_(-1),
-              0,
-              'the index is never less than zero');
-  QUnit.equal(loader.getMediaIndexForTime_(0), 0, 'time zero is index zero');
-  QUnit.equal(loader.getMediaIndexForTime_(3), 0, 'time three is index zero');
-  QUnit.equal(loader.getMediaIndexForTime_(10), 2, 'time 10 is index 2');
-  QUnit.equal(loader.getMediaIndexForTime_(22),
-              2,
-              'time greater than the length is index 2');
-});
-
-QUnit.test('returns the lower index when calculating for a segment boundary', function() {
-  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
-
-  this.requests.shift().respond(200, null,
-                                '#EXTM3U\n' +
-                                '#EXT-X-MEDIA-SEQUENCE:0\n' +
-                                '#EXTINF:4,\n' +
-                                '0.ts\n' +
-                                '#EXTINF:5,\n' +
-                                '1.ts\n' +
-                                '#EXT-X-ENDLIST\n');
-  QUnit.equal(loader.getMediaIndexForTime_(4), 1, 'rounds up exact matches');
-  QUnit.equal(loader.getMediaIndexForTime_(3.7), 0, 'rounds down');
-  QUnit.equal(loader.getMediaIndexForTime_(4.5), 1, 'rounds up at 0.5');
-});
-
-QUnit.test('accounts for non-zero starting segment time when calculating media index',
-function() {
-  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
-
-  this.requests.shift().respond(200, null,
-                                '#EXTM3U\n' +
-                                '#EXT-X-MEDIA-SEQUENCE:1001\n' +
-                                '#EXTINF:4,\n' +
-                                '1001.ts\n' +
-                                '#EXTINF:5,\n' +
-                                '1002.ts\n');
-  loader.media().segments[0].end = 154;
-
-  QUnit.equal(loader.getMediaIndexForTime_(0),
-              -1,
-              'the lowest returned value is  negative one');
-  QUnit.equal(loader.getMediaIndexForTime_(45),
-              -1,
-              'expired content returns negative one');
-  QUnit.equal(loader.getMediaIndexForTime_(75),
-              -1,
-              'expired content returns  negative one');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100),
-              0,
-              'calculates the earliest available position');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 2),
-              0,
-              'calculates within the first segment');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 4),
-              1,
-              'calculates within the second segment');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 4.5),
-              1,
-              'calculates within the second segment');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 6),
-              1,
-              'calculates within the second segment');
-});
-
-QUnit.test('prefers precise segment timing when tracking expired time', function() {
-  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
-
-  loader.trigger('firstplay');
-  this.requests.shift().respond(200, null,
-                                '#EXTM3U\n' +
-                                '#EXT-X-MEDIA-SEQUENCE:1001\n' +
-                                '#EXTINF:4,\n' +
-                                '1001.ts\n' +
-                                '#EXTINF:5,\n' +
-                                '1002.ts\n');
-  // setup the loader with an "imprecise" value as if it had been
-  // accumulating segment durations as they expire
-  loader.expired_ = 160;
-  // annotate the first segment with a start time
-  // this number would be coming from the Source Buffer in practice
-  loader.media().segments[0].end = 150;
-
-  QUnit.equal(loader.getMediaIndexForTime_(149),
-              0,
-              'prefers the value on the first segment');
-
-  // trigger a playlist refresh
-  this.clock.tick(10 * 1000);
-  this.requests.shift().respond(200, null,
-                                '#EXTM3U\n' +
-                                '#EXT-X-MEDIA-SEQUENCE:1002\n' +
-                                '#EXTINF:5,\n' +
-                                '1002.ts\n');
-  QUnit.equal(loader.getMediaIndexForTime_(150 + 4 + 1),
-              0,
-              'tracks precise expired times');
-});
-
-QUnit.test('accounts for expired time when calculating media index', function() {
-  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
-
-  this.requests.shift().respond(200, null,
-                                '#EXTM3U\n' +
-                                '#EXT-X-MEDIA-SEQUENCE:1001\n' +
-                                '#EXTINF:4,\n' +
-                                '1001.ts\n' +
-                                '#EXTINF:5,\n' +
-                                '1002.ts\n');
-  loader.expired_ = 150;
-
-  QUnit.equal(loader.getMediaIndexForTime_(0),
-              -1,
-              'expired content returns a negative index');
-  QUnit.equal(loader.getMediaIndexForTime_(75),
-              -1,
-              'expired content returns a negative index');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100),
-              0,
-              'calculates the earliest available position');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 2),
-              0,
-              'calculates within the first segment');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 4.5),
-              1,
-              'calculates within the second segment');
-  QUnit.equal(loader.getMediaIndexForTime_(50 + 100 + 6),
-              1,
-              'calculates within the second segment');
-});
-
 QUnit.test('does not misintrepret playlists missing newlines at the end', function() {
 QUnit.test('does not misintrepret playlists missing newlines at the end', function() {
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
   let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
 
 
+  loader.load();
+
   // no newline
   // no newline
   this.requests.shift().respond(200, null,
   this.requests.shift().respond(200, null,
                                 '#EXTM3U\n' +
                                 '#EXTM3U\n' +

 import Playlist from '../src/playlist';
 import Playlist from '../src/playlist';
+import PlaylistLoader from '../src/playlist-loader';
 import QUnit from 'qunit';
 import QUnit from 'qunit';
+import xhrFactory from '../src/xhr';
+import { useFakeEnvironment } from './test-helpers';
+
 QUnit.module('Playlist Duration');
 QUnit.module('Playlist Duration');
 
 
 QUnit.test('total duration for live playlists is Infinity', function() {
 QUnit.test('total duration for live playlists is Infinity', function() {
@@ -376,3 +380,251 @@ QUnit.test('seekable end accounts for non-standard target durations', function()
               9 - (2 + 2 + 1),
               9 - (2 + 2 + 1),
               'allows seeking no further than three segments from the end');
               'allows seeking no further than three segments from the end');
 });
 });
+
+QUnit.module('Playlist Media Index For Time', {
+  beforeEach() {
+    this.env = useFakeEnvironment();
+    this.clock = this.env.clock;
+    this.requests = this.env.requests;
+    this.fakeHls = {
+      xhr: xhrFactory()
+    };
+  },
+  afterEach() {
+    this.env.restore();
+  }
+});
+
+QUnit.test('can get media index by playback position for non-live videos', function() {
+  let media;
+  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+    '#EXTM3U\n' +
+    '#EXT-X-MEDIA-SEQUENCE:0\n' +
+    '#EXTINF:4,\n' +
+    '0.ts\n' +
+    '#EXTINF:5,\n' +
+    '1.ts\n' +
+    '#EXTINF:6,\n' +
+    '2.ts\n' +
+    '#EXT-X-ENDLIST\n'
+  );
+
+  media = loader.media();
+
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, -1), 0,
+              'the index is never less than zero');
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 0), 0, 'time zero is index zero');
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 3), 0, 'time three is index zero');
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 10), 2, 'time 10 is index 2');
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 22), 2,
+              'time greater than the length is index 2');
+});
+
+QUnit.test('returns the lower index when calculating for a segment boundary', function() {
+  let media;
+  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+    '#EXTM3U\n' +
+    '#EXT-X-MEDIA-SEQUENCE:0\n' +
+    '#EXTINF:4,\n' +
+    '0.ts\n' +
+    '#EXTINF:5,\n' +
+    '1.ts\n' +
+    '#EXT-X-ENDLIST\n'
+  );
+
+  media = loader.media();
+
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 4), 1, 'rounds up exact matches');
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 3.7), 0, 'rounds down');
+  QUnit.equal(Playlist.getMediaIndexForTime_(media, 4.5), 1, 'rounds up at 0.5');
+});
+
+QUnit.test(
+'accounts for non-zero starting segment time when calculating media index',
+function() {
+  let media;
+  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+    '#EXTM3U\n' +
+    '#EXT-X-MEDIA-SEQUENCE:1001\n' +
+    '#EXTINF:4,\n' +
+    '1001.ts\n' +
+    '#EXTINF:5,\n' +
+    '1002.ts\n'
+  );
+  loader.media().segments[0].end = 154;
+
+  media = loader.media();
+
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 0),
+    -1,
+    'the lowest returned value is  negative one'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 45),
+    -1,
+    'expired content returns negative one'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 75),
+    -1,
+    'expired content returns  negative one'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100),
+    0,
+    'calculates the earliest available position'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 2),
+    0,
+    'calculates within the first segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 2),
+    0,
+    'calculates within the first segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 4),
+    1,
+    'calculates within the second segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 4.5),
+    1,
+    'calculates within the second segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 6),
+    1,
+    'calculates within the second segment'
+  );
+
+  loader.media().segments[1].end = 159;
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 159),
+    2,
+    'returns number of segments when time is equal to end of last segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 159.1),
+    2,
+    'returns number of segments when time is past end of last segment'
+  );
+});
+
+QUnit.test('prefers precise segment timing when tracking expired time', function() {
+  let media;
+  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
+
+  loader.load();
+
+  loader.trigger('firstplay');
+  this.requests.shift().respond(200, null,
+    '#EXTM3U\n' +
+    '#EXT-X-MEDIA-SEQUENCE:1001\n' +
+    '#EXTINF:4,\n' +
+    '1001.ts\n' +
+    '#EXTINF:5,\n' +
+    '1002.ts\n'
+  );
+  // setup the loader with an "imprecise" value as if it had been
+  // accumulating segment durations as they expire
+  loader.expired_ = 160;
+  // annotate the first segment with a start time
+  // this number would be coming from the Source Buffer in practice
+  loader.media().segments[0].end = 150;
+
+  media = loader.media();
+
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 149),
+    0,
+    'prefers the value on the first segment'
+  );
+
+  // trigger a playlist refresh
+  this.clock.tick(10 * 1000);
+  this.requests.shift().respond(200, null,
+    '#EXTM3U\n' +
+    '#EXT-X-MEDIA-SEQUENCE:1002\n' +
+    '#EXTINF:5,\n' +
+    '1002.ts\n'
+  );
+
+  media = loader.media();
+
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 150 + 4 + 1),
+    0,
+    'tracks precise expired times'
+  );
+});
+
+QUnit.test('accounts for expired time when calculating media index', function() {
+  let media;
+  let loader = new PlaylistLoader('media.m3u8', this.fakeHls);
+  let expired = 150;
+
+  loader.load();
+
+  this.requests.shift().respond(200, null,
+    '#EXTM3U\n' +
+    '#EXT-X-MEDIA-SEQUENCE:1001\n' +
+    '#EXTINF:4,\n' +
+    '1001.ts\n' +
+    '#EXTINF:5,\n' +
+    '1002.ts\n'
+  );
+
+  media = loader.media();
+
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 0, expired),
+    -1,
+    'expired content returns a negative index'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 75, expired),
+    -1,
+    'expired content returns a negative index'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100, expired),
+    0,
+    'calculates the earliest available position'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 2, expired),
+    0,
+    'calculates within the first segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 2, expired),
+    0,
+    'calculates within the first segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 4.5, expired),
+    1,
+    'calculates within the second segment'
+  );
+  QUnit.equal(
+    Playlist.getMediaIndexForTime_(media, 50 + 100 + 6, expired),
+    1,
+    'calculates within the second segment'
+  );
+});

+import Ranges from '../src/ranges';
+import {createTimeRanges} from 'video.js';
+import QUnit from 'qunit';
+
+QUnit.module('TimeRanges Utilities');
+
+QUnit.test('finds the overlapping time range', function() {
+  let range = Ranges.findRange(createTimeRanges([[0, 5], [6, 12]]), 3);
+
+  QUnit.equal(range.length, 1, 'found one range');
+  QUnit.equal(range.end(0), 5, 'inside the first buffered region');
+
+  range = Ranges.findRange(createTimeRanges([[0, 5], [6, 12]]), 6);
+  QUnit.equal(range.length, 1, 'found one range');
+  QUnit.equal(range.end(0), 12, 'inside the second buffered region');
+});
+
+QUnit.module('Buffer Inpsection');
+
+QUnit.test('detects time range end-point changed by updates', function() {
+  let edge;
+
+  // Single-range changes
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10]]),
+                                              createTimeRanges([[0, 11]]));
+  QUnit.strictEqual(edge, 11, 'detected a forward addition');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[5, 10]]),
+                                              createTimeRanges([[0, 10]]));
+  QUnit.strictEqual(edge, null, 'ignores backward addition');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[5, 10]]),
+                                              createTimeRanges([[0, 11]]));
+  QUnit.strictEqual(edge, 11,
+                    'detected a forward addition & ignores a backward addition');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10]]),
+                                              createTimeRanges([[0, 9]]));
+  QUnit.strictEqual(edge, null,
+                    'ignores a backwards addition resulting from a shrinking range');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10]]),
+                                              createTimeRanges([[2, 7]]));
+  QUnit.strictEqual(edge, null,
+                    'ignores a forward & backwards addition resulting from a shrinking ' +
+                    'range');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[2, 10]]),
+                                              createTimeRanges([[0, 7]]));
+  QUnit.strictEqual(
+    edge,
+    null,
+    'ignores a forward & backwards addition resulting from a range shifted backward'
+  );
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[2, 10]]),
+                                              createTimeRanges([[5, 15]]));
+  QUnit.strictEqual(edge, 15,
+                    'detected a forwards addition resulting from a range shifted foward');
+
+  // Multiple-range changes
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10]]),
+                                              createTimeRanges([[0, 11], [12, 15]]));
+  QUnit.strictEqual(edge, null, 'ignores multiple new forward additions');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10], [20, 40]]),
+                                              createTimeRanges([[20, 50]]));
+  QUnit.strictEqual(edge, 50, 'detected a forward addition & ignores range removal');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10], [20, 40]]),
+                                              createTimeRanges([[0, 50]]));
+  QUnit.strictEqual(edge, 50, 'detected a forward addition & ignores merges');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 10], [20, 40]]),
+                                              createTimeRanges([[0, 40]]));
+  QUnit.strictEqual(edge, null, 'ignores merges');
+
+  // Empty input
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges(),
+                                              createTimeRanges([[0, 11]]));
+  QUnit.strictEqual(edge, 11, 'handle an empty original TimeRanges object');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 11]]),
+                                              createTimeRanges());
+  QUnit.strictEqual(edge, null, 'handle an empty update TimeRanges object');
+
+  // Null input
+  edge = Ranges.findSoleUncommonTimeRangesEnd(null, createTimeRanges([[0, 11]]));
+  QUnit.strictEqual(edge, 11, 'treat null original buffer as an empty TimeRanges object');
+
+  edge = Ranges.findSoleUncommonTimeRangesEnd(createTimeRanges([[0, 11]]), null);
+  QUnit.strictEqual(edge, null, 'treat null update buffer as an empty TimeRanges object');
+});

+import QUnit from 'qunit';
+import {GOAL_BUFFER_LENGTH, default as SegmentLoader} from '../src/segment-loader';
+import videojs from 'video.js';
+import xhrFactory from '../src/xhr';
+import { useFakeEnvironment, useFakeMediaSource } from './test-helpers.js';
+
+const playlistWithDuration = function(time, conf) {
+  let result = {
+    mediaSequence: conf && conf.mediaSequence ? conf.mediaSequence : 0,
+    discontinuityStarts: [],
+    segments: [],
+    endList: true
+  };
+  let count = Math.floor(time / 10);
+  let remainder = time % 10;
+  let i;
+  let isEncrypted = conf && conf.isEncrypted;
+
+  for (i = 0; i < count; i++) {
+    result.segments.push({
+      uri: i + '.ts',
+      resolvedUri: i + '.ts',
+      duration: 10
+    });
+    if (isEncrypted) {
+      result.segments[i].key = {
+        uri: i + '-key.php',
+        resolvedUri: i + '-key.php'
+      };
+    }
+  }
+  if (remainder) {
+    result.segments.push({
+      uri: i + '.ts',
+      duration: remainder
+    });
+  }
+  return result;
+};
+
+let currentTime;
+let mediaSource;
+let loader;
+
+QUnit.module('Segment Loader', {
+  beforeEach() {
+    this.env = useFakeEnvironment();
+    this.clock = this.env.clock;
+    this.requests = this.env.requests;
+    this.mse = useFakeMediaSource();
+    this.seekable = {
+      length: 0
+    };
+    this.mimeType = 'video/mp2t';
+    this.fakeHls = {
+      xhr: xhrFactory()
+    };
+
+    currentTime = 0;
+    mediaSource = new videojs.MediaSource();
+    mediaSource.trigger('sourceopen');
+    loader = new SegmentLoader({
+      hls: this.fakeHls,
+      currentTime() {
+        return currentTime;
+      },
+      seekable: () => this.seekable,
+      seeking: () => false,
+      hasPlayed: () => true,
+      mediaSource
+    });
+  },
+  afterEach() {
+    this.env.restore();
+    this.mse.restore();
+  }
+});
+
+QUnit.test('fails without required initialization options', function() {
+  /* eslint-disable no-new */
+  QUnit.throws(function() {
+    new SegmentLoader();
+  }, 'requires options');
+  QUnit.throws(function() {
+    new SegmentLoader({});
+  }, 'requires a currentTime callback');
+  QUnit.throws(function() {
+    new SegmentLoader({
+      currentTime() {}
+    });
+  }, 'requires a media source');
+  /* eslint-enable */
+});
+
+QUnit.test('load waits until a playlist and mime type are specified to proceed',
+function() {
+  loader.load();
+  QUnit.equal(loader.state, 'INIT', 'waiting in init');
+  QUnit.equal(loader.paused(), false, 'not paused');
+
+  loader.playlist(playlistWithDuration(10));
+  QUnit.equal(this.requests.length, 0, 'have not made a request yet');
+  loader.mimeType(this.mimeType);
+
+  QUnit.equal(this.requests.length, 1, 'made a request');
+  QUnit.equal(loader.state, 'WAITING', 'transitioned states');
+});
+
+QUnit.test('calling mime type and load begins buffering', function() {
+  QUnit.equal(loader.state, 'INIT', 'starts in the init state');
+  loader.playlist(playlistWithDuration(10));
+  QUnit.equal(loader.state, 'INIT', 'starts in the init state');
+  QUnit.ok(loader.paused(), 'starts paused');
+
+  loader.mimeType(this.mimeType);
+  QUnit.equal(loader.state, 'INIT', 'still in the init state');
+  loader.load();
+
+  QUnit.equal(loader.state, 'WAITING', 'moves to the ready state');
+  QUnit.ok(!loader.paused(), 'loading is not paused');
+  QUnit.equal(this.requests.length, 1, 'requested a segment');
+});
+
+QUnit.test('calling load is idempotent', function() {
+  loader.playlist(playlistWithDuration(20));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  QUnit.equal(loader.state, 'WAITING', 'moves to the ready state');
+  QUnit.equal(this.requests.length, 1, 'made one request');
+
+  loader.load();
+  QUnit.equal(loader.state, 'WAITING', 'still in the ready state');
+  QUnit.equal(this.requests.length, 1, 'still one request');
+
+  // some time passes and a response is received
+  this.clock.tick(100);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  loader.load();
+  QUnit.equal(this.requests.length, 0, 'load has no effect');
+});
+
+QUnit.test('calling load should unpause', function() {
+  let sourceBuffer;
+
+  loader.playlist(playlistWithDuration(20));
+  loader.pause();
+
+  loader.mimeType(this.mimeType);
+  sourceBuffer = mediaSource.sourceBuffers[0];
+
+  loader.load();
+  QUnit.equal(loader.paused(), false, 'loading unpauses');
+
+  loader.pause();
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+
+  QUnit.equal(loader.paused(), true, 'stayed paused');
+  loader.load();
+  QUnit.equal(loader.paused(), false, 'unpaused during processing');
+
+  loader.pause();
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(loader.state, 'READY', 'finished processing');
+  QUnit.ok(loader.paused(), 'stayed paused');
+
+  loader.load();
+  QUnit.equal(loader.paused(), false, 'unpaused');
+});
+
+QUnit.test('regularly checks the buffer while unpaused', function() {
+  let sourceBuffer;
+
+  loader.playlist(playlistWithDuration(90));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  sourceBuffer = mediaSource.sourceBuffers[0];
+
+  // fill the buffer
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  sourceBuffer.buffered = videojs.createTimeRanges([[
+    0, GOAL_BUFFER_LENGTH
+  ]]);
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(this.requests.length, 0, 'no outstanding requests');
+
+  // play some video to drain the buffer
+  currentTime = GOAL_BUFFER_LENGTH;
+  this.clock.tick(10 * 1000);
+  QUnit.equal(this.requests.length, 1, 'requested another segment');
+});
+
+QUnit.test('does not check the buffer while paused', function() {
+  let sourceBuffer;
+
+  loader.playlist(playlistWithDuration(90));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  sourceBuffer = mediaSource.sourceBuffers[0];
+
+  loader.pause();
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  sourceBuffer.trigger('updateend');
+
+  this.clock.tick(10 * 1000);
+  QUnit.equal(this.requests.length, 0, 'did not make a request');
+});
+
+QUnit.test('calculates bandwidth after downloading a segment', function() {
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // some time passes and a response is received
+  this.clock.tick(100);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+
+  QUnit.equal(loader.bandwidth, (10 / 100) * 8 * 1000, 'calculated bandwidth');
+  QUnit.equal(loader.roundTrip, 100, 'saves request round trip time');
+  QUnit.equal(loader.bytesReceived, 10, 'saves bytes received');
+});
+
+QUnit.test('segment request timeouts reset bandwidth', function() {
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // a lot of time passes so the request times out
+  this.requests[0].timedout = true;
+  this.clock.tick(100 * 1000);
+
+  QUnit.equal(loader.bandwidth, 1, 'reset bandwidth');
+  QUnit.ok(isNaN(loader.roundTrip), 'reset round trip time');
+});
+
+QUnit.test('appending a segment triggers progress', function() {
+  let progresses = 0;
+
+  loader.on('progress', function() {
+    progresses++;
+  });
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // some time passes and a response is received
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  mediaSource.sourceBuffers[0].trigger('updateend');
+
+  QUnit.equal(progresses, 1, 'fired progress');
+});
+
+QUnit.test('only requests one segment at a time', function() {
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // a bunch of time passes without recieving a response
+  this.clock.tick(20 * 1000);
+  QUnit.equal(this.requests.length, 1, 'only one request was made');
+});
+
+QUnit.test('only appends one segment at a time', function() {
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // some time passes and a segment is received
+  this.clock.tick(100);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+
+  // a lot of time goes by without "updateend"
+  this.clock.tick(20 * 1000);
+
+  QUnit.equal(mediaSource.sourceBuffers[0].updates_.filter(
+    update => update.append).length, 1, 'only one append');
+  QUnit.equal(this.requests.length, 0, 'only made one request');
+});
+
+QUnit.test('adjusts the playlist offset if no buffering progress is made', function() {
+  let sourceBuffer;
+  let playlist;
+
+  playlist = playlistWithDuration(40);
+  playlist.endList = false;
+  loader.playlist(playlist);
+  loader.mimeType(this.mimeType);
+  loader.load();
+  sourceBuffer = mediaSource.sourceBuffers[0];
+
+  // buffer some content and switch playlists on progress
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  loader.on('progress', function f() {
+    loader.off('progress', f);
+    // switch playlists
+    playlist = playlistWithDuration(40);
+    playlist.uri = 'alternate.m3u8';
+    playlist.endList = false;
+    loader.playlist(playlist);
+  });
+  sourceBuffer.buffered = videojs.createTimeRanges([[0, 5]]);
+  sourceBuffer.trigger('updateend');
+
+  // the next segment doesn't increase the buffer at all
+  QUnit.equal(this.requests[0].url, '0.ts', 'requested the same segment');
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  sourceBuffer.trigger('updateend');
+
+  // so the loader should try the next segment
+  QUnit.equal(this.requests[0].url, '1.ts', 'moved ahead a segment');
+});
+
+QUnit.test('never attempt to load a segment that ' +
+           'is greater than 90% buffered', function() {
+  let sourceBuffer;
+  let playlist;
+
+  playlist = playlistWithDuration(40);
+  playlist.endList = false;
+  loader.playlist(playlist);
+  loader.mimeType(this.mimeType);
+  loader.load();
+  sourceBuffer = mediaSource.sourceBuffers[0];
+
+  // buffer some content and switch playlists on progress
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  loader.on('progress', function f() {
+    loader.off('progress', f);
+    // switch playlists
+    playlist = playlistWithDuration(40);
+    playlist.uri = 'alternate.m3u8';
+    playlist.endList = false;
+    loader.playlist(playlist);
+  });
+  sourceBuffer.buffered = videojs.createTimeRanges([[0, 9.2]]);
+  sourceBuffer.trigger('updateend');
+
+  // the next segment doesn't increase the buffer at all
+  QUnit.equal(this.requests[0].url, '1.ts', 'requested the next segment');
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  sourceBuffer.trigger('updateend');
+
+  // so the loader should try the next segment
+  QUnit.equal(this.requests[0].url, '1.ts', 'moved ahead a segment');
+});
+
+QUnit.test('adjusts the playlist offset if no buffering progress is made', function() {
+  let sourceBuffer;
+  let playlist;
+
+  playlist = playlistWithDuration(40);
+  playlist.endList = false;
+  loader.playlist(playlist);
+  loader.mimeType(this.mimeType);
+  loader.load();
+  sourceBuffer = mediaSource.sourceBuffers[0];
+
+  // buffer some content and switch playlists on progress
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  loader.on('progress', function f() {
+    loader.off('progress', f);
+    // switch playlists
+    playlist = playlistWithDuration(40);
+    playlist.uri = 'alternate.m3u8';
+    playlist.endList = false;
+    loader.playlist(playlist);
+  });
+  sourceBuffer.buffered = videojs.createTimeRanges([[0, 5]]);
+  sourceBuffer.trigger('updateend');
+
+  // the next segment doesn't increase the buffer at all
+  QUnit.equal(this.requests[0].url, '0.ts', 'requested the same segment');
+  this.clock.tick(1);
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  sourceBuffer.trigger('updateend');
+
+  // so the loader should try the next segment
+  QUnit.equal(this.requests[0].url, '1.ts', 'moved ahead a segment');
+});
+
+QUnit.test('cancels outstanding requests on abort', function() {
+  loader.playlist(playlistWithDuration(20));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.xhr_.segmentXhr.onreadystatechange = function() {
+    throw new Error('onreadystatechange should not be called');
+  };
+
+  loader.abort();
+  QUnit.ok(this.requests[0].aborted, 'aborted the first request');
+  QUnit.equal(this.requests.length, 2, 'started a new request');
+  QUnit.equal(loader.state, 'WAITING', 'back to the waiting state');
+});
+
+QUnit.test('abort does not cancel segment processing in progress', function() {
+  loader.playlist(playlistWithDuration(20));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+
+  loader.abort();
+  QUnit.equal(loader.state, 'APPENDING', 'still appending');
+});
+
+QUnit.test('sets the timestampOffset on timeline change', function() {
+  let playlist = playlistWithDuration(40);
+
+  playlist.discontinuityStarts = [1];
+  playlist.segments[1].timeline = 1;
+  loader.playlist(playlist);
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // segment 0
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  mediaSource.sourceBuffers[0].buffered = videojs.createTimeRanges([[0, 10]]);
+  mediaSource.sourceBuffers[0].trigger('updateend');
+
+  // segment 1, discontinuity
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  QUnit.equal(mediaSource.sourceBuffers[0].timestampOffset, 10, 'set timestampOffset');
+});
+
+QUnit.test('tracks segment end times as they are buffered', function() {
+  let playlist = playlistWithDuration(20);
+
+  loader.playlist(playlist);
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+
+  mediaSource.sourceBuffers[0].buffered = videojs.createTimeRanges([
+    [0, 9.5]
+  ]);
+  mediaSource.sourceBuffers[0].trigger('updateend');
+  QUnit.equal(playlist.segments[0].end, 9.5, 'updated duration');
+});
+
+QUnit.test('segment 404s should trigger an error', function() {
+  let errors = [];
+
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.on('error', function(error) {
+    errors.push(error);
+  });
+  this.requests.shift().respond(404, null, '');
+
+  QUnit.equal(errors.length, 1, 'triggered an error');
+  QUnit.equal(loader.error().code, 2, 'triggered MEDIA_ERR_NETWORK');
+  QUnit.ok(loader.error().xhr, 'included the request object');
+  QUnit.ok(loader.paused(), 'paused the loader');
+  QUnit.equal(loader.state, 'READY', 'returned to the ready state');
+});
+
+QUnit.test('segment 5xx status codes trigger an error', function() {
+  let errors = [];
+
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.on('error', function(error) {
+    errors.push(error);
+  });
+  this.requests.shift().respond(500, null, '');
+
+  QUnit.equal(errors.length, 1, 'triggered an error');
+  QUnit.equal(loader.error().code, 2, 'triggered MEDIA_ERR_NETWORK');
+  QUnit.ok(loader.error().xhr, 'included the request object');
+  QUnit.ok(loader.paused(), 'paused the loader');
+  QUnit.equal(loader.state, 'READY', 'returned to the ready state');
+});
+
+QUnit.test('fires ended at the end of a playlist', function() {
+  let endOfStreams = 0;
+
+  loader.playlist(playlistWithDuration(10));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.mediaSource_ = {
+    readyState: 'open',
+    sourceBuffers: mediaSource.sourceBuffers,
+    endOfStream() {
+      endOfStreams++;
+    }
+  };
+
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  mediaSource.sourceBuffers[0].buffered = videojs.createTimeRanges([[0, 10]]);
+  mediaSource.sourceBuffers[0].trigger('updateend');
+  QUnit.equal(endOfStreams, 1, 'triggered ended');
+});
+
+QUnit.test('live playlists do not trigger ended', function() {
+  let endOfStreams = 0;
+  let playlist;
+
+  playlist = playlistWithDuration(10);
+  playlist.endList = false;
+  loader.playlist(playlist);
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.mediaSource_ = {
+    readyState: 'open',
+    sourceBuffers: mediaSource.sourceBuffers,
+    endOfStream() {
+      endOfStreams++;
+    }
+  };
+
+  this.requests[0].response = new Uint8Array(10).buffer;
+  this.requests.shift().respond(200, null, '');
+  mediaSource.sourceBuffers[0].buffered = videojs.createTimeRanges([[0, 10]]);
+  mediaSource.sourceBuffers[0].trigger('updateend');
+  QUnit.equal(endOfStreams, 0, 'did not trigger ended');
+});
+
+QUnit.test('respects the global withCredentials option', function() {
+  let hlsOptions = videojs.options.hls;
+
+  videojs.options.hls = {
+    withCredentials: true
+  };
+  loader = new SegmentLoader({
+    hls: this.fakeHls,
+    currentTime() {
+      return currentTime;
+    },
+    seekable: () => this.seekable,
+    mediaSource
+  });
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.ok(this.requests[0].withCredentials, 'key request used withCredentials');
+  QUnit.equal(this.requests[1].url, '0.ts', 'requested the first segment');
+  QUnit.ok(this.requests[1].withCredentials, 'segment request used withCredentials');
+  videojs.options.hls = hlsOptions;
+});
+
+QUnit.test('respects the withCredentials option', function() {
+  loader = new SegmentLoader({
+    hls: this.fakeHls,
+    currentTime() {
+      return currentTime;
+    },
+    seekable: () => this.seekable,
+    mediaSource,
+    withCredentials: true
+  });
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.ok(this.requests[0].withCredentials, 'key request used withCredentials');
+  QUnit.equal(this.requests[1].url, '0.ts', 'requested the first segment');
+  QUnit.ok(this.requests[1].withCredentials, 'segment request used withCredentials');
+});
+
+QUnit.test('the withCredentials option overrides the global', function() {
+  let hlsOptions = videojs.options.hls;
+
+  videojs.options.hls = {
+    withCredentials: true
+  };
+  loader = new SegmentLoader({
+    hls: this.fakeHls,
+    currentTime() {
+      return currentTime;
+    },
+    mediaSource,
+    seekable: () => this.seekable,
+    withCredentials: false
+  });
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.ok(!this.requests[0].withCredentials, 'overrode key request withCredentials');
+  QUnit.equal(this.requests[1].url, '0.ts', 'requested the first segment');
+  QUnit.ok(!this.requests[1].withCredentials, 'overrode segment request withCredentials');
+  videojs.options.hls = hlsOptions;
+});
+
+QUnit.test('remains ready if there are no segments', function() {
+  loader.playlist(playlistWithDuration(0));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  QUnit.equal(loader.state, 'READY', 'in the ready state');
+});
+
+QUnit.test('dispose cleans up outstanding work', function() {
+  loader.playlist(playlistWithDuration(20));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  loader.dispose();
+  QUnit.ok(this.requests[0].aborted, 'aborted segment request');
+  QUnit.equal(this.requests.length, 1, 'did not open another request');
+  mediaSource.sourceBuffers.forEach((sourceBuffer, i) => {
+    let lastOperation = sourceBuffer.updates_.slice(-1)[0];
+
+    QUnit.ok(lastOperation.abort, 'aborted source buffer ' + i);
+  });
+});
+
+// ----------
+// Decryption
+// ----------
+
+QUnit.test('calling load with an encrypted segment requests key and segment', function() {
+  QUnit.equal(loader.state, 'INIT', 'starts in the init state');
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  QUnit.equal(loader.state, 'INIT', 'starts in the init state');
+  QUnit.ok(loader.paused(), 'starts paused');
+
+  loader.mimeType(this.mimeType);
+  loader.load();
+  QUnit.equal(loader.state, 'WAITING', 'moves to the ready state');
+  QUnit.ok(!loader.paused(), 'loading is not paused');
+  QUnit.equal(this.requests.length, 2, 'requested a segment and key');
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.equal(this.requests[1].url, '0.ts', 'requested the first segment');
+});
+
+QUnit.test('cancels outstanding key request on abort', function() {
+  loader.playlist(playlistWithDuration(20, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.xhr_.keyXhr.onreadystatechange = function() {
+    throw new Error('onreadystatechange should not be called');
+  };
+
+  QUnit.equal(this.requests.length, 2, 'requested a segment and key');
+  loader.abort();
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.ok(this.requests[0].aborted, 'aborted the first key request');
+  QUnit.equal(this.requests.length, 4, 'started a new request');
+  QUnit.equal(loader.state, 'WAITING', 'back to the waiting state');
+});
+
+QUnit.test('dispose cleans up key requests for encrypted segments', function() {
+  loader.playlist(playlistWithDuration(20, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  loader.dispose();
+  QUnit.equal(this.requests.length, 2, 'requested a segment and key');
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.ok(this.requests[0].aborted, 'aborted the first segment\s key request');
+  QUnit.equal(this.requests.length, 2, 'did not open another request');
+});
+
+QUnit.test('key 404s should trigger an error', function() {
+  let errors = [];
+
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.on('error', function(error) {
+    errors.push(error);
+  });
+  this.requests.shift().respond(404, null, '');
+
+  QUnit.equal(errors.length, 1, 'triggered an error');
+  QUnit.equal(loader.error().code, 2, 'triggered MEDIA_ERR_NETWORK');
+  QUnit.equal(loader.error().message, 'HLS key request error at URL: 0-key.php',
+        'receieved a key error message');
+  QUnit.ok(loader.error().xhr, 'included the request object');
+  QUnit.ok(loader.paused(), 'paused the loader');
+  QUnit.equal(loader.state, 'READY', 'returned to the ready state');
+});
+
+QUnit.test('key 5xx status codes trigger an error', function() {
+  let errors = [];
+
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+  loader.on('error', function(error) {
+    errors.push(error);
+  });
+  this.requests.shift().respond(500, null, '');
+
+  QUnit.equal(errors.length, 1, 'triggered an error');
+  QUnit.equal(loader.error().code, 2, 'triggered MEDIA_ERR_NETWORK');
+  QUnit.equal(loader.error().message, 'HLS key request error at URL: 0-key.php',
+        'receieved a key error message');
+  QUnit.ok(loader.error().xhr, 'included the request object');
+  QUnit.ok(loader.paused(), 'paused the loader');
+  QUnit.equal(loader.state, 'READY', 'returned to the ready state');
+});
+
+QUnit.test('the key is saved to the segment in the correct format', function() {
+  let keyRequest;
+  let segmentRequest;
+  let segment;
+  let segmentInfo;
+
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // stop processing so we can examine segment info
+  loader.processResponse_ = function() {};
+
+  keyRequest = this.requests.shift();
+  keyRequest.response = new Uint32Array([0, 1, 2, 3]).buffer;
+  keyRequest.respond(200, null, '');
+
+  segmentRequest = this.requests.shift();
+  segmentRequest.response = new Uint8Array(10).buffer;
+  segmentRequest.respond(200, null, '');
+
+  segmentInfo = loader.pendingSegment_;
+  segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
+
+  QUnit.deepEqual(segment.key.bytes,
+                  new Uint32Array([0, 0x01000000, 0x02000000, 0x03000000]),
+                  'passed the specified segment key');
+});
+
+QUnit.test('supplies media sequence of current segment as the IV by default, if no IV ' +
+           'is specified',
+function() {
+  let keyRequest;
+  let segmentRequest;
+  let segment;
+  let segmentInfo;
+
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true, mediaSequence: 5}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  // stop processing so we can examine segment info
+  loader.processResponse_ = function() {};
+
+  keyRequest = this.requests.shift();
+  keyRequest.response = new Uint32Array([0, 0, 0, 0]).buffer;
+  keyRequest.respond(200, null, '');
+
+  segmentRequest = this.requests.shift();
+  segmentRequest.response = new Uint8Array(10).buffer;
+  segmentRequest.respond(200, null, '');
+
+  segmentInfo = loader.pendingSegment_;
+  segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
+
+  QUnit.deepEqual(segment.key.iv, new Uint32Array([0, 0, 0, 5]),
+                  'the IV for the segment is the media sequence');
+});
+
+QUnit.test('segment with key has decrypted bytes appended during processing', function() {
+  let keyRequest;
+  let segmentRequest;
+
+  // stop processing so we can examine segment info
+  loader.handleSegment_ = function() {};
+
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  segmentRequest = this.requests.pop();
+  segmentRequest.response = new Uint8Array(8).buffer;
+  segmentRequest.respond(200, null, '');
+  QUnit.ok(loader.pendingSegment_.encryptedBytes, 'encrypted bytes in segment');
+  QUnit.ok(!loader.pendingSegment_.bytes, 'no decrypted bytes in segment');
+
+  keyRequest = this.requests.shift();
+  keyRequest.response = new Uint32Array([0, 0, 0, 0]).buffer;
+  keyRequest.respond(200, null, '');
+
+  // Allow the decrypter to decrypt
+  this.clock.tick(1);
+  // Allow the decrypter's async stream to run the callback
+  this.clock.tick(1);
+  QUnit.ok(loader.pendingSegment_.bytes, 'decrypted bytes in segment');
+});
+
+QUnit.test('calling load with an encrypted segment waits for both key and segment ' +
+           'before processing', function() {
+  let keyRequest;
+  let segmentRequest;
+
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  QUnit.equal(loader.state, 'WAITING', 'moves to waiting state');
+  QUnit.equal(this.requests.length, 2, 'requested a segment and key');
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.equal(this.requests[1].url, '0.ts', 'requested the first segment');
+  // respond to the segment first
+  segmentRequest = this.requests.pop();
+  segmentRequest.response = new Uint8Array(10).buffer;
+  segmentRequest.respond(200, null, '');
+  QUnit.equal(loader.state, 'WAITING', 'still in waiting state');
+  // then respond to the key
+  keyRequest = this.requests.shift();
+  keyRequest.response = new Uint32Array([0, 0, 0, 0]).buffer;
+  keyRequest.respond(200, null, '');
+  QUnit.equal(loader.state, 'DECRYPTING', 'moves to decrypting state');
+});
+
+QUnit.test('key request timeouts reset bandwidth', function() {
+  loader.playlist(playlistWithDuration(10, {isEncrypted: true}));
+  loader.mimeType(this.mimeType);
+  loader.load();
+
+  QUnit.equal(this.requests[0].url, '0-key.php', 'requested the first segment\'s key');
+  QUnit.equal(this.requests[1].url, '0.ts', 'requested the first segment');
+  // a lot of time passes so the request times out
+  this.requests[0].timedout = true;
+  this.clock.tick(100 * 1000);
+
+  QUnit.equal(loader.bandwidth, 1, 'reset bandwidth');
+  QUnit.ok(isNaN(loader.roundTrip), 'reset round trip time');
+});
+
+QUnit.module('Segment Loading Calculation', {
+  beforeEach() {
+    this.env = useFakeEnvironment();
+    this.mse = useFakeMediaSource();
+    this.hasPlayed = true;
+
+    currentTime = 0;
+    loader = new SegmentLoader({
+      currentTime() {
+        return currentTime;
+      },
+      mediaSource: new videojs.MediaSource(),
+      hasPlayed: () => this.hasPlayed
+    });
+  },
+  afterEach() {
+    this.env.restore();
+    this.mse.restore();
+  }
+});
+
+QUnit.test('requests the first segment with an empty buffer', function() {
+  loader.mimeType(this.mimeType);
+
+  let segmentInfo = loader.checkBuffer_(videojs.createTimeRanges(),
+                                        playlistWithDuration(20),
+                                        0);
+
+  QUnit.ok(segmentInfo, 'generated a request');
+  QUnit.equal(segmentInfo.uri, '0.ts', 'requested the first segment');
+});
+
+QUnit.test('no request if video not played and 1 segment is buffered', function() {
+  this.hasPlayed = false;
+  loader.mimeType(this.mimeType);
+
+  let segmentInfo = loader.checkBuffer_(videojs.createTimeRanges([[0, 1]]),
+                                        playlistWithDuration(20),
+                                        0);
+
+  QUnit.ok(!segmentInfo, 'no request generated');
+
+});
+
+QUnit.test('does not download the next segment if the buffer is full', function() {
+  let buffered;
+  let segmentInfo;
+
+  loader.mimeType(this.mimeType);
+
+  buffered = videojs.createTimeRanges([
+    [0, 15 + GOAL_BUFFER_LENGTH]
+  ]);
+  segmentInfo = loader.checkBuffer_(buffered, playlistWithDuration(30), 15);
+
+  QUnit.ok(!segmentInfo, 'no segment request generated');
+});
+
+QUnit.test('downloads the next segment if the buffer is getting low', function() {
+  let buffered;
+  let segmentInfo;
+
+  loader.mimeType(this.mimeType);
+
+  buffered = videojs.createTimeRanges([[0, 19.999]]);
+  segmentInfo = loader.checkBuffer_(buffered, playlistWithDuration(30), 15);
+
+  QUnit.ok(segmentInfo, 'made a request');
+  QUnit.equal(segmentInfo.uri, '2.ts', 'requested the third segment');
+});
+
+QUnit.test('buffers based on the correct TimeRange if multiple ranges exist', function() {
+  let buffered;
+  let segmentInfo;
+
+  loader.mimeType(this.mimeType);
+
+  buffered = videojs.createTimeRanges([[0, 10], [20, 30]]);
+  segmentInfo = loader.checkBuffer_(buffered, playlistWithDuration(40), 8);
+
+  QUnit.ok(segmentInfo, 'made a request');
+  QUnit.equal(segmentInfo.uri, '1.ts', 'requested the second segment');
+
+  segmentInfo = loader.checkBuffer_(buffered, playlistWithDuration(40), 20);
+  QUnit.ok(segmentInfo, 'made a request');
+  QUnit.equal(segmentInfo.uri, '3.ts', 'requested the fourth segment');
+});
+
+QUnit.test('stops downloading segments at the end of the playlist', function() {
+  let buffered;
+  let segmentInfo;
+
+  loader.mimeType(this.mimeType);
+
+  buffered = videojs.createTimeRanges([[0, 60]]);
+  segmentInfo = loader.checkBuffer_(buffered, playlistWithDuration(60), 0);
+
+  QUnit.ok(!segmentInfo, 'no request was made');
+});
+
+QUnit.test('stops downloading segments if buffered past reported end of the playlist',
+function() {
+  let buffered;
+  let segmentInfo;
+  let playlist;
+
+  loader.mimeType(this.mimeType);
+
+  buffered = videojs.createTimeRanges([[0, 59.9]]);
+  playlist = playlistWithDuration(60);
+  playlist.segments[playlist.segments.length - 1].end = 59.9;
+  segmentInfo = loader.checkBuffer_(buffered, playlist, 50);
+
+  QUnit.ok(!segmentInfo, 'no request was made');
+});
+
+QUnit.test('calculates timestampOffset for discontinuities', function() {
+  let segmentInfo;
+  let playlist;
+
+  loader.mimeType(this.mimeType);
+
+  playlist = playlistWithDuration(60);
+  playlist.segments[3].end = 37.9;
+  playlist.discontinuityStarts = [4];
+  playlist.segments[4].discontinuity = true;
+  playlist.segments[4].timeline = 1;
+
+  segmentInfo = loader.checkBuffer_(videojs.createTimeRanges([[0, 37.9]]), playlist, 36);
+  QUnit.equal(segmentInfo.timestampOffset, 37.9, 'placed the discontinuous segment');
+});
+
+QUnit.test('adjusts calculations based on expired time', function() {
+  let buffered;
+  let playlist;
+  let segmentInfo;
+
+  loader.mimeType(this.mimeType);
+
+  buffered = videojs.createTimeRanges([[0, 30]]);
+  playlist = playlistWithDuration(50);
+
+  loader.expired(10);
+
+  segmentInfo = loader.checkBuffer_(buffered,
+                                    playlist,
+                                    40 - GOAL_BUFFER_LENGTH);
+
+  QUnit.ok(segmentInfo, 'fetched a segment');
+  QUnit.equal(segmentInfo.uri, '2.ts', 'accounted for expired time');
+});

+import SourceUpdater from '../src/source-updater';
+import QUnit from 'qunit';
+import videojs from 'video.js';
+import { useFakeMediaSource } from './test-helpers';
+
+QUnit.module('Source Updater', {
+  beforeEach() {
+    this.mse = useFakeMediaSource();
+    this.mediaSource = new videojs.MediaSource();
+  },
+  afterEach() {
+    this.mse.restore();
+  }
+});
+
+QUnit.test('waits for sourceopen to create a source buffer', function() {
+  new SourceUpdater(this.mediaSource, 'video/mp2t'); // eslint-disable-line no-new
+
+  QUnit.equal(this.mediaSource.sourceBuffers.length, 0,
+              'waited to create the source buffer');
+
+  this.mediaSource.trigger('sourceopen');
+
+  QUnit.equal(this.mediaSource.sourceBuffers.length, 1, 'created one source buffer');
+  QUnit.equal(this.mediaSource.sourceBuffers[0].mimeType_, 'video/mp2t',
+              'assigned the correct MIME type');
+});
+
+QUnit.test('runs a callback when the source buffer is created', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  updater.appendBuffer(new Uint8Array([0, 1, 2]));
+
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+  QUnit.equal(sourceBuffer.updates_.length, 1, 'called the source buffer once');
+  QUnit.deepEqual(sourceBuffer.updates_[0].append, new Uint8Array([0, 1, 2]),
+                  'appended the bytes');
+});
+
+QUnit.test('runs the completion callback when updateend fires', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let updateends = 0;
+  let sourceBuffer;
+
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+  updater.appendBuffer(new Uint8Array([0, 1, 2]), function() {
+    updateends++;
+  });
+  updater.appendBuffer(new Uint8Array([2, 3, 4]), function() {
+    throw new Error('Wrong completion callback invoked!');
+  });
+
+  QUnit.equal(updateends, 0, 'no completions yet');
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(updateends, 1, 'ran the completion callback');
+});
+
+QUnit.test('runs the next callback after updateend fires', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  updater.appendBuffer(new Uint8Array([0, 1, 2]));
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+
+  updater.appendBuffer(new Uint8Array([2, 3, 4]));
+  QUnit.equal(sourceBuffer.updates_.length, 1, 'delayed the update');
+
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(sourceBuffer.updates_.length, 2, 'updated twice');
+  QUnit.deepEqual(sourceBuffer.updates_[1].append, new Uint8Array([2, 3, 4]),
+                  'appended the bytes');
+});
+
+QUnit.test('runs only one callback at a time', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  updater.appendBuffer(new Uint8Array([0]));
+  updater.appendBuffer(new Uint8Array([1]));
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+
+  updater.appendBuffer(new Uint8Array([2]));
+  QUnit.equal(sourceBuffer.updates_.length, 1, 'queued some updates');
+  QUnit.deepEqual(sourceBuffer.updates_[0].append, new Uint8Array([0]),
+                  'ran the first update');
+
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(sourceBuffer.updates_.length, 2, 'queued some updates');
+  QUnit.deepEqual(sourceBuffer.updates_[1].append, new Uint8Array([1]),
+                  'ran the second update');
+
+  updater.appendBuffer(new Uint8Array([3]));
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(sourceBuffer.updates_.length, 3, 'queued the updates');
+  QUnit.deepEqual(sourceBuffer.updates_[2].append, new Uint8Array([2]),
+                  'ran the third update');
+
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(sourceBuffer.updates_.length, 4, 'finished the updates');
+  QUnit.deepEqual(sourceBuffer.updates_[3].append, new Uint8Array([3]),
+                  'ran the fourth update');
+});
+
+QUnit.test('runs updates immediately if possible', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+  updater.appendBuffer(new Uint8Array([0]));
+  QUnit.equal(sourceBuffer.updates_.length, 1, 'ran an update');
+  QUnit.deepEqual(sourceBuffer.updates_[0].append, new Uint8Array([0]),
+                  'appended the bytes');
+});
+
+QUnit.test('supports abort', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  updater.abort();
+  this.mediaSource.trigger('sourceopen');
+
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+  QUnit.ok(sourceBuffer.updates_[0].abort, 'aborted the source buffer');
+});
+
+QUnit.test('supports buffered', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+
+  QUnit.equal(updater.buffered().length, 0, 'buffered is empty');
+
+  this.mediaSource.trigger('sourceopen');
+  QUnit.ok(updater.buffered(), 'buffered is defined');
+});
+
+QUnit.test('supports removeBuffer', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+  updater.remove(1, 14);
+
+  QUnit.equal(sourceBuffer.updates_.length, 1, 'ran an update');
+  QUnit.deepEqual(sourceBuffer.updates_[0].remove, [1, 14], 'removed the time range');
+});
+
+QUnit.test('supports setting duration', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+  updater.duration(21);
+
+  QUnit.equal(sourceBuffer.updates_.length, 1, 'ran an update');
+  QUnit.deepEqual(sourceBuffer.updates_[0].duration, 21, 'changed duration');
+});
+
+QUnit.test('supports timestampOffset', function() {
+  let updater = new SourceUpdater(this.mediaSource, 'video/mp2t');
+  let sourceBuffer;
+
+  this.mediaSource.trigger('sourceopen');
+  sourceBuffer = this.mediaSource.sourceBuffers[0];
+
+  QUnit.equal(updater.timestampOffset(), 0, 'intialized to zero');
+  updater.timestampOffset(21);
+  QUnit.equal(updater.timestampOffset(), 21, 'reflects changes immediately');
+  QUnit.equal(sourceBuffer.timestampOffset, 21, 'applied the update');
+
+  updater.appendBuffer(new Uint8Array(2));
+  updater.timestampOffset(14);
+  QUnit.equal(updater.timestampOffset(), 14, 'reflects changes immediately');
+  QUnit.equal(sourceBuffer.timestampOffset, 21, 'queues application after updates');
+
+  sourceBuffer.trigger('updateend');
+  QUnit.equal(sourceBuffer.timestampOffset, 14, 'applied the update');
+});

+import document from 'global/document';
+import sinon from 'sinon';
+import videojs from 'video.js';
+import QUnit from 'qunit';
+/* eslint-disable no-unused-vars */
+// needed so MediaSource can be registered with videojs
+import MediaSource from 'videojs-contrib-media-sources';
+/* eslint-enable */
+import testDataManifests from './test-manifests.js';
+import xhrFactory from '../src/xhr';
+
+// a SourceBuffer that tracks updates but otherwise is a noop
+class MockSourceBuffer extends videojs.EventTarget {
+  constructor() {
+    super();
+    this.updates_ = [];
+
+    this.updating = false;
+    this.on('updateend', function() {
+      this.updating = false;
+    });
+
+    this.buffered = videojs.createTimeRanges();
+    this.duration_ = NaN;
+
+    Object.defineProperty(this, 'duration', {
+      get() {
+        return this.duration_;
+      },
+      set(duration) {
+        this.updates_.push({
+          duration
+        });
+        this.duration_ = duration;
+      }
+    });
+  }
+
+  abort() {
+    this.updates_.push({
+      abort: true
+    });
+  }
+
+  appendBuffer(bytes) {
+    this.updates_.push({
+      append: bytes
+    });
+    this.updating = true;
+  }
+
+  remove(start, end) {
+    this.updates_.push({
+      remove: [start, end]
+    });
+  }
+}
+
+class MockMediaSource extends videojs.EventTarget {
+  constructor() {
+    super();
+    this.readyState = 'closed';
+    this.on('sourceopen', function() {
+      this.readyState = 'open';
+    });
+
+    this.sourceBuffers = [];
+    this.duration = NaN;
+    this.seekable = videojs.createTimeRange();
+  }
+
+  addSeekableRange_(start, end) {
+    this.seekable = videojs.createTimeRange(start, end);
+  }
+
+  addSourceBuffer(mime) {
+    let sourceBuffer = new MockSourceBuffer();
+
+    sourceBuffer.mimeType_ = mime;
+    this.sourceBuffers.push(sourceBuffer);
+    return sourceBuffer;
+  }
+
+  endOfStream(error) {
+    this.readyState = 'closed';
+    this.error_ = error;
+  }
+}
+
+export const useFakeMediaSource = function() {
+  let RealMediaSource = videojs.MediaSource;
+  let realCreateObjectURL = window.URL.createObjectURL;
+  let id = 0;
+
+  videojs.MediaSource = MockMediaSource;
+  videojs.MediaSource.supportsNativeMediaSources =
+    RealMediaSource.supportsNativeMediaSources;
+  videojs.URL.createObjectURL = function() {
+    id++;
+    return 'blob:videojs-contrib-hls-mock-url' + id;
+  };
+
+  return {
+    restore() {
+      videojs.MediaSource = RealMediaSource;
+      videojs.URL.createObjectURL = realCreateObjectURL;
+    }
+  };
+};
+
+let fakeEnvironment = {
+  requests: [],
+  restore() {
+    this.clock.restore();
+    videojs.xhr.XMLHttpRequest = window.XMLHttpRequest;
+    this.xhr.restore();
+    ['warn', 'error'].forEach((level) => {
+      if (this.log && this.log[level] && this.log[level].restore) {
+        QUnit.equal(this.log[level].callCount, 0, `no unexpected logs on ${level}`);
+        this.log[level].restore();
+      }
+    });
+  }
+};
+
+export const useFakeEnvironment = function() {
+  fakeEnvironment.log = {};
+  ['warn', 'error'].forEach((level) => {
+    // you can use .log[level].args to get args
+    sinon.stub(videojs.log, level);
+    fakeEnvironment.log[level] = videojs.log[level];
+    Object.defineProperty(videojs.log[level], 'calls', {
+      get() {
+        // reset callCount to 0 so they don't have to
+        let callCount = this.callCount;
+
+        this.callCount = 0;
+        return callCount;
+      }
+    });
+  });
+  fakeEnvironment.clock = sinon.useFakeTimers();
+  fakeEnvironment.xhr = sinon.useFakeXMLHttpRequest();
+  fakeEnvironment.requests.length = 0;
+  fakeEnvironment.xhr.onCreate = function(xhr) {
+    fakeEnvironment.requests.push(xhr);
+  };
+  videojs.xhr.XMLHttpRequest = fakeEnvironment.xhr;
+
+  return fakeEnvironment;
+};
+
+// patch over some methods of the provided tech so it can be tested
+// synchronously with sinon's fake timers
+export const mockTech = function(tech) {
+  if (tech.isMocked_) {
+    // make this function idempotent because HTML and Flash based
+    // playback have very different lifecycles. For HTML, the tech
+    // is available on player creation. For Flash, the tech isn't
+    // ready until the source has been loaded and one tick has
+    // expired.
+    return;
+  }
+
+  tech.isMocked_ = true;
+  tech.src_ = null;
+  tech.time_ = null;
+
+  tech.paused_ = !tech.autoplay();
+  tech.paused = function() {
+    return tech.paused_;
+  };
+
+  if (!tech.currentTime_) {
+    tech.currentTime_ = tech.currentTime;
+  }
+  tech.currentTime = function() {
+    return tech.time_ === null ? tech.currentTime_() : tech.time_;
+  };
+
+  tech.setSrc = function(src) {
+    tech.src_ = src;
+  };
+  tech.src = function(src) {
+    if (src !== null) {
+      return tech.setSrc(src);
+    }
+    return tech.src_ === null ? tech.src : tech.src_;
+  };
+  tech.currentSrc_ = tech.currentSrc;
+  tech.currentSrc = function() {
+    return tech.src_ === null ? tech.currentSrc_() : tech.src_;
+  };
+
+  tech.play_ = tech.play;
+  tech.play = function() {
+    tech.play_();
+    tech.paused_ = false;
+    tech.trigger('play');
+  };
+  tech.pause_ = tech.pause_;
+  tech.pause = function() {
+    tech.pause_();
+    tech.paused_ = true;
+    tech.trigger('pause');
+  };
+
+  tech.setCurrentTime = function(time) {
+    tech.time_ = time;
+
+    setTimeout(function() {
+      tech.trigger('seeking');
+      setTimeout(function() {
+        tech.trigger('seeked');
+      }, 1);
+    }, 1);
+  };
+};
+
+export const createPlayer = function(options) {
+  let video;
+  let player;
+
+  video = document.createElement('video');
+  video.className = 'video-js';
+  document.querySelector('#qunit-fixture').appendChild(video);
+  player = videojs(video, options || {
+    flash: {
+      swf: ''
+    }
+  });
+
+  player.buffered = function() {
+    return videojs.createTimeRange(0, 0);
+  };
+  mockTech(player.tech_);
+
+  return player;
+};
+
+export const openMediaSource = function(player, clock) {
+  // ensure the Flash tech is ready
+  player.tech_.triggerReady();
+  clock.tick(1);
+  // mock the tech *after* it has finished loading so that we don't
+  // mock a tech that will be unloaded on the next tick
+  mockTech(player.tech_);
+  player.tech_.hls.xhr = xhrFactory();
+
+  // simulate the sourceopen event
+  player.tech_.hls.mediaSource.readyState = 'open';
+  player.tech_.hls.mediaSource.dispatchEvent({
+    type: 'sourceopen',
+    swfId: player.tech_.el().id
+  });
+};
+
+export const standardXHRResponse = function(request) {
+  if (!request.url) {
+    return;
+  }
+
+  let contentType = 'application/json';
+  // contents off the global object
+  let manifestName = (/(?:.*\/)?(.*)\.m3u8/).exec(request.url);
+
+  if (manifestName) {
+    manifestName = manifestName[1];
+  } else {
+    manifestName = request.url;
+  }
+
+  if (/\.m3u8?/.test(request.url)) {
+    contentType = 'application/vnd.apple.mpegurl';
+  } else if (/\.ts/.test(request.url)) {
+    contentType = 'video/MP2T';
+  }
+
+  request.response = new Uint8Array(16).buffer;
+  request.respond(200, { 'Content-Type': contentType },
+                  testDataManifests[manifestName]);
+};
+
+// return an absolute version of a page-relative URL
+export const absoluteUrl = function(relativeUrl) {
+  return window.location.protocol + '//' +
+    window.location.host +
+    (window.location.pathname
+        .split('/')
+        .slice(0, -1)
+        .concat(relativeUrl)
+        .join('/')
+    );
+};

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "http://example.com/00001.ts"
       "uri": "http://example.com/00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "https://example.com/00002.ts"
       "uri": "https://example.com/00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "//example.com/00003.ts"
       "uri": "//example.com/00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "http://example.com/00004.ts"
       "uri": "http://example.com/00004.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "offset": 522828
         "offset": 522828
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -25,6 +27,7 @@
         "offset": 1110328
         "offset": 1110328
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -33,6 +36,7 @@
         "offset": 1823412
         "offset": 1823412
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -41,6 +45,7 @@
         "offset": 2299992
         "offset": 2299992
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -49,6 +54,7 @@
         "offset": 2835604
         "offset": 2835604
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -57,6 +63,7 @@
         "offset": 3042780
         "offset": 3042780
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -65,6 +72,7 @@
         "offset": 3498680
         "offset": 3498680
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -73,6 +81,7 @@
         "offset": 4155928
         "offset": 4155928
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -81,6 +90,7 @@
         "offset": 4727636
         "offset": 4727636
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -89,6 +99,7 @@
         "offset": 5212676
         "offset": 5212676
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -97,6 +108,7 @@
         "offset": 5921812
         "offset": 5921812
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -105,6 +117,7 @@
         "offset": 6651816
         "offset": 6651816
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -113,6 +126,7 @@
         "offset": 7108092
         "offset": 7108092
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -121,6 +135,7 @@
         "offset": 7576776
         "offset": 7576776
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -129,6 +144,7 @@
         "offset": 8021772
         "offset": 8021772
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -137,6 +153,7 @@
         "offset": 8353216
         "offset": 8353216
       },
       },
       "duration": 1.4167,
       "duration": 1.4167,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -144,4 +161,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -16,4 +17,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

+{
+  allowCache: true,
+  discontinuityStarts: [],
+  mediaGroups: {
+    // TYPE
+    AUDIO: {
+      // GROUP-ID
+      "audio": {
+        // NAME
+        "English": {
+          language: 'eng',
+          autoselect: true,
+          default: true,
+          uri: "eng/prog_index.m3u8"
+        },
+        // NAME
+        "Français": {
+          language: "fre",
+          autoselect: true,
+          default: false,
+          uri: "fre/prog_index.m3u8"
+        },
+        // NAME
+        "Espanol": {
+          language: "sp",
+          autoselect: true,
+          default: false,
+          uri: "sp/prog_index.m3u8"
+        }
+      }
+    },
+    VIDEO: {},
+    "CLOSED-CAPTIONS": {},
+    SUBTITLES: {}
+  },
+  playlists: [{
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 195023,
+      CODECS: "avc1.42e00a,mp4a.40.2",
+      AUDIO: 'audio'
+    },
+    timeline: 0,
+    uri: "lo/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 591680,
+      CODECS: "avc1.42e01e,mp4a.40.2",
+      AUDIO: 'audio'
+    },
+    timeline: 0,
+    uri: "hi/prog_index.m3u8"
+  }]
+}

+#EXTM3U
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",LANGUAGE="eng",NAME="English",AUTOSELECT=YES, DEFAULT=YES,URI="eng/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",LANGUAGE="fre",NAME="Français",AUTOSELECT=YES, DEFAULT=NO,URI="fre/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",LANGUAGE="sp",NAME="Espanol",AUTOSELECT=YES, DEFAULT=NO,URI="sp/prog_index.m3u8"
+
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=195023,CODECS="avc1.42e00a,mp4a.40.2",AUDIO="audio"
+lo/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=591680,CODECS="avc1.42e01e,mp4a.40.2",AUDIO="audio"
+hi/prog_index.m3u8
\ No newline at end of file

+{
+  allowCache: true,
+  discontinuityStarts: [],
+  mediaGroups: {
+    AUDIO: {
+      aac: {
+        English: {
+          autoselect: true,
+          default: true,
+          language: "eng",
+          uri: "eng/prog_index.m3u8"
+        }
+      }
+    },
+    VIDEO: {
+      "500kbs": {
+        Angle1: {
+          autoselect: true,
+          default: true
+        },
+        Angle2: {
+          autoselect: true,
+          default: false,
+          uri: "Angle2/500kbs/prog_index.m3u8"
+        },
+        Angle3: {
+          autoselect: true,
+          default: false,
+          uri: "Angle3/500kbs/prog_index.m3u8"
+        }
+      }
+    },
+    "CLOSED-CAPTIONS": {},
+    SUBTITLES: {}
+  },
+  playlists: [{
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 754857,
+      CODECS: "mp4a.40.2,avc1.4d401e",
+      AUDIO: "aac",
+      VIDEO: "500kbs"
+    },
+    timeline: 0,
+    uri: "Angle1/500kbs/prog_index.m3u8"
+  }]
+}

+#EXTM3U
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="500kbs",NAME="Angle1",AUTOSELECT=YES,DEFAULT=YES
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="500kbs",NAME="Angle2",AUTOSELECT=YES,DEFAULT=NO,URI="Angle2/500kbs/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="500kbs",NAME="Angle3",AUTOSELECT=YES,DEFAULT=NO,URI="Angle3/500kbs/prog_index.m3u8"
+
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aac",LANGUAGE="eng",NAME="English",AUTOSELECT=YES,DEFAULT=YES,URI="eng/prog_index.m3u8"
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=754857,CODECS="mp4a.40.2,avc1.4d401e",VIDEO="500kbs",AUDIO="aac"
+Angle1/500kbs/prog_index.m3u8
\ No newline at end of file

@@ -10,6 +10,7 @@
           "height": 224
           "height": 224
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686811001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686811001&videoId=1824650741001"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "PROGRAM-ID": 1,
         "PROGRAM-ID": 1,
         "BANDWIDTH": 40000
         "BANDWIDTH": 40000
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824683759001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824683759001&videoId=1824650741001"
     },
     },
     {
     {
@@ -28,6 +30,7 @@
           "height": 224
           "height": 224
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686593001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686593001&videoId=1824650741001"
     },
     },
     {
     {
@@ -39,8 +42,15 @@
           "height": 540
           "height": 540
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824687660001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824687660001&videoId=1824650741001"
     }
     }
   ],
   ],
-  "discontinuityStarts": []
-}
\ No newline at end of file
+  "discontinuityStarts": [],
+  "mediaGroups": {
+    "VIDEO": {},
+    "AUDIO": {},
+    "CLOSED-CAPTIONS": {},
+    "SUBTITLES": {}
+  }
+}

@@ -5,6 +5,7 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -13,6 +14,7 @@
         "offset": 522828
         "offset": 522828
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -21,6 +23,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video2.ts"
       "uri": "hls_450k_video2.ts"
     },
     },
     {
     {
@@ -29,6 +32,7 @@
         "offset": 1823412
         "offset": 1823412
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -37,6 +41,7 @@
         "offset": 2299992
         "offset": 2299992
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -45,6 +50,7 @@
         "offset": 2835604
         "offset": 2835604
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -53,6 +59,7 @@
         "offset": 3042780
         "offset": 3042780
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -61,6 +68,7 @@
         "offset": 3498680
         "offset": 3498680
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -69,6 +77,7 @@
         "offset": 4155928
         "offset": 4155928
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -77,6 +86,7 @@
         "offset": 4727636
         "offset": 4727636
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -85,6 +95,7 @@
         "offset": 5212676
         "offset": 5212676
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -93,6 +104,7 @@
         "offset": 5921812
         "offset": 5921812
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -101,6 +113,7 @@
         "offset": 6651816
         "offset": 6651816
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -109,6 +122,7 @@
         "offset": 7108092
         "offset": 7108092
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -117,6 +131,7 @@
         "offset": 7576776
         "offset": 7576776
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -125,6 +140,7 @@
         "offset": 8021772
         "offset": 8021772
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -133,6 +149,7 @@
         "offset": 8353216
         "offset": 8353216
       },
       },
       "duration": 1.4167,
       "duration": 1.4167,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -140,4 +157,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -16,4 +17,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,19 +5,23 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 3,
       "uri": "001.ts"
       "uri": "001.ts"
     },
     },
     {
     {
       "duration": 19,
       "duration": 19,
+      "timeline": 3,
       "uri": "002.ts"
       "uri": "002.ts"
     },
     },
     {
     {
       "discontinuity": true,
       "discontinuity": true,
       "duration": 10,
       "duration": 10,
+      "timeline": 4,
       "uri": "003.ts"
       "uri": "003.ts"
     },
     },
     {
     {
       "duration": 11,
       "duration": 11,
+      "timeline": 4,
       "uri": "004.ts"
       "uri": "004.ts"
     }
     }
   ],
   ],

@@ -5,41 +5,50 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "001.ts"
       "uri": "001.ts"
     },
     },
     {
     {
       "duration": 19,
       "duration": 19,
+      "timeline": 0,
       "uri": "002.ts"
       "uri": "002.ts"
     },
     },
     {
     {
       "discontinuity": true,
       "discontinuity": true,
       "duration": 10,
       "duration": 10,
+      "timeline": 1,
       "uri": "003.ts"
       "uri": "003.ts"
     },
     },
     {
     {
       "duration": 11,
       "duration": 11,
+      "timeline": 1,
       "uri": "004.ts"
       "uri": "004.ts"
     },
     },
     {
     {
       "discontinuity": true,
       "discontinuity": true,
       "duration": 10,
       "duration": 10,
+      "timeline": 2,
       "uri": "005.ts"
       "uri": "005.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 2,
       "uri": "006.ts"
       "uri": "006.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 2,
       "uri": "007.ts"
       "uri": "007.ts"
     },
     },
     {
     {
       "discontinuity": true,
       "discontinuity": true,
       "duration": 10,
       "duration": 10,
+      "timeline": 3,
       "uri": "008.ts"
       "uri": "008.ts"
     },
     },
     {
     {
       "duration": 16,
       "duration": 16,
+      "timeline": 3,
       "uri": "009.ts"
       "uri": "009.ts"
     }
     }
   ],
   ],

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/00001.ts"
       "uri": "/00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/subdir/00002.ts"
       "uri": "/subdir/00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/00003.ts"
       "uri": "/00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/00004.ts"
       "uri": "/00004.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -16,4 +17,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 6.08,
       "duration": 6.08,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 6.6,
       "duration": 6.6,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,26 +4,32 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00001.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00002.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00003.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00004.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00004.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00005.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00005.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00006.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00006.ts"
     }
     }
   ],
   ],
@@ -31,4 +37,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -10,6 +10,7 @@
           "height": 224
           "height": 224
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686811001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686811001&videoId=1824650741001"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "PROGRAM-ID": 1,
         "PROGRAM-ID": 1,
         "BANDWIDTH": 40000
         "BANDWIDTH": 40000
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824683759001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824683759001&videoId=1824650741001"
     },
     },
     {
     {
@@ -28,6 +30,7 @@
           "height": 224
           "height": 224
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686593001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824686593001&videoId=1824650741001"
     },
     },
     {
     {
@@ -39,8 +42,15 @@
           "height": 540
           "height": 540
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824687660001&videoId=1824650741001"
       "uri": "http://c.brightcove.com/services/mobile/streaming/index/rendition.m3u8?assetId=1824687660001&videoId=1824650741001"
     }
     }
   ],
   ],
-  "discontinuityStarts": []
-}
\ No newline at end of file
+  "discontinuityStarts": [],
+  "mediaGroups": {
+    "VIDEO": {},
+    "AUDIO": {},
+    "CLOSED-CAPTIONS": {},
+    "SUBTITLES": {}
+  }
+}

@@ -6,6 +6,7 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 2.833,
       "duration": 2.833,
+      "timeline": 0,
       "key": {
       "key": {
         "method": "AES-128",
         "method": "AES-128",
         "uri": "https://priv.example.com/key.php?r=52"
         "uri": "https://priv.example.com/key.php?r=52"
@@ -14,6 +15,7 @@
     },
     },
     {
     {
       "duration": 15,
       "duration": 15,
+      "timeline": 0,
       "key": {
       "key": {
         "method": "AES-128",
         "method": "AES-128",
         "uri": "https://priv.example.com/key.php?r=52"
         "uri": "https://priv.example.com/key.php?r=52"
@@ -22,6 +24,7 @@
     },
     },
     {
     {
       "duration": 13.333,
       "duration": 13.333,
+      "timeline": 0,
       "key": {
       "key": {
         "method": "AES-128",
         "method": "AES-128",
         "uri": "https://priv.example.com/key.php?r=52"
         "uri": "https://priv.example.com/key.php?r=52"
@@ -30,6 +33,7 @@
     },
     },
     {
     {
       "duration": 15,
       "duration": 15,
+      "timeline": 0,
       "key": {
       "key": {
         "method": "AES-128",
         "method": "AES-128",
         "uri": "https://priv.example.com/key.php?r=53"
         "uri": "https://priv.example.com/key.php?r=53"
@@ -38,6 +42,7 @@
     },
     },
     {
     {
       "duration": 14,
       "duration": 14,
+      "timeline": 0,
       "key": {
       "key": {
         "method": "AES-128",
         "method": "AES-128",
         "uri": "https://priv.example.com/key.php?r=54",
         "uri": "https://priv.example.com/key.php?r=54",
@@ -47,6 +52,7 @@
     },
     },
     {
     {
       "duration": 15,
       "duration": 15,
+      "timeline": 0,
       "uri": "http://media.example.com/fileSequence53-B.ts"
       "uri": "http://media.example.com/fileSequence53-B.ts"
     }
     }
   ],
   ],

@@ -5,26 +5,32 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00001.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00002.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00003.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00004.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00004.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00005.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00005.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00006.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00006.ts"
     }
     }
   ],
   ],
@@ -32,4 +38,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,6 +4,7 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     }
     }
   ],
   ],
@@ -11,4 +12,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "offset": 522828
         "offset": 522828
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -25,6 +27,7 @@
         "offset": 1110328
         "offset": 1110328
       },
       },
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -33,6 +36,7 @@
         "offset": 1823412
         "offset": 1823412
       },
       },
       "duration": 9.7,
       "duration": 9.7,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -41,6 +45,7 @@
         "offset": 2299992
         "offset": 2299992
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -49,6 +54,7 @@
         "offset": 2835604
         "offset": 2835604
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -57,6 +63,7 @@
         "offset": 3042780
         "offset": 3042780
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -65,6 +72,7 @@
         "offset": 3498680
         "offset": 3498680
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -73,6 +81,7 @@
         "offset": 4155928
         "offset": 4155928
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -81,6 +90,7 @@
         "offset": 4727636
         "offset": 4727636
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -89,6 +99,7 @@
         "offset": 5212676
         "offset": 5212676
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -97,6 +108,7 @@
         "offset": 5921812
         "offset": 5921812
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -105,6 +117,7 @@
         "offset": 6651816
         "offset": 6651816
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -113,6 +126,7 @@
         "offset": 7108092
         "offset": 7108092
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -121,6 +135,7 @@
         "offset": 7576776
         "offset": 7576776
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -129,6 +144,7 @@
         "offset": 8021772
         "offset": 8021772
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -137,6 +153,7 @@
         "offset": 8353216
         "offset": 8353216
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -144,4 +161,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -16,4 +17,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 6.08,
       "duration": 6.08,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 6.6,
       "duration": 6.6,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,26 +4,32 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00001.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00002.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00003.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00004.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00004.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00005.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00005.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00006.ts"
       "uri": "/test/ts-files/zencoder/haze/Haze_Mantel_President_encoded_1200-00006.ts"
     }
     }
   ],
   ],
@@ -31,4 +37,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "offset": 522828
         "offset": 522828
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -25,6 +27,7 @@
         "offset": 1110328
         "offset": 1110328
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -33,6 +36,7 @@
         "offset": 1823412
         "offset": 1823412
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -41,6 +45,7 @@
         "offset": 2299992
         "offset": 2299992
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -49,6 +54,7 @@
         "offset": 2835604
         "offset": 2835604
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -57,6 +63,7 @@
         "offset": 3042780
         "offset": 3042780
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -65,6 +72,7 @@
         "offset": 3498680
         "offset": 3498680
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -73,6 +81,7 @@
         "offset": 4155928
         "offset": 4155928
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -81,6 +90,7 @@
         "offset": 4727636
         "offset": 4727636
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -89,6 +99,7 @@
         "offset": 5212676
         "offset": 5212676
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -97,6 +108,7 @@
         "offset": 5921812
         "offset": 5921812
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -105,6 +117,7 @@
         "offset": 6651816
         "offset": 6651816
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -113,6 +126,7 @@
         "offset": 7108092
         "offset": 7108092
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -121,6 +135,7 @@
         "offset": 7576776
         "offset": 7576776
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -129,6 +144,7 @@
         "offset": 8021772
         "offset": 8021772
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -137,10 +153,11 @@
         "offset": 8353216
         "offset": 8353216
       },
       },
       "duration": 1.4167,
       "duration": 1.4167,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,21 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     }
     }
   ],
   ],
   "targetDuration": 8,
   "targetDuration": 8,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,42 +4,51 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "001.ts"
       "uri": "001.ts"
     },
     },
     {
     {
       "duration": 19,
       "duration": 19,
+      "timeline": 0,
       "uri": "002.ts"
       "uri": "002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "003.ts"
       "uri": "003.ts"
     },
     },
     {
     {
       "duration": 11,
       "duration": 11,
+      "timeline": 0,
       "uri": "004.ts"
       "uri": "004.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "005.ts"
       "uri": "005.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "006.ts"
       "uri": "006.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "007.ts"
       "uri": "007.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "008.ts"
       "uri": "008.ts"
     },
     },
     {
     {
       "duration": 16,
       "duration": 16,
+      "timeline": 0,
       "uri": "009.ts"
       "uri": "009.ts"
     }
     }
   ],
   ],
   "targetDuration": 10,
   "targetDuration": 10,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,10 +4,11 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00001.ts"
       "uri": "/test/ts-files/zencoder/gogo/00001.ts"
     }
     }
   ],
   ],
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,22 +4,27 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00001.ts"
       "uri": "/test/ts-files/zencoder/gogo/00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00002.ts"
       "uri": "/test/ts-files/zencoder/gogo/00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00003.ts"
       "uri": "/test/ts-files/zencoder/gogo/00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00004.ts"
       "uri": "/test/ts-files/zencoder/gogo/00004.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00005.ts"
       "uri": "/test/ts-files/zencoder/gogo/00005.ts"
     }
     }
   ],
   ],
@@ -27,4 +32,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,6 +4,7 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "/test/ts-files/zencoder/gogo/00001.ts"
       "uri": "/test/ts-files/zencoder/gogo/00001.ts"
     }
     }
   ],
   ],
@@ -11,4 +12,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -10,6 +10,7 @@
           "height": 224
           "height": 224
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "media.m3u8"
       "uri": "media.m3u8"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "PROGRAM-ID": 1,
         "PROGRAM-ID": 1,
         "BANDWIDTH": 40000
         "BANDWIDTH": 40000
       },
       },
+      "timeline": 0,
       "uri": "media1.m3u8"
       "uri": "media1.m3u8"
     },
     },
     {
     {
@@ -28,6 +30,7 @@
           "height": 224
           "height": 224
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "media2.m3u8"
       "uri": "media2.m3u8"
     },
     },
     {
     {
@@ -39,8 +42,15 @@
           "height": 540
           "height": 540
         }
         }
       },
       },
+      "timeline": 0,
       "uri": "media3.m3u8"
       "uri": "media3.m3u8"
     }
     }
   ],
   ],
-  "discontinuityStarts": []
-}
\ No newline at end of file
+  "discontinuityStarts": [],
+  "mediaGroups": {
+    "VIDEO": {},
+    "AUDIO": {},
+    "CLOSED-CAPTIONS": {},
+    "SUBTITLES": {}
+  }
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "media-00001.ts"
       "uri": "media-00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "media-00002.ts"
       "uri": "media-00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "media-00003.ts"
       "uri": "media-00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "media-00004.ts"
       "uri": "media-00004.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 6.08,
       "duration": 6.08,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 6.6,
       "duration": 6.6,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -4,14 +4,16 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "00001.ts"
       "uri": "00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "00002.ts"
       "uri": "00002.ts"
     }
     }
   ],
   ],
   "targetDuration": 10,
   "targetDuration": 10,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,14 +5,17 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -20,4 +23,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 6.08,
       "duration": 6.08,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 6.6,
       "duration": 6.6,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 8,
       "duration": 8,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

+{
+  allowCache: true,
+  discontinuityStarts: [],
+  mediaGroups: {
+    AUDIO: {
+      "audio-lo": {
+        "English": {
+          autoselect: true,
+          default: true,
+          language: "eng",
+          uri: "englo/prog_index.m3u8"
+        },
+        "Français": {
+          autoselect: true,
+          default: false,
+          language: "fre",
+          uri: "frelo/prog_index.m3u8"
+        },
+        "Espanol": {
+          autoselect: true,
+          default: false,
+          language: "sp",
+          uri: "splo/prog_index.m3u8"
+        }
+      },
+      "audio-hi": {
+        "English": {
+          autoselect: true,
+          default: true,
+          language: "eng",
+          uri: "eng/prog_index.m3u8"
+        },
+        "Français": {
+          autoselect: true,
+          default: false,
+          language: "fre",
+          uri: "fre/prog_index.m3u8"
+        },
+        "Espanol": {
+          autoselect: true,
+          default: false,
+          language: "sp",
+          uri: "sp/prog_index.m3u8"
+        }
+      }
+    },
+    VIDEO: {},
+    "CLOSED-CAPTIONS": {},
+    SUBTITLES: {}
+  },
+  playlists: [{
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 195023,
+      CODECS: "mp4a.40.5",
+      AUDIO: "audio-lo",
+    },
+    timeline: 0,
+    uri: "lo/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 260000,
+      CODECS: "avc1.42e01e,mp4a.40.2",
+      AUDIO: "audio-lo"
+    },
+    timeline: 0,
+    uri: "lo2/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 591680,
+      CODECS: "mp4a.40.2, avc1.64001e",
+      AUDIO: "audio-hi"
+    },
+    timeline: 0,
+    uri: "hi/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 650000,
+      CODECS: "avc1.42e01e,mp4a.40.2",
+      AUDIO: "audio-hi"
+    },
+    timeline: 0,
+    uri: "hi2/prog_index.m3u8"
+  }]
+}

+#EXTM3U
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="eng",NAME="English",AUTOSELECT=YES, DEFAULT=YES,URI="englo/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="fre",NAME="Français",AUTOSELECT=YES, DEFAULT=NO,URI="frelo/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="sp",NAME="Espanol",AUTOSELECT=YES, DEFAULT=NO,URI="splo/prog_index.m3u8"
+
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-hi",LANGUAGE="eng",NAME="English",AUTOSELECT=YES, DEFAULT=YES,URI="eng/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-hi",LANGUAGE="fre",NAME="Français",AUTOSELECT=YES, DEFAULT=NO,URI="fre/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-hi",LANGUAGE="sp",NAME="Espanol",AUTOSELECT=YES, DEFAULT=NO,URI="sp/prog_index.m3u8"
+
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=195023,CODECS="mp4a.40.5", AUDIO="audio-lo"
+lo/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=260000,CODECS="avc1.42e01e,mp4a.40.2", AUDIO="audio-lo"
+lo2/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=591680,CODECS="mp4a.40.2, avc1.64001e", AUDIO="audio-hi"
+hi/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=650000,CODECS="avc1.42e01e,mp4a.40.2", AUDIO="audio-hi"
+hi2/prog_index.m3u8

+{
+  allowCache: true,
+  discontinuityStarts: [],
+  mediaGroups: {
+    AUDIO: {
+      "audio-lo": {
+        "English": {
+          autoselect: true,
+          default: true,
+          language: "eng",
+        },
+        "Français": {
+          autoselect: true,
+          default: false,
+          language: "fre",
+          uri: "frelo/prog_index.m3u8"
+        },
+        "Espanol": {
+          autoselect: true,
+          default: false,
+          language: "sp",
+          uri: "splo/prog_index.m3u8"
+        }
+      },
+      "audio-hi": {
+        "English": {
+          autoselect: true,
+          default: true,
+          language: "eng",
+          uri: "eng/prog_index.m3u8"
+        },
+        "Français": {
+          autoselect: true,
+          default: false,
+          language: "fre",
+          uri: "fre/prog_index.m3u8"
+        },
+        "Espanol": {
+          autoselect: true,
+          default: false,
+          language: "sp",
+          uri: "sp/prog_index.m3u8"
+        }
+      }
+    },
+    VIDEO: {},
+    "CLOSED-CAPTIONS": {},
+    SUBTITLES: {}
+  },
+  playlists: [{
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 195023,
+      CODECS: "mp4a.40.5",
+      AUDIO: "audio-lo",
+    },
+    timeline: 0,
+    uri: "lo/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 260000,
+      CODECS: "avc1.42e01e,mp4a.40.2",
+      AUDIO: "audio-lo"
+    },
+    timeline: 0,
+    uri: "lo2/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 591680,
+      CODECS: "mp4a.40.2, avc1.64001e",
+      AUDIO: "audio-hi"
+    },
+    timeline: 0,
+    uri: "hi/prog_index.m3u8"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 650000,
+      CODECS: "avc1.42e01e,mp4a.40.2",
+      AUDIO: "audio-hi"
+    },
+    timeline: 0,
+    uri: "hi2/prog_index.m3u8"
+  }]
+}

+#EXTM3U
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="eng",NAME="English",AUTOSELECT=YES, DEFAULT=YES
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="fre",NAME="Français",AUTOSELECT=YES, DEFAULT=NO,URI="frelo/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="sp",NAME="Espanol",AUTOSELECT=YES, DEFAULT=NO,URI="splo/prog_index.m3u8"
+
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-hi",LANGUAGE="eng",NAME="English",AUTOSELECT=YES, DEFAULT=YES,URI="eng/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-hi",LANGUAGE="fre",NAME="Français",AUTOSELECT=YES, DEFAULT=NO,URI="fre/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-hi",LANGUAGE="sp",NAME="Espanol",AUTOSELECT=YES, DEFAULT=NO,URI="sp/prog_index.m3u8"
+
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=195023,CODECS="mp4a.40.5", AUDIO="audio-lo"
+lo/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=260000,CODECS="avc1.42e01e,mp4a.40.2", AUDIO="audio-lo"
+lo2/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=591680,CODECS="mp4a.40.2, avc1.64001e", AUDIO="audio-hi"
+hi/prog_index.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=650000,CODECS="avc1.42e01e,mp4a.40.2", AUDIO="audio-hi"
+hi2/prog_index.m3u8

@@ -4,21 +4,25 @@
   "targetDuration": 10,
   "targetDuration": 10,
   "segments": [
   "segments": [
     {
     {
-      "uri": "001.ts"
+      "uri": "001.ts",
+      "timeline": 0
     },
     },
     {
     {
       "uri": "002.ts",
       "uri": "002.ts",
-      "duration": 9
+      "duration": 9,
+      "timeline": 0
     },
     },
     {
     {
       "uri": "003.ts",
       "uri": "003.ts",
-      "duration": 7
+      "duration": 7,
+      "timeline": 0
     },
     },
     {
     {
       "uri": "004.ts",
       "uri": "004.ts",
-      "duration": 10
+      "duration": 10,
+      "timeline": 0
     }
     }
   ],
   ],
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

+{
+  allowCache: true,
+  discontinuityStarts: [],
+  mediaGroups: {
+    AUDIO: {
+      aac: {
+        English: {
+          autoselect: true,
+          default: true,
+          language: "eng",
+          uri: "eng/prog_index.m3u8"
+        }
+      }
+    },
+    VIDEO: {
+      "200kbs": {
+        Angle1: {
+          autoselect: true,
+          default: true
+        },
+        Angle2: {
+          autoselect: true,
+          default: false,
+          uri: "Angle2/200kbs/prog_index.m3u8"
+        },
+        Angle3: {
+          autoselect: true,
+          default: false,
+          uri: "Angle3/200kbs/prog_index.m3u8"
+        }
+      },
+      "500kbs": {
+        Angle1: {
+          autoselect: true,
+          default: true
+        },
+        Angle2: {
+          autoselect: true,
+          default: false,
+          uri: "Angle2/500kbs/prog_index.m3u8"
+        },
+        Angle3: {
+          autoselect: true,
+          default: false,
+          uri: "Angle3/500kbs/prog_index.m3u8"
+        }
+      }
+    },
+    "CLOSED-CAPTIONS": {},
+    SUBTITLES: {}
+  },
+  playlists: [{
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 300000,
+      CODECS: "mp4a.40.2,avc1.4d401e",
+      AUDIO: "aac",
+      VIDEO: "200kbs"
+    },
+    timeline: 0,
+    uri: "Angle1/200kbs/prog_index.m3u"
+  }, {
+    attributes: {
+      "PROGRAM-ID": 1,
+      BANDWIDTH: 754857,
+      CODECS: "mp4a.40.2,avc1.4d401e",
+      AUDIO: "aac",
+      VIDEO: "500kbs"
+    },
+    timeline: 0,
+    uri: "Angle1/500kbs/prog_index.m3u8"
+  }]
+}

+#EXTM3U
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="200kbs",NAME="Angle1",AUTOSELECT=YES,DEFAULT=YES
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="200kbs",NAME="Angle2",AUTOSELECT=YES,DEFAULT=NO,URI="Angle2/200kbs/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="200kbs",NAME="Angle3",AUTOSELECT=YES,DEFAULT=NO,URI="Angle3/200kbs/prog_index.m3u8"
+ 
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="500kbs",NAME="Angle1",AUTOSELECT=YES,DEFAULT=YES
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="500kbs",NAME="Angle2",AUTOSELECT=YES,DEFAULT=NO,URI="Angle2/500kbs/prog_index.m3u8"
+#EXT-X-MEDIA:TYPE=VIDEO,GROUP-ID="500kbs",NAME="Angle3",AUTOSELECT=YES,DEFAULT=NO,URI="Angle3/500kbs/prog_index.m3u8"
+ 
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aac",LANGUAGE="eng",NAME="English",AUTOSELECT=YES,DEFAULT=YES,URI="eng/prog_index.m3u8"
+ 
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=300000,CODECS="mp4a.40.2,avc1.4d401e",VIDEO="200kbs",AUDIO="aac"
+Angle1/200kbs/prog_index.m3u
+ 
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=754857,CODECS="mp4a.40.2,avc1.4d401e",VIDEO="500kbs",AUDIO="aac"
+Angle1/500kbs/prog_index.m3u8
\ No newline at end of file

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 6.08,
       "duration": 6.08,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 6.6,
       "duration": 6.6,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -9,6 +9,7 @@
         "offset": 0
         "offset": 0
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -17,6 +18,7 @@
         "offset": 522828
         "offset": 522828
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -25,6 +27,7 @@
         "offset": 1110328
         "offset": 1110328
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -33,6 +36,7 @@
         "offset": 1823412
         "offset": 1823412
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -41,6 +45,7 @@
         "offset": 2299992
         "offset": 2299992
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -49,6 +54,7 @@
         "offset": 2835604
         "offset": 2835604
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -57,6 +63,7 @@
         "offset": 3042780
         "offset": 3042780
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -65,6 +72,7 @@
         "offset": 3498680
         "offset": 3498680
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -73,6 +81,7 @@
         "offset": 4155928
         "offset": 4155928
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -81,6 +90,7 @@
         "offset": 4727636
         "offset": 4727636
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -89,6 +99,7 @@
         "offset": 5212676
         "offset": 5212676
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -97,6 +108,7 @@
         "offset": 5921812
         "offset": 5921812
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -105,6 +117,7 @@
         "offset": 6651816
         "offset": 6651816
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -113,6 +126,7 @@
         "offset": 7108092
         "offset": 7108092
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -121,6 +135,7 @@
         "offset": 7576776
         "offset": 7576776
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -129,6 +144,7 @@
         "offset": 8021772
         "offset": 8021772
       },
       },
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     },
     },
     {
     {
@@ -137,6 +153,7 @@
         "offset": 8353216
         "offset": 8353216
       },
       },
       "duration": 1.4167,
       "duration": 1.4167,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -144,4 +161,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,6 +5,7 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     }
     }
   ],
   ],
@@ -12,4 +13,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,11 +5,19 @@
       "attributes": {
       "attributes": {
         "PROGRAM-ID": 1
         "PROGRAM-ID": 1
       },
       },
+      "timeline": 0,
       "uri": "media.m3u8"
       "uri": "media.m3u8"
     },
     },
     {
     {
+      "timeline": 0,
       "uri": "media1.m3u8"
       "uri": "media1.m3u8"
     }
     }
   ],
   ],
-  "discontinuityStarts": []
-}
\ No newline at end of file
+  "discontinuityStarts": [],
+  "mediaGroups": {
+    "VIDEO": {},
+    "AUDIO": {},
+    "CLOSED-CAPTIONS": {},
+    "SUBTITLES": {}
+  }
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 6.64,
       "duration": 6.64,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
       "uri": "/test/ts-files/tvy7/8a5e2822668b5370f4eb1438b2564fb7ab12ffe1-hi720.ts"
     },
     },
     {
     {
       "duration": 6.08,
       "duration": 6.08,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
       "uri": "/test/ts-files/tvy7/56be1cef869a1c0cc8e38864ad1add17d187f051-hi720.ts"
     },
     },
     {
     {
       "duration": 6.6,
       "duration": 6.6,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
       "uri": "/test/ts-files/tvy7/549c8c77f55f049741a06596e5c1e01dacaa46d0-hi720.ts"
     },
     },
     {
     {
       "duration": 5,
       "duration": 5,
+      "timeline": 0,
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
       "uri": "/test/ts-files/tvy7/6cfa378684ffeb1c455a64dae6c103290a1f53d4-hi720.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,6 +5,7 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "hls_450k_video.ts"
       "uri": "hls_450k_video.ts"
     }
     }
   ],
   ],
@@ -12,4 +13,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

@@ -5,18 +5,22 @@
   "segments": [
   "segments": [
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "http://example.com/00001.ts"
       "uri": "http://example.com/00001.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "https://example.com/00002.ts"
       "uri": "https://example.com/00002.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "//example.com/00003.ts"
       "uri": "//example.com/00003.ts"
     },
     },
     {
     {
       "duration": 10,
       "duration": 10,
+      "timeline": 0,
       "uri": "http://example.com/00004.ts"
       "uri": "http://example.com/00004.ts"
     }
     }
   ],
   ],
@@ -24,4 +28,4 @@
   "endList": true,
   "endList": true,
   "discontinuitySequence": 0,
   "discontinuitySequence": 0,
   "discontinuityStarts": []
   "discontinuityStarts": []
-}
\ No newline at end of file
+}

+(function(videojs) {
+  var Component = videojs.getComponent('Component');
+
+  // -----------------
+  // AudioTrackMenuItem
+  // -----------------
+  //
+  var MenuItem = videojs.getComponent('MenuItem');
+
+  var AudioTrackMenuItem = videojs.extend(MenuItem, {
+    constructor: function(player, options) {
+      var track = options.track;
+      var tracks = player.audioTracks();
+
+      options.label = track.label || track.language || 'Unknown';
+      options.selected = track.enabled;
+
+      MenuItem.call(this, player, options);
+
+      this.track = track;
+
+      if (tracks) {
+        var changeHandler = videojs.bind(this, this.handleTracksChange);
+
+        tracks.addEventListener('change', changeHandler);
+        this.on('dispose', function() {
+          tracks.removeEventListener('change', changeHandler);
+        });
+      }
+    },
+
+    handleClick: function(event) {
+      var kind = this.track.kind;
+      var tracks = this.player_.audioTracks();
+
+      MenuItem.prototype.handleClick.call(this, event);
+
+      if (!tracks) return;
+
+      for (var i = 0; i < tracks.length; i++) {
+        var track = tracks[i];
+
+        if (track === this.track) {
+          track.enabled = true;
+        }
+      }
+    },
+
+    handleTracksChange: function(event) {
+      this.selected(this.track.enabled);
+    }
+  });
+
+  Component.registerComponent('AudioTrackMenuItem', AudioTrackMenuItem);
+
+  // -----------------
+  // AudioTrackButton
+  // -----------------
+  //
+  var MenuButton = videojs.getComponent('MenuButton');
+
+  var AudioTrackButton = videojs.extend(MenuButton, {
+    constructor: function(player, options) {
+      MenuButton.call(this, player, options);
+      this.el_.setAttribute('aria-label','Audio Menu');
+
+      var tracks = this.player_.audioTracks();
+
+      if (this.items.length <= 1) {
+        this.hide();
+      }
+
+      if (!tracks) {
+        return;
+      }
+
+      var updateHandler = videojs.bind(this, this.update);
+      tracks.addEventListener('removetrack', updateHandler);
+      tracks.addEventListener('addtrack', updateHandler);
+
+      this.player_.on('dispose', function() {
+        tracks.removeEventListener('removetrack', updateHandler);
+        tracks.removeEventListener('addtrack', updateHandler);
+      });
+    },
+
+    buildCSSClass() {
+      return 'vjs-subtitles-button ' + MenuButton.prototype.buildCSSClass.call(this);
+    },
+
+    createItems: function(items) {
+      items = items || [];
+
+      var tracks = this.player_.audioTracks();
+
+      if (!tracks) {
+        return items;
+      }
+
+      for (var i = 0; i < tracks.length; i++) {
+        var track = tracks[i];
+
+        items.push(new AudioTrackMenuItem(this.player_, {
+          'selectable': true,
+          'track': track
+        }));
+      }
+
+      return items;
+    }
+  });
+
+  Component.registerComponent('AudioTrackButton', AudioTrackButton);
+})(window.videojs);

@@ -9,28 +9,16 @@
   <!-- video.js -->
   <!-- video.js -->
   <script src="../../node_modules/video.js/dist/video.js"></script>
   <script src="../../node_modules/video.js/dist/video.js"></script>
 
 
-  <!-- Media Sources plugin -->
-  <script src="../../node_modules/videojs-contrib-media-sources/dist/videojs-media-sources.js"></script>
-
   <!-- HLS plugin -->
   <!-- HLS plugin -->
-  <script src="../../src/videojs-hls.js"></script>
-
-  <!-- m3u8 handling -->
-  <script src="../../src/xhr.js"></script>
-  <script src="../../src/stream.js"></script>
-  <script src="../../src/m3u8/m3u8-parser.js"></script>
-  <script src="../../src/playlist.js"></script>
-  <script src="../../src/playlist-loader.js"></script>
+  <script src="../../dist/videojs-contrib-hls.js"></script>
 
 
-  <script src="../../node_modules/pkcs7/dist/pkcs7.unpad.js"></script>
-  <script src="../../src/decrypter.js"></script>
+  <!-- Track Selector plugin -->
+  <script src="audio-track-selector.js"></script>
 
 
   <!-- player stats visualization -->
   <!-- player stats visualization -->
   <link href="stats.css" rel="stylesheet">
   <link href="stats.css" rel="stylesheet">
   <script src="../switcher/js/vendor/d3.min.js"></script>
   <script src="../switcher/js/vendor/d3.min.js"></script>
 
 
-  <!-- debugging -->
-  <script src="../../src/bin-utils.js"></script>
   <style>
   <style>
     body {
     body {
       font-family: Arial, sans-serif;
       font-family: Arial, sans-serif;
@@ -43,13 +31,12 @@
       padding: 0 5px;
       padding: 0 5px;
       margin: 20px 0;
       margin: 20px 0;
     }
     }
-  </style>
-
-  <script>
-    if (window.location.search === '?flash') {
-      videojs.options.techOrder = ['flash'];
+    input {
+      margin-top: 15px;
+      min-width: 450px;
+      padding: 5px;
     }
     }
-  </script>
+  </style>
 
 
 </head>
 </head>
 <body>
 <body>
@@ -57,18 +44,50 @@
     <p>The video below is an <a href="https://developer.apple.com/library/ios/documentation/networkinginternet/conceptual/streamingmediaguide/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008332-CH1-SW1">HTTP Live Stream</a>. On desktop browsers other than Safari, the HLS plugin will polyfill support for the format on top of the video.js Flash tech.</p>
     <p>The video below is an <a href="https://developer.apple.com/library/ios/documentation/networkinginternet/conceptual/streamingmediaguide/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008332-CH1-SW1">HTTP Live Stream</a>. On desktop browsers other than Safari, the HLS plugin will polyfill support for the format on top of the video.js Flash tech.</p>
     <p>Due to security restrictions in Flash, you will have to load this page over HTTP(S) to see the example in action.</p>
     <p>Due to security restrictions in Flash, you will have to load this page over HTTP(S) to see the example in action.</p>
   </div>
   </div>
-  <video id="video"
-         class="video-js vjs-default-skin"
-         height="300"
-         width="600"
-         controls>
-    <source
-       src="http://solutions.brightcove.com/jwhisenant/hls/apple/bipbop/bipbopall.m3u8"
-       type="application/x-mpegURL">
-    <source
-       src="http://s3.amazonaws.com/_bc_dml/example-content/bipbop-id3/index.m3u8"
-       type="application/x-mpegURL">
-  </video>
+
+  <div id="fixture">
+  </div>
+
+  <form id="load-url">
+    <label>
+      URL to Load:
+      <input id="url-to-load" type="url" value="https://s3.amazonaws.com/_bc_dml/example-content/bipbop-advanced/bipbop_16x9_variant.m3u8">
+    </label>
+    <br>
+    <label>
+      Player Options:
+      <input id="player-options" type="text" value='{}'>
+    </label>
+    <br>
+    <label>
+      URL Content Type:
+      <input id="url-content-type" type="text" value="application/x-mpegURL">
+    </label>
+    <br>
+    <label>
+      Default Caption Track Label (blank for none):
+      <input id="caption-track" type="text" value="">
+    </label>
+    <br>
+    <label>
+      Technology Mode:
+      <input type="radio" name="technology-mode" value="auto" checked> Auto
+      <input type="radio" name="technology-mode" value="html"> HTML
+      <input type="radio" name="technology-mode" value="flash"> Flash
+    </label>
+    <br>
+    <label>
+      Autoplay:
+      <input type="radio" name="autoplay" value="on"> On
+      <input type="radio" name="autoplay" value="off" checked> Off
+    </label>
+
+    <br>
+    <br>
+    <button type="submit">Load</button>
+  </form>
+  <br>
+
   <section class="stats">
   <section class="stats">
     <div class="player-stats">
     <div class="player-stats">
       <h2>Player Stats</h2>
       <h2>Player Stats</h2>
@@ -109,98 +128,181 @@
 
 
   <script src="stats.js"></script>
   <script src="stats.js"></script>
   <script>
   <script>
-    videojs.options.flash.swf = '../../node_modules/videojs-swf/dist/video-js.swf';
-    // initialize the player
-    var player = videojs('video').ready(function() {
-
-      // ------------
-      // Player Stats
-      // ------------
-
-      var currentTimeStat = document.querySelector('.current-time-stat');
-      var bufferedStat = document.querySelector('.buffered-stat');
-      var seekableStartStat = document.querySelector('.seekable-start-stat');
-      var seekableEndStat = document.querySelector('.seekable-end-stat');
-      var videoBitrateState = document.querySelector('.video-bitrate-stat');
-      var measuredBitrateStat = document.querySelector('.measured-bitrate-stat');
-
-      player.on('timeupdate', function() {
-        currentTimeStat.textContent = player.currentTime().toFixed(1);
-      });
+    function getCheckedValue(name) {
+      var radios = document.getElementsByName(name);
+      var value;
+      for (var i = 0, length = radios.length; i < length; i++) {
+        if (radios[i].checked) {
+          value = radios[i].value;
+          break;
+        }
+      }
+      return value;
+    }
 
 
-      window.setInterval(function() {
-        var bufferedText = '', oldStart, oldEnd, i;
+    function createPlayer(cb) {
+      if (window.stats_timer) {
+        clearInterval(window.stats_timer);
+      }
+      // dispose of existing player
+      if(window.player) {
+        window.player.dispose();
+      }
 
 
-        // buffered
-        var buffered = player.buffered();
-        if (buffered.length) {
-          bufferedText += buffered.start(0) + ' - ' + buffered.end(0);
+      // create video element in the dom
+      var video = document.createElement('video');
+      video.id = 'videojs-contrib-hls-player';
+      video.className = 'video-js vjs-default-skin';
+      video.setAttribute('controls', true);
+      video.setAttribute('height', 300);
+      video.setAttribute('width', 600);
+      document.querySelector('#fixture').appendChild(video);
+      var techRadios = document.getElementsByName('technology-mode');
+      var techMode = getCheckedValue('technology-mode') || 'auto';
+      var autoplay = getCheckedValue('autoplay') || 'off';
+      var captionTrack = document.getElementById('caption-track').value || "";
+      var url = document.getElementById('url-to-load').value || "";
+      var options = {};
+      // try to parse options from the form
+      try {
+        options = JSON.parse(document.getElementById('player-options').value);
+      } catch(err) {
+        console.log("Reseting options to {}, JSON Parse Error:", err);
+      }
+      if(typeof options.techOrder === 'undefined') {
+        if (techMode === 'html') {
+          options.techOrder = ['html5'];
+        } else if (techMode === 'flash') {
+          options.techOrder = ['flash'];
         }
         }
-        for (i = 1; i < buffered.length; i++) {
-          bufferedText += ', ' + buffered.start(i) + ' - ' + buffered.end(i);
+      }
+      if(typeof options.autoplay === 'undefined') {
+        if (autoplay === 'on') {
+          options.autoplay = true;
+        } else if (techMode === 'off') {
+          options.autoplay = false;
         }
         }
-        bufferedStat.textContent = bufferedText;
+      }
+      var type = document.getElementById('url-content-type').value;
+      // use the form data to add a src to the player
+      try {
+        window.player = videojs(video.id, options);
+        if(captionTrack) {
+          // hackey way to show captions
+          window.player.on('loadeddata', function(event) {
+            textTracks = this.textTracks().tracks_;
+            for(var i = 0; i < textTracks.length; i++) {
+              if(textTracks[i].label === captionTrack) {
+                console.log("Found matching track, going to show " + captionTrack);
+                textTracks[i].mode = "showing";
+                break;
+              }
+            }
+          });
+        }
+        window.player.src({
+          src: url,
+          type: type
+        });
+
+        cb(player);
+      } catch(err) {
+        console.log("caught an error trying to create and add src to player:", err);
+      }
+    }
+
+    function setup(player) {
+      player.ready(function() {
 
 
-        // seekable
-        var seekable = player.seekable();
-        if (seekable && seekable.length) {
+        // ------------
+        // Audio Track Switcher
+        // ------------
 
 
-          oldStart = seekableStartStat.textContent;
-          if (seekable.start(0).toFixed(1) !== oldStart) {
-            seekableStartStat.textContent = seekable.start(0).toFixed(1);
+        player.controlBar.addChild('AudioTrackButton', {}, 13);
+
+        // ------------
+        // Player Stats
+        // ------------
+
+        var currentTimeStat = document.querySelector('.current-time-stat');
+        var bufferedStat = document.querySelector('.buffered-stat');
+        var seekableStartStat = document.querySelector('.seekable-start-stat');
+        var seekableEndStat = document.querySelector('.seekable-end-stat');
+        var videoBitrateState = document.querySelector('.video-bitrate-stat');
+        var measuredBitrateStat = document.querySelector('.measured-bitrate-stat');
+
+        player.on('timeupdate', function() {
+          currentTimeStat.textContent = player.currentTime().toFixed(1);
+        });
+
+        window.stats_timer = window.setInterval(function() {
+          var bufferedText = '', oldStart, oldEnd, i;
+
+          // buffered
+          var buffered = player.buffered();
+          if (buffered.length) {
+            bufferedText += buffered.start(0) + ' - ' + buffered.end(0);
           }
           }
-          oldEnd = seekableEndStat.textContent;
-          if (seekable.end(0).toFixed(1) !== oldEnd) {
-            seekableEndStat.textContent = seekable.end(0).toFixed(1);
+          for (i = 1; i < buffered.length; i++) {
+            bufferedText += ', ' + buffered.start(i) + ' - ' + buffered.end(i);
           }
           }
-        }
+          bufferedStat.textContent = bufferedText;
 
 
-        // bitrates
-        var playlist = player.tech_.hls.playlists.media();
-        if (playlist && playlist.attributes && playlist.attributes.BANDWIDTH) {
-          videoBitrateState.textContent = (playlist.attributes.BANDWIDTH / 1024).toLocaleString(undefined, {
-            maximumFractionDigits: 1
-          }) + ' kbps';
-        }
-        if (player.tech_.hls.bandwidth) {
-          measuredBitrateStat.textContent = (player.tech_.hls.bandwidth / 1024).toLocaleString(undefined, {
-            maximumFractionDigits: 1
-          }) + ' kbps';
-        }
-      }, 1000);
+          // seekable
+          var seekable = player.seekable();
+          if (seekable && seekable.length) {
 
 
-      var trackEventCount = function(eventName, selector) {
-        var count = 0, element = document.querySelector(selector);
-        player.on(eventName, function() {
-          count++;
-          element.innerHTML = count;
-        });
-      };
-      trackEventCount('play', '.play-count');
-      trackEventCount('playing', '.playing-count');
-      trackEventCount('seeking', '.seeking-count');
-      trackEventCount('seeked', '.seeked-count');
-
-      videojs.Hls.displayStats(document.querySelector('.switching-stats'), player);
-      videojs.Hls.displayCues(document.querySelector('.segment-timeline'), player);
-    });
-
-    // -----------
-    // Tech Switch
-    // -----------
-
-    var techSwitch = document.createElement('a');
-    techSwitch.className = 'tech-switch';
-    if (player.el().querySelector('video')) {
-      techSwitch.href = window.location.origin + window.location.pathname + '?flash';
-      techSwitch.appendChild(document.createTextNode('Switch to the Flash tech'));
-    } else {
-      techSwitch.href = window.location.origin + window.location.pathname;
-      techSwitch.appendChild(document.createTextNode('Stop forcing Flash'));
-    }
+            oldStart = seekableStartStat.textContent;
+            if (seekable.start(0).toFixed(1) !== oldStart) {
+              seekableStartStat.textContent = seekable.start(0).toFixed(1);
+            }
+            oldEnd = seekableEndStat.textContent;
+            if (seekable.end(0).toFixed(1) !== oldEnd) {
+              seekableEndStat.textContent = seekable.end(0).toFixed(1);
+            }
+          }
+
+          // bitrates
+          var playlist = player.tech_.hls.playlists.media();
+          if (playlist && playlist.attributes && playlist.attributes.BANDWIDTH) {
+            videoBitrateState.textContent = (playlist.attributes.BANDWIDTH / 1024).toLocaleString(undefined, {
+              maximumFractionDigits: 1
+            }) + ' kbps';
+          }
+          if (player.tech_.hls.bandwidth) {
+            measuredBitrateStat.textContent = (player.tech_.hls.bandwidth / 1024).toLocaleString(undefined, {
+              maximumFractionDigits: 1
+            }) + ' kbps';
+          }
+        }, 1000);
 
 
-    document.body.insertBefore(techSwitch, document.querySelector('.stats'));
+        var trackEventCount = function(eventName, selector) {
+          var count = 0, element = document.querySelector(selector);
+          player.on(eventName, function() {
+            count++;
+            element.innerHTML = count;
+          });
+        };
+        trackEventCount('play', '.play-count');
+        trackEventCount('playing', '.playing-count');
+        trackEventCount('seeking', '.seeking-count');
+        trackEventCount('seeked', '.seeked-count');
 
 
+        videojs.Hls.displayStats(document.querySelector('.switching-stats'), player);
+        videojs.Hls.displayCues(document.querySelector('.segment-timeline'), player);
+      });
+    }
+
+    (function(window, videojs) {
+      videojs.options.flash.swf = '../../node_modules/videojs-swf/dist/video-js.swf';
+      createPlayer(setup);
+      // hook up the video switcher
+      document.getElementById('load-url').addEventListener('submit', function(event) {
+        event.preventDefault();
+        createPlayer(setup);
+        return false;
+      });
+    }(window, window.videojs));
   </script>
   </script>
 </body>
 </body>
 </html>
 </html>