From 67a1201c14b2791fd3014a0d5e34f431ce8343b2 Mon Sep 17 00:00:00 2001
From: Brandon Casey <2381475+brandonocasey@users.noreply.github.com>
Date: Tue, 27 Jul 2021 16:19:52 -0400
Subject: [PATCH] feat: Add experimentalExactManifestTimings which forgoes
 TIME_FUDGE_FACTOR during segment choice (#1165)

---
 index.html                        |    4 +
 scripts/index-demo-page.js        |    5 +-
 src/master-playlist-controller.js |    3 +-
 src/playlist.js                   |   61 +-
 src/segment-loader.js             |    2 +
 src/videojs-http-streaming.js     |    1 +
 test/playlist.test.js             | 1034 +++++++++++++++--------------
 7 files changed, 568 insertions(+), 542 deletions(-)

diff --git a/index.html b/index.html
index f0fd335f8..a5cdfbc8c 100644
--- a/index.html
+++ b/index.html
@@ -84,6 +84,10 @@ <h3>Options</h3>
       <input id=buffer-water type="checkbox">
       [EXPERIMENTAL] Use Buffer Level for ABR (reloads player)
     </label>
+    <label>
+      <input id=exact-manifest-timings type="checkbox">
+      [EXPERIMENTAL] Use exact manifest timings for segment choices (reloads player)
+    </label>
     <label>
       <input id=pixel-diff-selector type="checkbox">
       [EXPERIMENTAL] Use the Pixel difference resolution selector (reloads player)
diff --git a/scripts/index-demo-page.js b/scripts/index-demo-page.js
index 2f00e4ec4..9df5eecac 100644
--- a/scripts/index-demo-page.js
+++ b/scripts/index-demo-page.js
@@ -245,6 +245,7 @@
     'type',
     'keysystems',
     'buffer-water',
+    'exact-manifest-timings',
     'pixel-diff-selector',
     'override-native',
     'preload',
@@ -285,7 +286,8 @@
       'buffer-water',
       'override-native',
       'liveui',
-      'pixel-diff-selector'
+      'pixel-diff-selector',
+      'exact-manifest-timings'
     ].forEach(function(name) {
       stateEls[name].addEventListener('change', function(event) {
         saveState();
@@ -350,6 +352,7 @@
               overrideNative: getInputValue(stateEls['override-native']),
               experimentalBufferBasedABR: getInputValue(stateEls['buffer-water']),
               experimentalLLHLS: getInputValue(stateEls.llhls),
+              experimentalExactManifestTimings: getInputValue(stateEls['exact-manifest-timings']),
               experimentalLeastPixelDiffSelector: getInputValue(stateEls['pixel-diff-selector'])
             }
           }
diff --git a/src/master-playlist-controller.js b/src/master-playlist-controller.js
index 12217c018..329523c4d 100644
--- a/src/master-playlist-controller.js
+++ b/src/master-playlist-controller.js
@@ -234,7 +234,8 @@ export class MasterPlaylistController extends videojs.EventTarget {
       inbandTextTracks: this.inbandTextTracks_,
       cacheEncryptionKeys,
       sourceUpdater: this.sourceUpdater_,
-      timelineChangeController: this.timelineChangeController_
+      timelineChangeController: this.timelineChangeController_,
+      experimentalExactManifestTimings: options.experimentalExactManifestTimings
     };
 
     // The source type check not only determines whether a special DASH playlist loader
diff --git a/src/playlist.js b/src/playlist.js
index a1a053276..4bbe5f99b 100644
--- a/src/playlist.js
+++ b/src/playlist.js
@@ -382,7 +382,8 @@ export const getMediaInfoForTime = function({
   currentTime,
   startingSegmentIndex,
   startingPartIndex,
-  startTime
+  startTime,
+  experimentalExactManifestTimings
 }) {
 
   let time = currentTime - startTime;
@@ -415,19 +416,23 @@ export const getMediaInfoForTime = function({
 
         time += partAndSegment.duration;
 
-        // TODO: consider not using TIME_FUDGE_FACTOR at all here
-        if ((time + TIME_FUDGE_FACTOR) > 0) {
-          return {
-            partIndex: partAndSegment.partIndex,
-            segmentIndex: partAndSegment.segmentIndex,
-            startTime: startTime - sumDurations({
-              defaultDuration: playlist.targetDuration,
-              durationList: partsAndSegments,
-              startIndex,
-              endIndex: i
-            })
-          };
+        if (experimentalExactManifestTimings) {
+          if (time < 0) {
+            continue;
+          }
+        } else if ((time + TIME_FUDGE_FACTOR) <= 0) {
+          continue;
         }
+        return {
+          partIndex: partAndSegment.partIndex,
+          segmentIndex: partAndSegment.segmentIndex,
+          startTime: startTime - sumDurations({
+            defaultDuration: playlist.targetDuration,
+            durationList: partsAndSegments,
+            startIndex,
+            endIndex: i
+          })
+        };
       }
     }
 
@@ -446,6 +451,7 @@ export const getMediaInfoForTime = function({
   if (startIndex < 0) {
     for (let i = startIndex; i < 0; i++) {
       time -= playlist.targetDuration;
+
       if (time < 0) {
         return {
           partIndex: partsAndSegments[0] && partsAndSegments[0].partIndex || null,
@@ -464,19 +470,24 @@ export const getMediaInfoForTime = function({
 
     time -= partAndSegment.duration;
 
-    // TODO: consider not using TIME_FUDGE_FACTOR at all here
-    if ((time - TIME_FUDGE_FACTOR) < 0) {
-      return {
-        partIndex: partAndSegment.partIndex,
-        segmentIndex: partAndSegment.segmentIndex,
-        startTime: startTime + sumDurations({
-          defaultDuration: playlist.targetDuration,
-          durationList: partsAndSegments,
-          startIndex,
-          endIndex: i
-        })
-      };
+    if (experimentalExactManifestTimings) {
+      if (time > 0) {
+        continue;
+      }
+    } else if ((time - TIME_FUDGE_FACTOR) >= 0) {
+      continue;
     }
+
+    return {
+      partIndex: partAndSegment.partIndex,
+      segmentIndex: partAndSegment.segmentIndex,
+      startTime: startTime + sumDurations({
+        defaultDuration: playlist.targetDuration,
+        durationList: partsAndSegments,
+        startIndex,
+        endIndex: i
+      })
+    };
   }
 
   // We are out of possible candidates so load the last one...
diff --git a/src/segment-loader.js b/src/segment-loader.js
index 9ea2a43b9..2b9d5a202 100644
--- a/src/segment-loader.js
+++ b/src/segment-loader.js
@@ -539,6 +539,7 @@ export default class SegmentLoader extends videojs.EventTarget {
     this.timelineChangeController_ = settings.timelineChangeController;
     this.shouldSaveSegmentTimingInfo_ = true;
     this.parse708captions_ = settings.parse708captions;
+    this.experimentalExactManifestTimings = settings.experimentalExactManifestTimings;
 
     // private instance variables
     this.checkBufferTimeout_ = null;
@@ -1404,6 +1405,7 @@ export default class SegmentLoader extends videojs.EventTarget {
     } else {
       // Find the segment containing the end of the buffer or current time.
       const {segmentIndex, startTime, partIndex} = Playlist.getMediaInfoForTime({
+        experimentalExactManifestTimings: this.experimentalExactManifestTimings,
         playlist: this.playlist_,
         currentTime: this.fetchAtBuffer_ ? bufferedEnd : this.currentTime_(),
         startingPartIndex: this.syncPoint_.partIndex,
diff --git a/src/videojs-http-streaming.js b/src/videojs-http-streaming.js
index 3e1101358..179999816 100644
--- a/src/videojs-http-streaming.js
+++ b/src/videojs-http-streaming.js
@@ -682,6 +682,7 @@ class VhsHandler extends Component {
       'experimentalBufferBasedABR',
       'liveRangeSafeTimeDelta',
       'experimentalLLHLS',
+      'experimentalExactManifestTimings',
       'experimentalLeastPixelDiffSelector'
     ].forEach((option) => {
       if (typeof this.source_[option] !== 'undefined') {
diff --git a/test/playlist.test.js b/test/playlist.test.js
index bcb95ffb2..824b40354 100644
--- a/test/playlist.test.js
+++ b/test/playlist.test.js
@@ -957,28 +957,91 @@ QUnit.module('Playlist', function() {
     assert.ok(Playlist.isAes(media), 'media is an AES encrypted HLS stream');
   });
 
-  QUnit.module('Media Index For Time', {
-    beforeEach(assert) {
-      this.env = useFakeEnvironment(assert);
-      this.clock = this.env.clock;
-      this.requests = this.env.requests;
-      this.fakeVhs = {
-        xhr: xhrFactory()
-      };
+  ['experimentalExactManifestTimings', ''].forEach((key) => {
+    QUnit.module(`Media Index For Time ${key}`, {
+      beforeEach(assert) {
+        this.env = useFakeEnvironment(assert);
+        this.clock = this.env.clock;
+        this.requests = this.env.requests;
+        this.fakeVhs = {
+          xhr: xhrFactory()
+        };
+
+        const experiment = {experimentalExactManifestTimings: key === 'experimentalExactManifestTimings'};
+
+        this.getMediaInfoForTime = (overrides) => {
+          return Playlist.getMediaInfoForTime(merge(this.defaults, overrides, experiment));
+        };
 
-      this.getMediaInfoForTime = (overrides) => {
-        return Playlist.getMediaInfoForTime(merge(this.defaults, overrides));
-      };
+      },
+      afterEach() {
+        this.env.restore();
+      }
+    });
 
-    },
-    afterEach() {
-      this.env.restore();
-    }
-  });
+    QUnit.test(
+      'can get media index by playback position for non-live videos',
+      function(assert) {
+        const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
+
+        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'
+        );
+
+        const media = loader.media();
+
+        this.defaults = {
+          playlist: media,
+          currentTime: -1,
+          startingSegmentIndex: 0,
+          startingPartIndex: null,
+          startTime: 0
+        };
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: -1}),
+          {partIndex: null, segmentIndex: 0, startTime: -1},
+          'the index is never less than zero'
+        );
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 0}),
+          {partIndex: null, segmentIndex: 0, startTime: 0},
+          'time zero is index zero'
+        );
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 3}),
+          {partIndex: null, segmentIndex: 0, startTime: 0},
+          'time three is index zero'
+        );
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 10}),
+          {partIndex: null, segmentIndex: 2, startTime: 9},
+          'time 10 is index 2'
+        );
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 22}),
+          {partIndex: null, segmentIndex: 2, startTime: 22},
+          'time greater than the length is index 2'
+        );
+      }
+    );
 
-  QUnit.test(
-    'can get media index by playback position for non-live videos',
-    function(assert) {
+    QUnit.test('rounding down works', function(assert) {
       const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
 
       loader.load();
@@ -987,12 +1050,18 @@ QUnit.module('Playlist', function() {
         200, null,
         '#EXTM3U\n' +
         '#EXT-X-MEDIA-SEQUENCE:0\n' +
-        '#EXTINF:4,\n' +
+        '#EXTINF:2,\n' +
         '0.ts\n' +
-        '#EXTINF:5,\n' +
+        '#EXTINF:2,\n' +
         '1.ts\n' +
-        '#EXTINF:6,\n' +
+        '#EXTINF:2,\n' +
         '2.ts\n' +
+        '#EXTINF:2,\n' +
+        '3.ts\n' +
+        '#EXTINF:2,\n' +
+        '4.ts\n' +
+        '#EXTINF:2,\n' +
+        '5.ts\n' +
         '#EXT-X-ENDLIST\n'
       );
 
@@ -1000,250 +1069,80 @@ QUnit.module('Playlist', function() {
 
       this.defaults = {
         playlist: media,
-        currentTime: -1,
+        currentTime: 2.1,
         startingSegmentIndex: 0,
         startingPartIndex: null,
         startTime: 0
       };
 
+      // 1 segment away
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: -1}),
-        {partIndex: null, segmentIndex: 0, startTime: -1},
-        'the index is never less than zero'
+        this.getMediaInfoForTime({currentTime: 2.1}),
+        {segmentIndex: 1, startTime: 2, partIndex: null},
+        '1 away 2 is correct'
       );
-
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 0}),
-        {partIndex: null, segmentIndex: 0, startTime: 0},
-        'time zero is index zero'
+        this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 1, startTime: 2}),
+        {segmentIndex: 2, startTime: 4, partIndex: null},
+        '1 away 3 is correct'
       );
-
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 3}),
-        {partIndex: null, segmentIndex: 0, startTime: 0},
-        'time three is index zero'
+        this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 2, startTime: 4}),
+        {segmentIndex: 3, startTime: 6, partIndex: null},
+        '1 away 4 is correct'
       );
-
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 10}),
-        {partIndex: null, segmentIndex: 2, startTime: 9},
-        'time 10 is index 2'
+        this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 3, startTime: 6}),
+        {segmentIndex: 4, startTime: 8, partIndex: null},
+        '1 away 5 is correct'
       );
-
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 22}),
-        {partIndex: null, segmentIndex: 2, startTime: 22},
-        'time greater than the length is index 2'
+        this.getMediaInfoForTime({currentTime: 10.1, startingSegmentIndex: 4, startTime: 8}),
+        {segmentIndex: 5, startTime: 10, partIndex: null},
+        '1 away 6 is correct'
       );
-    }
-  );
-
-  QUnit.test('rounding down works', function(assert) {
-    const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
-
-    loader.load();
-
-    this.requests.shift().respond(
-      200, null,
-      '#EXTM3U\n' +
-      '#EXT-X-MEDIA-SEQUENCE:0\n' +
-      '#EXTINF:2,\n' +
-      '0.ts\n' +
-      '#EXTINF:2,\n' +
-      '1.ts\n' +
-      '#EXTINF:2,\n' +
-      '2.ts\n' +
-      '#EXTINF:2,\n' +
-      '3.ts\n' +
-      '#EXTINF:2,\n' +
-      '4.ts\n' +
-      '#EXTINF:2,\n' +
-      '5.ts\n' +
-      '#EXT-X-ENDLIST\n'
-    );
-
-    const media = loader.media();
-
-    this.defaults = {
-      playlist: media,
-      currentTime: 2.1,
-      startingSegmentIndex: 0,
-      startingPartIndex: null,
-      startTime: 0
-    };
-
-    // 1 segment away
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 2.1}),
-      {segmentIndex: 1, startTime: 2, partIndex: null},
-      '1 away 2 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 1, startTime: 2}),
-      {segmentIndex: 2, startTime: 4, partIndex: null},
-      '1 away 3 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 2, startTime: 4}),
-      {segmentIndex: 3, startTime: 6, partIndex: null},
-      '1 away 4 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 3, startTime: 6}),
-      {segmentIndex: 4, startTime: 8, partIndex: null},
-      '1 away 5 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 10.1, startingSegmentIndex: 4, startTime: 8}),
-      {segmentIndex: 5, startTime: 10, partIndex: null},
-      '1 away 6 is correct'
-    );
-
-    // 2 segments away
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 0, startTime: 0}),
-      {segmentIndex: 2, startTime: 4, partIndex: null},
-      '2 away 3 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 1, startTime: 2}),
-      {segmentIndex: 3, startTime: 6, partIndex: null},
-      '2 away 4 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 2, startTime: 4}),
-      {segmentIndex: 4, startTime: 8, partIndex: null},
-      '2 away 5 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 10.1, startingSegmentIndex: 3, startTime: 6}),
-      {segmentIndex: 5, startTime: 10, partIndex: null},
-      '2 away 6 is correct'
-    );
-
-    // 3 segments away
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 0, startTime: 0}),
-      {segmentIndex: 3, startTime: 6, partIndex: null},
-      '3 away 4 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 1, startTime: 2}),
-      {segmentIndex: 4, startTime: 8, partIndex: null},
-      '3 away 5 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 10.1, startingSegmentIndex: 2, startTime: 4}),
-      {segmentIndex: 5, startTime: 10, partIndex: null},
-      '3 away 6 is correct'
-    );
-  });
 
-  QUnit.test('rounding up works', function(assert) {
-    const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
-
-    loader.load();
-
-    this.requests.shift().respond(
-      200, null,
-      '#EXTM3U\n' +
-      '#EXT-X-MEDIA-SEQUENCE:0\n' +
-      '#EXTINF:2,\n' +
-      '0.ts\n' +
-      '#EXTINF:2,\n' +
-      '1.ts\n' +
-      '#EXTINF:2,\n' +
-      '2.ts\n' +
-      '#EXTINF:2,\n' +
-      '3.ts\n' +
-      '#EXTINF:2,\n' +
-      '4.ts\n' +
-      '#EXTINF:2,\n' +
-      '5.ts\n' +
-      '#EXT-X-ENDLIST\n'
-    );
-
-    const media = loader.media();
-
-    this.defaults = {
-      playlist: media,
-      currentTime: 2.1,
-      startingSegmentIndex: 0,
-      startingPartIndex: null,
-      startTime: 0
-    };
-
-    // 1 segment away
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 0, startingSegmentIndex: 1, startTime: 2}),
-      {segmentIndex: 0, startTime: 0, partIndex: null},
-      '1 away 1 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 2.1, startingSegmentIndex: 2, startTime: 4}),
-      {segmentIndex: 1, startTime: 2, partIndex: null},
-      '1 away 2 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 3, startTime: 6}),
-      {segmentIndex: 2, startTime: 4, partIndex: null},
-      '1 away 3 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 4, startTime: 8}),
-      {segmentIndex: 3, startTime: 6, partIndex: null},
-      '1 away 4 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 5, startTime: 10}),
-      {segmentIndex: 4, startTime: 8, partIndex: null},
-      '1 away 5 is correct'
-    );
-
-    // 2 segments away
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 0, startingSegmentIndex: 2, startTime: 4}),
-      {segmentIndex: 0, startTime: 0, partIndex: null},
-      '2 away 1 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 2.1, startingSegmentIndex: 3, startTime: 6}),
-      {segmentIndex: 1, startTime: 2, partIndex: null},
-      '2 away 2 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 4, startTime: 8}),
-      {segmentIndex: 2, startTime: 4, partIndex: null},
-      '2 away 3 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 5, startTime: 10}),
-      {segmentIndex: 3, startTime: 6, partIndex: null},
-      '2 away 4 is correct'
-    );
-
-    // 3 segments away
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 0, startingSegmentIndex: 3, startTime: 6}),
-      {segmentIndex: 0, startTime: 0, partIndex: null},
-      '3 away 1 is correct'
-    );
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 2.1, startingSegmentIndex: 4, startTime: 8}),
-      {segmentIndex: 1, startTime: 2, partIndex: null},
-      '3 away 2 is correct'
-    );
+      // 2 segments away
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 0, startTime: 0}),
+        {segmentIndex: 2, startTime: 4, partIndex: null},
+        '2 away 3 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 1, startTime: 2}),
+        {segmentIndex: 3, startTime: 6, partIndex: null},
+        '2 away 4 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 2, startTime: 4}),
+        {segmentIndex: 4, startTime: 8, partIndex: null},
+        '2 away 5 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 10.1, startingSegmentIndex: 3, startTime: 6}),
+        {segmentIndex: 5, startTime: 10, partIndex: null},
+        '2 away 6 is correct'
+      );
 
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 5, startTime: 10}),
-      {segmentIndex: 2, startTime: 4, partIndex: null},
-      '3 away 3 is correct'
-    );
-  });
+      // 3 segments away
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 0, startTime: 0}),
+        {segmentIndex: 3, startTime: 6, partIndex: null},
+        '3 away 4 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 1, startTime: 2}),
+        {segmentIndex: 4, startTime: 8, partIndex: null},
+        '3 away 5 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 10.1, startingSegmentIndex: 2, startTime: 4}),
+        {segmentIndex: 5, startTime: 10, partIndex: null},
+        '3 away 6 is correct'
+      );
+    });
 
-  QUnit.test(
-    'returns the lower index when calculating for a segment boundary',
-    function(assert) {
+    QUnit.test('rounding up works', function(assert) {
       const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
 
       loader.load();
@@ -1252,10 +1151,18 @@ QUnit.module('Playlist', function() {
         200, null,
         '#EXTM3U\n' +
         '#EXT-X-MEDIA-SEQUENCE:0\n' +
-        '#EXTINF:4,\n' +
+        '#EXTINF:2,\n' +
         '0.ts\n' +
-        '#EXTINF:5,\n' +
+        '#EXTINF:2,\n' +
         '1.ts\n' +
+        '#EXTINF:2,\n' +
+        '2.ts\n' +
+        '#EXTINF:2,\n' +
+        '3.ts\n' +
+        '#EXTINF:2,\n' +
+        '4.ts\n' +
+        '#EXTINF:2,\n' +
+        '5.ts\n' +
         '#EXT-X-ENDLIST\n'
       );
 
@@ -1263,34 +1170,210 @@ QUnit.module('Playlist', function() {
 
       this.defaults = {
         playlist: media,
-        currentTime: 0,
+        currentTime: 2.1,
         startingSegmentIndex: 0,
         startingPartIndex: null,
         startTime: 0
       };
 
+      // 1 segment away
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 0, startingSegmentIndex: 1, startTime: 2}),
+        {segmentIndex: 0, startTime: 0, partIndex: null},
+        '1 away 1 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 2.1, startingSegmentIndex: 2, startTime: 4}),
+        {segmentIndex: 1, startTime: 2, partIndex: null},
+        '1 away 2 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 3, startTime: 6}),
+        {segmentIndex: 2, startTime: 4, partIndex: null},
+        '1 away 3 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 4, startTime: 8}),
+        {segmentIndex: 3, startTime: 6, partIndex: null},
+        '1 away 4 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 8.1, startingSegmentIndex: 5, startTime: 10}),
+        {segmentIndex: 4, startTime: 8, partIndex: null},
+        '1 away 5 is correct'
+      );
+
+      // 2 segments away
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 4}),
+        this.getMediaInfoForTime({currentTime: 0, startingSegmentIndex: 2, startTime: 4}),
         {segmentIndex: 0, startTime: 0, partIndex: null},
-        'rounds down exact matches'
+        '2 away 1 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 2.1, startingSegmentIndex: 3, startTime: 6}),
+        {segmentIndex: 1, startTime: 2, partIndex: null},
+        '2 away 2 is correct'
       );
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 3.7}),
+        this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 4, startTime: 8}),
+        {segmentIndex: 2, startTime: 4, partIndex: null},
+        '2 away 3 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 6.1, startingSegmentIndex: 5, startTime: 10}),
+        {segmentIndex: 3, startTime: 6, partIndex: null},
+        '2 away 4 is correct'
+      );
+
+      // 3 segments away
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 0, startingSegmentIndex: 3, startTime: 6}),
         {segmentIndex: 0, startTime: 0, partIndex: null},
-        'rounds down'
+        '3 away 1 is correct'
+      );
+      assert.deepEqual(
+        this.getMediaInfoForTime({currentTime: 2.1, startingSegmentIndex: 4, startTime: 8}),
+        {segmentIndex: 1, startTime: 2, partIndex: null},
+        '3 away 2 is correct'
       );
 
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 4.5}),
-        {segmentIndex: 1, startTime: 4, partIndex: null},
-        'rounds up at 0.5'
+        this.getMediaInfoForTime({currentTime: 4.1, startingSegmentIndex: 5, startTime: 10}),
+        {segmentIndex: 2, startTime: 4, partIndex: null},
+        '3 away 3 is correct'
       );
-    }
-  );
+    });
 
-  QUnit.test(
-    'accounts for non-zero starting segment time when calculating media index',
-    function(assert) {
+    QUnit.test(
+      'returns the lower index when calculating for a segment boundary',
+      function(assert) {
+        const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
+
+        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'
+        );
+
+        const media = loader.media();
+
+        this.defaults = {
+          playlist: media,
+          currentTime: 0,
+          startingSegmentIndex: 0,
+          startingPartIndex: null,
+          startTime: 0
+        };
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 4}),
+          {segmentIndex: 0, startTime: 0, partIndex: null},
+          'rounds down exact matches'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 3.7}),
+          {segmentIndex: 0, startTime: 0, partIndex: null},
+          'rounds down'
+        );
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 4.5}),
+          {segmentIndex: 1, startTime: 4, partIndex: null},
+          'rounds up at 0.5'
+        );
+      }
+    );
+
+    QUnit.test(
+      'accounts for non-zero starting segment time when calculating media index',
+      function(assert) {
+        const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
+
+        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'
+        );
+
+        const media = loader.media();
+
+        this.defaults = {
+          playlist: media,
+          currentTime: 0,
+          startingSegmentIndex: 0,
+          startingPartIndex: null,
+          startTime: 0
+        };
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 45, startTime: 150}),
+          {segmentIndex: 0, startTime: 45, partIndex: null},
+          'expired content returns 0 for earliest segment available'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 75, startTime: 150}),
+          {segmentIndex: 0, startTime: 75, partIndex: null},
+          'expired content returns 0 for earliest segment available'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 0, startTime: 150}),
+          {segmentIndex: 0, startTime: 0, partIndex: null},
+          'time of 0 with no expired time returns first segment'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 150, startTime: 150}),
+          {segmentIndex: 0, startTime: 150, partIndex: null},
+          'calculates the earliest available position'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 152, startTime: 150}),
+          {segmentIndex: 0, startTime: 150, partIndex: null},
+          'calculates within the first segment'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 154, startTime: 150}),
+          {segmentIndex: 0, startTime: 150, partIndex: null},
+          'calculates earlier segment on exact boundary match'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 154.5, startTime: 150}),
+          {segmentIndex: 1, startTime: 154, partIndex: null},
+          'calculates within the second segment'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 156, startTime: 150}),
+          {segmentIndex: 1, startTime: 154, partIndex: null},
+          'calculates within the second segment'
+        );
+
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 159, startTime: 150}),
+          {segmentIndex: 1, startTime: 154, partIndex: null},
+          'returns last segment when time is equal to end of last segment'
+        );
+        assert.deepEqual(
+          this.getMediaInfoForTime({currentTime: 160, startTime: 150}),
+          {segmentIndex: 1, startTime: 160, partIndex: null},
+          'returns last segment when time is past end of last segment'
+        );
+      }
+    );
+
+    QUnit.test('can return a partIndex', function(assert) {
+      this.fakeVhs.options_ = {experimentalLLHLS: true};
       const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
 
       loader.load();
@@ -1302,7 +1385,11 @@ QUnit.module('Playlist', function() {
         '#EXTINF:4,\n' +
         '1001.ts\n' +
         '#EXTINF:5,\n' +
-        '1002.ts\n'
+        '1002.ts\n' +
+        '#EXT-X-PART:URI="1003.part1.ts",DURATION=1\n' +
+        '#EXT-X-PART:URI="1003.part2.ts",DURATION=1\n' +
+        '#EXT-X-PART:URI="1003.part3.ts",DURATION=1\n' +
+        '#EXT-X-PRELOAD-HINT:TYPE="PART",URI="1003.part4.ts"\n'
       );
 
       const media = loader.media();
@@ -1316,294 +1403,211 @@ QUnit.module('Playlist', function() {
       };
 
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 45, startTime: 150}),
-        {segmentIndex: 0, startTime: 45, partIndex: null},
-        'expired content returns 0 for earliest segment available'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 75, startTime: 150}),
-        {segmentIndex: 0, startTime: 75, partIndex: null},
-        'expired content returns 0 for earliest segment available'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 0, startTime: 150}),
-        {segmentIndex: 0, startTime: 0, partIndex: null},
-        'time of 0 with no expired time returns first segment'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 150, startTime: 150}),
-        {segmentIndex: 0, startTime: 150, partIndex: null},
-        'calculates the earliest available position'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 152, startTime: 150}),
-        {segmentIndex: 0, startTime: 150, partIndex: null},
-        'calculates within the first segment'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 154, startTime: 150}),
-        {segmentIndex: 0, startTime: 150, partIndex: null},
-        'calculates earlier segment on exact boundary match'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 154.5, startTime: 150}),
-        {segmentIndex: 1, startTime: 154, partIndex: null},
-        'calculates within the second segment'
-      );
-      assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 156, startTime: 150}),
-        {segmentIndex: 1, startTime: 154, partIndex: null},
-        'calculates within the second segment'
+        this.getMediaInfoForTime({currentTime: 10, startTime: 0}),
+        {segmentIndex: 2, startTime: 9, partIndex: 0},
+        'returns expected part/segment'
       );
 
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 159, startTime: 150}),
-        {segmentIndex: 1, startTime: 154, partIndex: null},
-        'returns last segment when time is equal to end of last segment'
+        this.getMediaInfoForTime({currentTime: 11, startTime: 0}),
+        {segmentIndex: 2, startTime: 10, partIndex: 1},
+        'returns expected part/segment'
       );
+
       assert.deepEqual(
-        this.getMediaInfoForTime({currentTime: 160, startTime: 150}),
-        {segmentIndex: 1, startTime: 160, partIndex: null},
-        'returns last segment when time is past end of last segment'
+        this.getMediaInfoForTime({currentTime: 11, segmentIndex: -15}),
+        {segmentIndex: 2, startTime: 10, partIndex: 1},
+        'returns expected part/segment'
       );
-    }
-  );
-
-  QUnit.test('can return a partIndex', function(assert) {
-    this.fakeVhs.options_ = {experimentalLLHLS: true};
-    const loader = new PlaylistLoader('media.m3u8', this.fakeVhs);
-
-    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' +
-      '#EXT-X-PART:URI="1003.part1.ts",DURATION=1\n' +
-      '#EXT-X-PART:URI="1003.part2.ts",DURATION=1\n' +
-      '#EXT-X-PART:URI="1003.part3.ts",DURATION=1\n' +
-      '#EXT-X-PRELOAD-HINT:TYPE="PART",URI="1003.part4.ts"\n'
-    );
-
-    const media = loader.media();
-
-    this.defaults = {
-      playlist: media,
-      currentTime: 0,
-      startingSegmentIndex: 0,
-      startingPartIndex: null,
-      startTime: 0
-    };
+    });
 
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 10, startTime: 0}),
-      {segmentIndex: 2, startTime: 9, partIndex: 0},
-      'returns expected part/segment'
-    );
+    QUnit.test('liveEdgeDelay works as expected', function(assert) {
+      const media = {
+        endList: true,
+        targetDuration: 5,
+        partTargetDuration: 1.1,
+        serverControl: {
+          holdBack: 20,
+          partHoldBack: 2
+        },
+        segments: [
+          {duration: 3},
+          {duration: 4, parts: [
+            {duration: 1},
+            {duration: 0.5}
+          ]},
+          {duration: 3, parts: [
+            {duration: 1},
+            {duration: 0.5}
+          ]},
+          {duration: 4, parts: [
+            {duration: 1},
+            {duration: 0.5}
+          ]}
+        ]
+      };
+      const master = {
+        suggestedPresentationDelay: 10
+      };
 
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 11, startTime: 0}),
-      {segmentIndex: 2, startTime: 10, partIndex: 1},
-      'returns expected part/segment'
-    );
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        0,
+        'returns 0 with endlist'
+      );
 
-    assert.deepEqual(
-      this.getMediaInfoForTime({currentTime: 11, segmentIndex: -15}),
-      {segmentIndex: 2, startTime: 10, partIndex: 1},
-      'returns expected part/segment'
-    );
-  });
+      delete media.endList;
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        master.suggestedPresentationDelay,
+        'uses suggestedPresentationDelay'
+      );
 
-  QUnit.test('liveEdgeDelay works as expected', function(assert) {
-    const media = {
-      endList: true,
-      targetDuration: 5,
-      partTargetDuration: 1.1,
-      serverControl: {
-        holdBack: 20,
-        partHoldBack: 2
-      },
-      segments: [
-        {duration: 3},
-        {duration: 4, parts: [
-          {duration: 1},
-          {duration: 0.5}
-        ]},
-        {duration: 3, parts: [
-          {duration: 1},
-          {duration: 0.5}
-        ]},
-        {duration: 4, parts: [
-          {duration: 1},
-          {duration: 0.5}
-        ]}
-      ]
-    };
-    const master = {
-      suggestedPresentationDelay: 10
-    };
+      delete master.suggestedPresentationDelay;
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        media.serverControl.partHoldBack,
+        'uses part hold back'
+      );
 
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      0,
-      'returns 0 with endlist'
-    );
+      media.serverControl.partHoldBack = null;
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        media.partTargetDuration * 3,
+        'uses part target duration * 3'
+      );
 
-    delete media.endList;
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      master.suggestedPresentationDelay,
-      'uses suggestedPresentationDelay'
-    );
+      media.partTargetDuration = null;
 
-    delete master.suggestedPresentationDelay;
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      media.serverControl.partHoldBack,
-      'uses part hold back'
-    );
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        media.serverControl.holdBack,
+        'uses hold back'
+      );
 
-    media.serverControl.partHoldBack = null;
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      media.partTargetDuration * 3,
-      'uses part target duration * 3'
-    );
+      media.serverControl.holdBack = null;
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        (media.targetDuration * 3),
+        'uses (targetDuration * 3)'
+      );
 
-    media.partTargetDuration = null;
+      media.targetDuration = null;
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        0,
+        'no target duration delay cannot be calcluated'
+      );
 
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      media.serverControl.holdBack,
-      'uses hold back'
-    );
+      media.segments = media.segments.map((s) => {
+        s.duration = null;
+        return s;
+      });
 
-    media.serverControl.holdBack = null;
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      (media.targetDuration * 3),
-      'uses (targetDuration * 3)'
-    );
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        0,
+        'no segment durations, live delay can\'t be calculated'
+      );
 
-    media.targetDuration = null;
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      0,
-      'no target duration delay cannot be calcluated'
-    );
+      media.segments.length = 0;
 
-    media.segments = media.segments.map((s) => {
-      s.duration = null;
-      return s;
+      assert.equal(
+        Playlist.liveEdgeDelay(master, media),
+        0,
+        'no segments, live delay can\'t be calculated'
+      );
     });
 
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      0,
-      'no segment durations, live delay can\'t be calculated'
-    );
-
-    media.segments.length = 0;
-
-    assert.equal(
-      Playlist.liveEdgeDelay(master, media),
-      0,
-      'no segments, live delay can\'t be calculated'
-    );
-  });
+    QUnit.test('playlistMatch', function(assert) {
+      assert.false(Playlist.playlistMatch(null, null), 'null playlists do not match');
+      assert.false(Playlist.playlistMatch({}, null), 'a playlist without b');
+      assert.false(Playlist.playlistMatch(null, {}), 'b playlist without a');
 
-  QUnit.test('playlistMatch', function(assert) {
-    assert.false(Playlist.playlistMatch(null, null), 'null playlists do not match');
-    assert.false(Playlist.playlistMatch({}, null), 'a playlist without b');
-    assert.false(Playlist.playlistMatch(null, {}), 'b playlist without a');
+      const a = {id: 'foo', uri: 'foo.m3u8', resolvedUri: 'http://example.com/foo.m3u8'};
+      const b = {id: 'foo', uri: 'foo.m3u8', resolvedUri: 'http://example.com/foo.m3u8'};
 
-    const a = {id: 'foo', uri: 'foo.m3u8', resolvedUri: 'http://example.com/foo.m3u8'};
-    const b = {id: 'foo', uri: 'foo.m3u8', resolvedUri: 'http://example.com/foo.m3u8'};
+      assert.true(Playlist.playlistMatch(a, a), 'object signature match');
 
-    assert.true(Playlist.playlistMatch(a, a), 'object signature match');
+      assert.true(Playlist.playlistMatch(a, b), 'id match');
 
-    assert.true(Playlist.playlistMatch(a, b), 'id match');
+      a.id = 'bar';
+      assert.true(Playlist.playlistMatch(a, b), 'resolved uri match');
 
-    a.id = 'bar';
-    assert.true(Playlist.playlistMatch(a, b), 'resolved uri match');
+      a.resolvedUri += '?nope';
+      assert.true(Playlist.playlistMatch(a, b), 'uri match');
 
-    a.resolvedUri += '?nope';
-    assert.true(Playlist.playlistMatch(a, b), 'uri match');
+      a.uri += '?nope';
 
-    a.uri += '?nope';
+      assert.false(Playlist.playlistMatch(a, b), 'no match');
+    });
 
-    assert.false(Playlist.playlistMatch(a, b), 'no match');
-  });
+    QUnit.test('isAudioOnly', function(assert) {
+      assert.false(Playlist.isAudioOnly({
+        playlists: [{attributes: {CODECS: 'mp4a.40.2,avc1.4d400d'}}]
+      }), 'muxed playlist');
 
-  QUnit.test('isAudioOnly', function(assert) {
-    assert.false(Playlist.isAudioOnly({
-      playlists: [{attributes: {CODECS: 'mp4a.40.2,avc1.4d400d'}}]
-    }), 'muxed playlist');
-
-    assert.false(Playlist.isAudioOnly({
-      playlists: [
-        {attributes: {CODECS: 'mp4a.40.2,avc1.4d400d'}},
-        {attributes: {CODECS: 'avc1.4d400d'}},
-        {attributes: {CODECS: 'mp4a.40.2'}}
-      ]
-    }), 'muxed, audio only, and video only');
-
-    assert.false(Playlist.isAudioOnly({
-      mediaGroups: {
-        AUDIO: {
-          main: {
-            en: {id: 'en', uri: 'en'},
-            es: {id: 'es', uri: 'es'}
+      assert.false(Playlist.isAudioOnly({
+        playlists: [
+          {attributes: {CODECS: 'mp4a.40.2,avc1.4d400d'}},
+          {attributes: {CODECS: 'avc1.4d400d'}},
+          {attributes: {CODECS: 'mp4a.40.2'}}
+        ]
+      }), 'muxed, audio only, and video only');
+
+      assert.false(Playlist.isAudioOnly({
+        mediaGroups: {
+          AUDIO: {
+            main: {
+              en: {id: 'en', uri: 'en'},
+              es: {id: 'es', uri: 'es'}
+            }
           }
-        }
-      },
-      playlists: [{attributes: {CODECS: 'mp4a.40.2,avc1.4d400d'}}]
-    }), 'muxed and alt audio');
-
-    assert.true(Playlist.isAudioOnly({
-      playlists: [
-        {attributes: {CODECS: 'mp4a.40.2'}},
-        {attributes: {CODECS: 'mp4a.40.2'}},
-        {attributes: {CODECS: 'mp4a.40.2'}}
-      ]
-    }), 'audio only playlists');
-
-    assert.true(Playlist.isAudioOnly({
-      mediaGroups: {
-        AUDIO: {
-          main: {
-            en: {id: 'en', uri: 'en'}
+        },
+        playlists: [{attributes: {CODECS: 'mp4a.40.2,avc1.4d400d'}}]
+      }), 'muxed and alt audio');
+
+      assert.true(Playlist.isAudioOnly({
+        playlists: [
+          {attributes: {CODECS: 'mp4a.40.2'}},
+          {attributes: {CODECS: 'mp4a.40.2'}},
+          {attributes: {CODECS: 'mp4a.40.2'}}
+        ]
+      }), 'audio only playlists');
+
+      assert.true(Playlist.isAudioOnly({
+        mediaGroups: {
+          AUDIO: {
+            main: {
+              en: {id: 'en', uri: 'en'}
+            }
           }
         }
-      }
-    }), 'only audio groups, uri');
-
-    assert.true(Playlist.isAudioOnly({
-      mediaGroups: {
-        AUDIO: {
-          main: {
-            en: {id: 'en', playlists: [{uri: 'foo'}]}
+      }), 'only audio groups, uri');
+
+      assert.true(Playlist.isAudioOnly({
+        mediaGroups: {
+          AUDIO: {
+            main: {
+              en: {id: 'en', playlists: [{uri: 'foo'}]}
+            }
           }
         }
-      }
-    }), 'only audio groups, playlists');
-
-    assert.true(Playlist.isAudioOnly({
-      playlists: [
-        {id: 'en'}
-      ],
-      mediaGroups: {
-        AUDIO: {
-          main: {
-            en: {id: 'en'}
+      }), 'only audio groups, playlists');
+
+      assert.true(Playlist.isAudioOnly({
+        playlists: [
+          {id: 'en'}
+        ],
+        mediaGroups: {
+          AUDIO: {
+            main: {
+              en: {id: 'en'}
+            }
           }
         }
-      }
-    }), 'audio playlists that are also in groups, without codecs');
+      }), 'audio playlists that are also in groups, without codecs');
 
+    });
   });
 });