diff --git a/contrib/akamai/controlbar/ControlBar.js b/contrib/akamai/controlbar/ControlBar.js
index b9c09c4b9d..08353979f9 100644
--- a/contrib/akamai/controlbar/ControlBar.js
+++ b/contrib/akamai/controlbar/ControlBar.js
@@ -27,7 +27,7 @@
  *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  *  POSSIBILITY OF SUCH DAMAGE.
- */
+ *
 
 /**
  * @module ControlBar
@@ -47,6 +47,7 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
     var seeking = false;
     var videoControllerVisibleTimeout = 0;
     var liveThresholdSecs = 12;
+    var textTrackList = {};
     var video,
         videoContainer,
         videoController,
@@ -66,7 +67,8 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         thumbnailElem,
         thumbnailTimeLabel,
         idSuffix,
-        startedPlaying;
+        startedPlaying,
+        seekbarBufferInterval;
 
     //************************************************************************************
     // THUMBNAIL CONSTANTS
@@ -102,21 +104,25 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         self.player.on(dashjs.MediaPlayer.events.PLAYBACK_STARTED, onPlayStart, this);
         self.player.on(dashjs.MediaPlayer.events.PLAYBACK_PAUSED, onPlaybackPaused, this);
         self.player.on(dashjs.MediaPlayer.events.PLAYBACK_TIME_UPDATED, onPlayTimeUpdate, this);
-        self.player.on(dashjs.MediaPlayer.events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-        self.player.on(dashjs.MediaPlayer.events.STREAM_INITIALIZED, onStreamInitialized, this);
+        self.player.on(dashjs.MediaPlayer.events.STREAM_ACTIVATED, onStreamActivated, this);
+        self.player.on(dashjs.MediaPlayer.events.STREAM_DEACTIVATED, onStreamDeactivated, this);
         self.player.on(dashjs.MediaPlayer.events.STREAM_TEARDOWN_COMPLETE, onStreamTeardownComplete, this);
         self.player.on(dashjs.MediaPlayer.events.SOURCE_INITIALIZED, onSourceInitialized, this);
-    }
+        self.player.on(dashjs.MediaPlayer.events.TEXT_TRACKS_ADDED, onTracksAdded, this);
+        self.player.on(dashjs.MediaPlayer.events.BUFFER_LEVEL_UPDATED, _onBufferLevelUpdated, this);
+    };
 
     var removePlayerEventsListeners = function () {
         self.player.off(dashjs.MediaPlayer.events.PLAYBACK_STARTED, onPlayStart, this);
         self.player.off(dashjs.MediaPlayer.events.PLAYBACK_PAUSED, onPlaybackPaused, this);
         self.player.off(dashjs.MediaPlayer.events.PLAYBACK_TIME_UPDATED, onPlayTimeUpdate, this);
-        self.player.off(dashjs.MediaPlayer.events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-        self.player.off(dashjs.MediaPlayer.events.STREAM_INITIALIZED, onStreamInitialized, this);
+        self.player.off(dashjs.MediaPlayer.events.STREAM_ACTIVATED, onStreamActivated, this);
+        self.player.off(dashjs.MediaPlayer.events.STREAM_DEACTIVATED, onStreamDeactivated, this);
         self.player.off(dashjs.MediaPlayer.events.STREAM_TEARDOWN_COMPLETE, onStreamTeardownComplete, this);
         self.player.off(dashjs.MediaPlayer.events.SOURCE_INITIALIZED, onSourceInitialized, this);
-    }
+        self.player.off(dashjs.MediaPlayer.events.TEXT_TRACKS_ADDED, onTracksAdded, this);
+        self.player.off(dashjs.MediaPlayer.events.BUFFER_LEVEL_UPDATED, _onBufferLevelUpdated, this);
+    };
 
     var getControlId = function (id) {
         return id + (idSuffix ? idSuffix : '');
@@ -171,25 +177,21 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         setTime(displayUTCTimeCodes ? self.player.timeAsUTC() : self.player.time());
         updateDuration();
         togglePlayPauseBtnState();
+        if (seekbarBufferInterval) {
+            clearInterval(seekbarBufferInterval);
+        }
     };
 
     var onPlayTimeUpdate = function (/*e*/) {
         updateDuration();
         if (!seeking) {
-            setTime(displayUTCTimeCodes ? self.player.timeAsUTC() : self.player.time());
+            setTime(displayUTCTimeCodes ? player.timeAsUTC() : player.time());
             if (seekbarPlay) {
-                if (self.player.isDynamic() && (self.player.duration() - self.player.time() < liveThresholdSecs)) {
-                    seekbarPlay.style.width = '100%';
-                } else {
-                    seekbarPlay.style.width = (self.player.time() / self.player.duration() * 100) + '%';
-                }
-            }
-            if (seekbarBuffer) {
-                seekbarBuffer.style.width = ((self.player.time() + getBufferLevel()) / self.player.duration() * 100) + '%';
+                seekbarPlay.style.width = (player.time() / player.duration() * 100) + '%';
             }
 
             if (seekbar.getAttribute('type') === 'range') {
-                seekbar.value = self.player.time();
+                seekbar.value = player.time();
             }
 
         }
@@ -353,19 +355,6 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         thumbnailContainer.style.display = 'none';
     };
 
-    var getScrollOffset = function () {
-        if (window.pageXOffset) {
-            return {
-                x: window.pageXOffset,
-                y: window.pageYOffset
-            };
-        }
-        return {
-            x: document.documentElement.scrollLeft,
-            y: document.documentElement.scrollTop
-        };
-    };
-
     var seekLive = function () {
         self.player.seek(self.player.duration());
     };
@@ -471,7 +460,7 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         if (document.fullscreenElement) {
             document.exitFullscreen();
         } else if (document.exitFullscreen) {
-           document.exitFullscreen();
+            document.exitFullscreen();
         } else if (document.mozCancelFullScreen) {
             document.mozCancelFullScreen();
         } else if (document.msExitFullscreen) {
@@ -503,48 +492,42 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
     // Audio Video MENU
     //************************************************************************************
 
-    var onTracksAdded = function (e) {
-        // Subtitles/Captions Menu //XXX we need to add two layers for captions & subtitles if present.
-        if (!captionMenu) {
-            var contentFunc = function (element, index) {
-                if (isNaN(index)) {
-                    return 'OFF';
-                }
-
-                var label = getLabelForLocale(element.labels);
-                if (label) {
-                    return label + ' : ' + element.kind;
-                }
-
-                return element.lang + ' : ' + element.kind;
-            };
-            captionMenu = createMenu({ menuType: 'caption', arr: e.tracks }, contentFunc);
+    var onSourceInitialized = function () {
+        startedPlaying = false;
+    };
 
-            var func = function () {
-                onMenuClick(captionMenu, captionBtn);
-            }
-            menuHandlersList.push(func);
-            captionBtn.addEventListener('click', func);
-            captionBtn.classList.remove('hide');
-        } else if (e.index !== undefined) {
-            setMenuItemsState(e.index + 1, 'caption-list');
+    var onStreamDeactivated = function (e) {
+        if (e.streamInfo && textTrackList[e.streamInfo.id]) {
+            delete textTrackList[e.streamInfo.id];
         }
     };
 
-    var onSourceInitialized = function () {
-        startedPlaying = false;
-    };
+    var onStreamActivated = function (e) {
+        var streamInfo = e.streamInfo;
 
-    var onStreamInitialized = function (/*e*/) {
         updateDuration();
-        var contentFunc;
+
         //Bitrate Menu
+        createBitrateSwitchMenu();
+
+        //Track Switch Menu
+        createTrackSwitchMenu();
+
+        //Text Switch Menu
+        createCaptionSwitchMenu(streamInfo);
+    };
+
+    var createBitrateSwitchMenu = function () {
+        var contentFunc;
+
         if (bitrateListBtn) {
-            destroyBitrateMenu();
+            destroyMenu(bitrateListMenu, bitrateListBtn);
+            bitrateListMenu = null;
             var availableBitrates = { menuType: 'bitrate' };
             availableBitrates.audio = self.player.getBitrateInfoListFor && self.player.getBitrateInfoListFor('audio') || [];
             availableBitrates.video = self.player.getBitrateInfoListFor && self.player.getBitrateInfoListFor('video') || [];
             availableBitrates.images = self.player.getBitrateInfoListFor && self.player.getBitrateInfoListFor('image') || [];
+
             if (availableBitrates.audio.length > 1 || availableBitrates.video.length > 1 || availableBitrates.images.length > 1) {
                 contentFunc = function (element, index) {
                     var result = isNaN(index) ? ' Auto Switch' : Math.floor(element.bitrate / 1000) + ' kbps';
@@ -564,8 +547,16 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
                 bitrateListBtn.classList.add('hide');
             }
         }
-        //Track Switch Menu
-        if (!trackSwitchMenu && trackSwitchBtn) {
+    };
+
+    var createTrackSwitchMenu = function () {
+        var contentFunc;
+
+        if (trackSwitchBtn) {
+
+            destroyMenu(trackSwitchMenu, trackSwitchBtn);
+            trackSwitchMenu = null;
+
             var availableTracks = { menuType: 'track' };
             availableTracks.audio = self.player.getTracksFor('audio');
             availableTracks.video = self.player.getTracksFor('video'); // these return empty arrays so no need to check for null
@@ -585,6 +576,57 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         }
     };
 
+    var createCaptionSwitchMenu = function (streamId) {
+        // Subtitles/Captions Menu //XXX we need to add two layers for captions & subtitles if present.
+        var activeStreamInfo = player.getActiveStream().getStreamInfo();
+
+        if (captionBtn && (!activeStreamInfo.id || activeStreamInfo.id === streamId)) {
+
+            destroyMenu(captionMenu, captionBtn);
+            captionMenu = null;
+
+            var tracks = textTrackList[streamId] || [];
+            var contentFunc = function (element, index) {
+                if (isNaN(index)) {
+                    return 'OFF';
+                }
+
+                var label = getLabelForLocale(element.labels);
+                if (label) {
+                    return label + ' : ' + element.type;
+                }
+
+                return element.lang + ' : ' + element.kind;
+            };
+            captionMenu = createMenu({ menuType: 'caption', arr: tracks }, contentFunc);
+
+            var func = function () {
+                onMenuClick(captionMenu, captionBtn);
+            };
+
+            menuHandlersList.push(func);
+            captionBtn.addEventListener('click', func);
+            captionBtn.classList.remove('hide');
+        }
+
+    };
+
+    var onTracksAdded = function (e) {
+        // Subtitles/Captions Menu //XXX we need to add two layers for captions & subtitles if present.
+        if (!textTrackList[e.streamId]) {
+            textTrackList[e.streamId] = [];
+        }
+
+        textTrackList[e.streamId] = textTrackList[e.streamId].concat(e.tracks);
+        createCaptionSwitchMenu(e.streamId);
+    };
+
+    var _onBufferLevelUpdated = function () {
+        if (seekbarBuffer) {
+            seekbarBuffer.style.width = ((player.time() + getBufferLevel()) / player.duration() * 100) + '%';
+        }
+    };
+
     var onStreamTeardownComplete = function (/*e*/) {
         setPlayBtn();
         timeDisplay.textContent = '00:00';
@@ -761,52 +803,57 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
     };
 
     var setMenuItemsState = function (value, type) {
-        var item = typeof value === 'number' ? document.getElementById(type + 'Item_' + value) : this;
-        var nodes = item.parentElement.children;
-
-        for (var i = 0; i < nodes.length; i++) {
-            nodes[i].selected = false;
-            nodes[i].classList.remove('menu-item-selected');
-            nodes[i].classList.add('menu-item-unselected');
-        }
-        item.selected = true;
-        item.classList.remove('menu-item-over');
-        item.classList.remove('menu-item-unselected');
-        item.classList.add('menu-item-selected');
-
-        if (type === undefined) { // User clicked so type is part of item binding.
-            switch (item.name) {
-                case 'video-bitrate-list':
-                case 'audio-bitrate-list':
-                    var cfg = {
-                        'streaming': {
-                            'abr': {
-                                'autoSwitchBitrate': {
+        try {
+            var item = typeof value === 'number' ? document.getElementById(type + 'Item_' + value) : this;
+            if (item) {
+                var nodes = item.parentElement.children;
+
+                for (var i = 0; i < nodes.length; i++) {
+                    nodes[i].selected = false;
+                    nodes[i].classList.remove('menu-item-selected');
+                    nodes[i].classList.add('menu-item-unselected');
+                }
+                item.selected = true;
+                item.classList.remove('menu-item-over');
+                item.classList.remove('menu-item-unselected');
+                item.classList.add('menu-item-selected');
+
+                if (type === undefined) { // User clicked so type is part of item binding.
+                    switch (item.name) {
+                        case 'video-bitrate-list':
+                        case 'audio-bitrate-list':
+                            var cfg = {
+                                'streaming': {
+                                    'abr': {
+                                        'autoSwitchBitrate': {}
+                                    }
                                 }
+                            };
+
+                            if (item.index > 0) {
+                                cfg.streaming.abr.autoSwitchBitrate[item.mediaType] = false;
+                                self.player.updateSettings(cfg);
+                                self.player.setQualityFor(item.mediaType, item.index - 1);
+                            } else {
+                                cfg.streaming.abr.autoSwitchBitrate[item.mediaType] = true;
+                                self.player.updateSettings(cfg);
                             }
-                        }
-                    };
-
-                    if (item.index > 0) {
-                        cfg.streaming.abr.autoSwitchBitrate[item.mediaType] = false;
-                        self.player.updateSettings(cfg);
-                        self.player.setQualityFor(item.mediaType, item.index - 1);
-                    } else {
-                        cfg.streaming.abr.autoSwitchBitrate[item.mediaType] = true;
-                        self.player.updateSettings(cfg);
+                            break;
+                        case 'image-bitrate-list':
+                            player.setQualityFor(self.mediaType, self.index);
+                            break;
+                        case 'caption-list':
+                            self.player.setTextTrack(item.index - 1);
+                            break;
+                        case 'video-track-list':
+                        case 'audio-track-list':
+                            self.player.setCurrentTrack(self.player.getTracksFor(item.mediaType)[item.index]);
+                            break;
                     }
-                    break;
-                case 'image-bitrate-list':
-                    player.setQualityFor(self.mediaType, self.index);
-                    break;
-                case 'caption-list':
-                    self.player.setTextTrack(item.index - 1);
-                    break;
-                case 'video-track-list':
-                case 'audio-track-list':
-                    self.player.setCurrentTrack(self.player.getTracksFor(item.mediaType)[item.index]);
-                    break;
+                }
             }
+        } catch (e) {
+            console.error(e);
         }
     };
 
@@ -833,13 +880,26 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         menu.style.top = menu_y + 'px';
     };
 
-    var destroyBitrateMenu = function () {
-        if (bitrateListMenu) {
-            menuHandlersList.forEach(function (item) {
-                bitrateListBtn.removeEventListener('click', item);
-            });
-            videoController.removeChild(bitrateListMenu);
-            bitrateListMenu = null;
+    var destroyMenu = function (menu, btn) {
+        try {
+            if (menu && videoController) {
+                menuHandlersList.forEach(function (item) {
+                    btn.removeEventListener('click', item);
+                });
+                videoController.removeChild(menu);
+            }
+        } catch (e) {
+        }
+    };
+
+    var removeMenu = function (menu, btn) {
+        try {
+            if (menu) {
+                videoController.removeChild(menu);
+                menu = null;
+                btn.classList.add('hide');
+            }
+        } catch (e) {
         }
     };
 
@@ -875,7 +935,6 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         return !!navigator.userAgent.match(/Trident.*rv[ :]*11\./);
     };
 
-
     //************************************************************************************
     // PUBLIC API
     //************************************************************************************
@@ -885,6 +944,7 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
         setDuration: setDuration,
         setTime: setTime,
         setPlayer: setPlayer,
+        removeMenu: removeMenu,
 
         initialize: function (suffix) {
 
@@ -945,23 +1005,25 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
             videoController.classList.remove('disable');
         },
 
-        reset: function () {
-            window.removeEventListener('resize', handleMenuPositionOnResize);
-            destroyBitrateMenu();
+        resetSelectionMenus: function () {
+            destroyMenu();
             menuHandlersList.forEach(function (item) {
                 if (trackSwitchBtn) trackSwitchBtn.removeEventListener('click', item);
                 if (captionBtn) captionBtn.removeEventListener('click', item);
             });
             if (captionMenu) {
-                videoController.removeChild(captionMenu);
-                captionMenu = null;
-                captionBtn.classList.add('hide');
+                this.removeMenu(captionMenu, captionBtn);
             }
             if (trackSwitchMenu) {
-                videoController.removeChild(trackSwitchMenu);
-                trackSwitchMenu = null;
-                trackSwitchBtn.classList.add('hide');
+                this.removeMenu(trackSwitchMenu, trackSwitchBtn);
             }
+        },
+
+        reset: function () {
+            window.removeEventListener('resize', handleMenuPositionOnResize);
+
+            this.resetSelectionMenus();
+
             menuHandlersList = [];
             seeking = false;
 
diff --git a/index.d.ts b/index.d.ts
index e8242e648e..19eff9c216 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -4,9 +4,13 @@ export as namespace dashjs;
 declare namespace dashjs {
     interface Logger {
         debug(...params: any[]): void;
+
         info(...params: any[]): void;
+
         warn(...params: any[]): void;
+
         error(...params: any[]): void;
+
         fatal(...params: any[]): void;
     }
 
@@ -21,7 +25,9 @@ declare namespace dashjs {
 
     interface Debug {
         getLogger(): Logger;
+
         setLogTimestampVisible(flag: boolean): void;
+
         setCalleeNameVisible(flag: boolean): void;
     }
 
@@ -31,22 +37,36 @@ declare namespace dashjs {
         data: unknown | null;
     }
 
-    interface VideoModel { }
+    interface VideoModel {
+    }
 
     interface ProtectionController {
         initializeForMedia(mediaInfo: ProtectionMediaInfo): void;
+
         createKeySession(initData: ArrayBuffer, cdmData: Uint8Array): void;
+
         removeKeySession(session: SessionToken): void;
+
         closeKeySession(session: SessionToken): void;
+
         setServerCertificate(serverCertificate: ArrayBuffer): void;
+
         setMediaElement(element: HTMLMediaElement): void;
+
         setSessionType(type: string): void;
+
         setRobustnessLevel(level: string): void;
+
         setProtectionData(protDataSet: ProtectionDataSet): void;
+
         getSupportedKeySystemsFromContentProtection(cps: any[]): SupportedKeySystem[];
+
         getKeySystems(): KeySystem[];
+
         setKeySystems(keySystems: KeySystem[]): void;
+
         stop(): void;
+
         reset(): void;
     }
 
@@ -60,14 +80,23 @@ declare namespace dashjs {
 
     interface OfflineController {
         loadRecordsFromStorage(): Promise<void>;
+
         getAllRecords(): OfflineRecord[];
+
         createRecord(manifestURL: string): Promise<string>;
+
         startRecord(id: string, mediaInfos: MediaInfo[]): void;
+
         stopRecord(id: string): void;
+
         resumeRecord(id: string): void;
+
         deleteRecord(id: string): void;
+
         getRecordProgression(id: string): number;
+
         resetRecords(): void;
+
         reset(): void;
     }
 
@@ -112,34 +141,43 @@ declare namespace dashjs {
             dispatchEvent?: boolean;
         };
         streaming?: {
-            metricsMaxListDepth?: number;
-            abandonLoadTimeout?: number;
-            liveDelayFragmentCount?: number;
-            liveDelay?: number;
-            scheduleWhilePaused?: boolean;
-            fastSwitchEnabled?: boolean;
-            flushBufferAtTrackSwitch?: boolean;
-            reuseExistingSourceBuffers?: boolean;
+            metricsMaxListDepth?: number,
+            abandonLoadTimeout?: number,
             calcSegmentAvailabilityRangeFromTimeline?: boolean,
-            bufferPruningInterval?: number;
-            bufferToKeep?: number;
-            jumpGaps?: boolean;
-            jumpLargeGaps?: boolean;
-            smallGapLimit?: number;
-            stableBufferTime?: number;
-            bufferTimeAtTopQuality?: number;
-            bufferTimeAtTopQualityLongForm?: number;
-            longFormContentDurationThreshold?: number;
-            wallclockTimeUpdateInterval?: number;
-            lowLatencyEnabled?: boolean;
-            keepProtectionMediaKeys?: boolean;
-            useManifestDateHeaderTimeSource?: boolean;
-            useSuggestedPresentationDelay?: boolean;
-            useAppendWindow?: boolean,
-            manifestUpdateRetryInterval?: number;
-            stallThreshold?: number;
-            filterUnsupportedEssentialProperties?: boolean;
-            eventControllerRefreshDelay?: number;
+            wallclockTimeUpdateInterval?: number,
+            lowLatencyEnabled?: boolean,
+            useManifestDateHeaderTimeSource?: boolean,
+            manifestUpdateRetryInterval?: number,
+            filterUnsupportedEssentialProperties?: boolean,
+            cacheInitSegments?: boolean,
+            eventControllerRefreshDelay?: number,
+            delay?: {
+                liveDelayFragmentCount?: number,
+                liveDelay?: number,
+                useSuggestedPresentationDelay?: boolean
+            },
+            buffer?: {
+                fastSwitchEnabled?: boolean,
+                flushBufferAtTrackSwitch?: boolean,
+                reuseExistingSourceBuffers?: boolean,
+                bufferPruningInterval?: number,
+                bufferToKeep?: number,
+                bufferTimeAtTopQuality?: number,
+                bufferTimeAtTopQualityLongForm?: number,
+                initialBufferLevel?: number,
+                stableBufferTime?: number,
+                longFormContentDurationThreshold?: number,
+                stallThreshold?: number,
+                useAppendWindow?: boolean,
+            },
+            protection?: {
+                keepProtectionMediaKeys?: boolean,
+            }
+            gaps?: {
+                jumpGaps?: boolean,
+                jumpLargeGaps?: boolean,
+                smallGapLimit?: number,
+            },
             utcSynchronization?: {
                 backgroundAttempts?: number,
                 timeBetweenSyncAttempts?: number,
@@ -153,6 +191,14 @@ declare namespace dashjs {
                     value?: string
                 }
             },
+            scheduling?: {
+                defaultTimeout?: number,
+                lowLatencyTimeout?: number,
+                scheduleWhilePaused?: boolean
+            },
+            text?: {
+                defaultEnabled?: boolean
+            },
             liveCatchup?: {
                 minDrift?: number;
                 maxDrift?: number;
@@ -181,26 +227,26 @@ declare namespace dashjs {
             selectionModeForInitialTrack?: TrackSelectionMode
             fragmentRequestTimeout?: number;
             retryIntervals?: {
-                'MPD'?:                       number;
-                'XLinkExpansion'?:            number;
-                'MediaSegment'?:              number;
-                'InitializationSegment'?:     number;
+                'MPD'?: number;
+                'XLinkExpansion'?: number;
+                'MediaSegment'?: number;
+                'InitializationSegment'?: number;
                 'BitstreamSwitchingSegment'?: number;
-                'IndexSegment'?:              number;
-                'FragmentInfoSegment'?:       number;
-                'other'?:                     number;
-                'lowLatencyReductionFactor'?:  number;
+                'IndexSegment'?: number;
+                'FragmentInfoSegment'?: number;
+                'other'?: number;
+                'lowLatencyReductionFactor'?: number;
             };
             retryAttempts?: {
-                'MPD'?:                       number;
-                'XLinkExpansion'?:            number;
-                'MediaSegment'?:              number;
-                'InitializationSegment'?:     number;
+                'MPD'?: number;
+                'XLinkExpansion'?: number;
+                'MediaSegment'?: number;
+                'InitializationSegment'?: number;
                 'BitstreamSwitchingSegment'?: number;
-                'IndexSegment'?:              number;
-                'FragmentInfoSegment'?:       number;
-                'other'?:                     number;
-                'lowLatencyMultiplyFactor'?:  number;
+                'IndexSegment'?: number;
+                'FragmentInfoSegment'?: number;
+                'other'?: number;
+                'lowLatencyMultiplyFactor'?: number;
             };
             abr?: {
                 movingAverageMethod?: 'slidingWindow' | 'ewma';
@@ -263,137 +309,261 @@ declare namespace dashjs {
 
     export interface MediaPlayerClass {
         initialize(view?: HTMLElement, source?: string, autoPlay?: boolean): void;
+
         on(type: AstInFutureEvent['type'], listener: (e: AstInFutureEvent) => void, scope?: object): void;
+
         on(type: BufferEvent['type'], listener: (e: BufferEvent) => void, scope?: object): void;
+
         on(type: CaptionRenderedEvent['type'], listener: (e: CaptionRenderedEvent) => void, scope?: object): void;
+
         on(type: CaptionContainerResizeEvent['type'], listener: (e: CaptionContainerResizeEvent) => void, scope?: object): void;
+
         on(type: DynamicToStaticEvent['type'], listener: (e: DynamicToStaticEvent) => void, scope?: object): void;
+
         on(type: ErrorEvent['type'], listener: (e: ErrorEvent) => void, scope?: object): void;
+
         on(type: FragmentLoadingCompletedEvent['type'], listener: (e: FragmentLoadingCompletedEvent) => void, scope?: object): void;
+
         on(type: FragmentLoadingAbandonedEvent['type'], listener: (e: FragmentLoadingAbandonedEvent) => void, scope?: object): void;
+
         on(type: KeyErrorEvent['type'], listener: (e: KeyErrorEvent) => void, scope?: object): void;
+
         on(type: KeyMessageEvent['type'], listener: (e: KeyMessageEvent) => void, scope?: object): void;
+
         on(type: KeySessionClosedEvent['type'], listener: (e: KeySessionClosedEvent) => void, scope?: object): void;
+
         on(type: KeySessionEvent['type'], listener: (e: KeySessionEvent) => void, scope?: object): void;
+
         on(type: KeyStatusesChangedEvent['type'], listener: (e: KeyStatusesChangedEvent) => void, scope?: object): void;
+
         on(type: KeySystemSelectedEvent['type'], listener: (e: KeySystemSelectedEvent) => void, scope?: object): void;
+
         on(type: LicenseRequestCompleteEvent['type'], listener: (e: LicenseRequestCompleteEvent) => void, scope?: object): void;
+
         on(type: LogEvent['type'], listener: (e: LogEvent) => void, scope?: object): void;
+
         on(type: ManifestLoadedEvent['type'], listener: (e: ManifestLoadedEvent) => void, scope?: object): void;
+
         on(type: MetricEvent['type'], listener: (e: MetricEvent) => void, scope?: object): void;
+
         on(type: MetricChangedEvent['type'], listener: (e: MetricChangedEvent) => void, scope?: object): void;
+
         on(type: OfflineRecordEvent['type'], listener: (e: OfflineRecordEvent) => void, scope?: object): void;
+
         on(type: OfflineRecordLoademetadataEvent['type'], listener: (e: OfflineRecordLoademetadataEvent) => void, scope?: object): void;
+
         on(type: PeriodSwitchEvent['type'], listener: (e: PeriodSwitchEvent) => void, scope?: object): void;
+
         on(type: PlaybackErrorEvent['type'], listener: (e: PlaybackErrorEvent) => void, scope?: object): void;
+
         on(type: PlaybackPausedEvent['type'], listener: (e: PlaybackPausedEvent) => void, scope?: object): void;
+
         on(type: PlaybackPlayingEvent['type'], listener: (e: PlaybackPlayingEvent) => void, scope?: object): void;
+
         on(type: PlaybackRateChangedEvent['type'], listener: (e: PlaybackRateChangedEvent) => void, scope?: object): void;
+
         on(type: PlaybackSeekingEvent['type'], listener: (e: PlaybackSeekingEvent) => void, scope?: object): void;
+
         on(type: PlaybackStartedEvent['type'], listener: (e: PlaybackStartedEvent) => void, scope?: object): void;
+
         on(type: PlaybackTimeUpdatedEvent['type'], listener: (e: PlaybackTimeUpdatedEvent) => void, scope?: object): void;
+
         on(type: ProtectionCreatedEvent['type'], listener: (e: ProtectionCreatedEvent) => void, scope?: object): void;
+
         on(type: ProtectionDestroyedEvent['type'], listener: (e: ProtectionDestroyedEvent) => void, scope?: object): void;
+
         on(type: QualityChangeRenderedEvent['type'], listener: (e: QualityChangeRenderedEvent) => void, scope?: object): void;
+
         on(type: QualityChangeRequestedEvent['type'], listener: (e: QualityChangeRequestedEvent) => void, scope?: object): void;
+
         on(type: StreamInitializedEvent['type'], listener: (e: StreamInitializedEvent) => void, scope?: object): void;
+
         on(type: TextTracksAddedEvent['type'], listener: (e: TextTracksAddedEvent) => void, scope?: object): void;
+
         on(type: TtmlParsedEvent['type'], listener: (e: TtmlParsedEvent) => void, scope?: object): void;
+
         on(type: TtmlToParseEvent['type'], listener: (e: TtmlToParseEvent) => void, scope?: object): void;
+
         on(type: string, listener: (e: Event) => void, scope?: object): void;
+
         off(type: string, listener: (e: any) => void, scope?: object): void;
+
         extend(parentNameString: string, childInstance: object, override: boolean): void;
+
         attachView(element: HTMLElement): void;
+
         attachSource(urlOrManifest: string | object): void;
+
         isReady(): boolean;
+
         play(): void;
+
         isPaused(): boolean;
+
         pause(): void;
+
         isSeeking(): boolean;
+
         isDynamic(): boolean;
+
         seek(value: number): void;
-        setPlaybackRate(value:number): void;
+
+        setPlaybackRate(value: number): void;
+
         getPlaybackRate(): number;
+
         setMute(value: boolean): void;
+
         isMuted(): boolean;
+
         setVolume(value: number): void;
+
         getVolume(): number;
+
         time(streamId?: string): number;
+
         duration(): number;
+
         timeAsUTC(): number;
+
         durationAsUTC(): number;
+
         getActiveStream(): Stream | null;
+
         getDVRWindowSize(): number;
+
         getDVRSeekOffset(value: number): number;
+
         convertToTimeCode(value: number): string;
+
         formatUTC(time: number, locales: string, hour12: boolean, withDate?: boolean): string;
+
         getVersion(): string;
+
         getDebug(): Debug;
+
         getBufferLength(type: MediaType): number;
+
         getVideoModel(): VideoModel;
+
         getTTMLRenderingDiv(): HTMLDivElement | null;
+
         getVideoElement(): HTMLVideoElement;
+
         getSource(): string | object;
+
         getTopBitrateInfoFor(type: MediaType): BitrateInfo;
+
         setAutoPlay(value: boolean): void;
+
         getAutoPlay(): boolean;
+
         getDashMetrics(): DashMetrics;
+
         getDashAdapter(): DashAdapter;
+
         getQualityFor(type: MediaType): number;
+
         setQualityFor(type: MediaType, value: number): void;
+
         updatePortalSize(): void;
+
         enableText(enable: boolean): void;
+
         setTextTrack(idx: number): void;
+
         getTextDefaultLanguage(): string | undefined;
+
         setTextDefaultLanguage(lang: string): void;
+
         getTextDefaultEnabled(): boolean | undefined;
+
         setTextDefaultEnabled(enable: boolean): void;
+
         provideThumbnail(time: number, callback: (thumbnail: Thumbnail | null) => void): void;
+
         getBitrateInfoListFor(type: MediaType): BitrateInfo[];
+
         getStreamsFromManifest(manifest: object): StreamInfo[];
+
         getTracksFor(type: MediaType): MediaInfo[];
+
         getTracksForTypeFromManifest(type: MediaType, manifest: object, streamInfo: StreamInfo): MediaInfo[];
+
         getCurrentTrackFor(type: MediaType): MediaInfo | null;
+
         setInitialMediaSettingsFor(type: MediaType, value: MediaSettings): void;
+
         getInitialMediaSettingsFor(type: MediaType): MediaSettings;
+
         setCurrentTrack(track: MediaInfo): void;
-        getTrackSwitchModeFor(type: MediaType): TrackSwitchMode;
-        setTrackSwitchModeFor(type: MediaType, mode: TrackSwitchMode): void;
-        setSelectionModeForInitialTrack(mode: TrackSelectionMode): void;
-        getSelectionModeForInitialTrack(): TrackSelectionMode;
+
         retrieveManifest(url: string, callback: (manifest: object | null, error: any) => void): void;
+
         addUTCTimingSource(schemeIdUri: string, value: string): void;
+
         removeUTCTimingSource(schemeIdUri: string, value: string): void;
+
         clearDefaultUTCTimingSources(): void;
+
         restoreDefaultUTCTimingSources(): void;
+
         setXHRWithCredentialsForType(type: string, value: boolean): void;
+
         getXHRWithCredentialsForType(type: string): boolean;
+
         getProtectionController(): ProtectionController;
+
         attachProtectionController(value: ProtectionController): void;
+
         setProtectionData(value: ProtectionDataSet): void;
+
         registerLicenseRequestFilter(filter: RequestFilter): void,
+
         registerLicenseResponseFilter(filter: ResponseFilter): void,
+
         unregisterLicenseRequestFilter(filter: RequestFilter): void,
+
         unregisterLicenseResponseFilter(filter: ResponseFilter): void,
+
         registerCustomCapabilitiesFilter(filter: CapabilitiesFilter): void,
+
         unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilter): void,
+
         getOfflineController(): OfflineController;
+
         enableManifestDateHeaderTimeSource(value: boolean): void;
+
         displayCaptionsOnTop(value: boolean): void;
+
         attachTTMLRenderingDiv(div: HTMLDivElement): void;
+
         getCurrentTextTrackIndex(): number;
+
         preload(): void;
+
         reset(): void;
+
         destroy(): void;
+
         addABRCustomRule(type: string, rulename: string, rule: object): void;
+
         removeABRCustomRule(rulename: string): void;
+
         removeAllABRCustomRule(): void;
+
         getCurrentLiveLatency(): number;
+
         enableForcedTextStreaming(value: boolean): void;
+
         isTextEnabled(): boolean;
+
         getAverageThroughput(value: number): void;
+
         getSettings(): MediaPlayerSettingClass;
+
         updateSettings(settings: MediaPlayerSettingClass): void;
+
         resetSettings(): void;
     }
 
@@ -409,63 +579,63 @@ declare namespace dashjs {
     }
 
     interface MediaPlayerErrors {
-        MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE:          10;
-        MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE:          11;
-        XLINK_LOADER_LOADING_FAILURE_ERROR_CODE:             12;
-        SEGMENTS_UPDATE_FAILED_ERROR_CODE:                   13;
-        SEGMENTS_UNAVAILABLE_ERROR_CODE:                     14;
-        SEGMENT_BASE_LOADER_ERROR_CODE:                      15;
-        TIME_SYNC_FAILED_ERROR_CODE:                         16;
-        FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE:          17;
-        FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE:             18;
-        URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE:            19;
-        APPEND_ERROR_CODE:                                   20;
-        REMOVE_ERROR_CODE:                                   21;
-        DATA_UPDATE_FAILED_ERROR_CODE:                       22;
-        CAPABILITY_MEDIASOURCE_ERROR_CODE:                   23;
-        CAPABILITY_MEDIAKEYS_ERROR_CODE:                     24;
-        DOWNLOAD_ERROR_ID_MANIFEST_CODE:                     25;
-        DOWNLOAD_ERROR_ID_CONTENT_CODE:                      27;
-        DOWNLOAD_ERROR_ID_INITIALIZATION_CODE:               28;
-        DOWNLOAD_ERROR_ID_XLINK_CODE:                        29;
-        MANIFEST_ERROR_ID_PARSE_CODE:                        31;
-        MANIFEST_ERROR_ID_NOSTREAMS_CODE:                    32;
-        TIMED_TEXT_ERROR_ID_PARSE_CODE:                      33;
-        MANIFEST_ERROR_ID_MULTIPLEXED_CODE:                  34;
-        MEDIASOURCE_TYPE_UNSUPPORTED_CODE:                   35;
-        MEDIA_KEYERR_CODE:                                  100;
-        MEDIA_KEYERR_UNKNOWN_CODE:                          101;
-        MEDIA_KEYERR_CLIENT_CODE:                           102;
-        MEDIA_KEYERR_SERVICE_CODE:                          103;
-        MEDIA_KEYERR_OUTPUT_CODE:                           104;
-        MEDIA_KEYERR_HARDWARECHANGE_CODE:                   105;
-        MEDIA_KEYERR_DOMAIN_CODE:                           106;
-        MEDIA_KEY_MESSAGE_ERROR_CODE:                       107;
-        MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE:          108;
-        SERVER_CERTIFICATE_UPDATED_ERROR_CODE:              109;
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE:              110;
+        MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE: 10;
+        MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE: 11;
+        XLINK_LOADER_LOADING_FAILURE_ERROR_CODE: 12;
+        SEGMENTS_UPDATE_FAILED_ERROR_CODE: 13;
+        SEGMENTS_UNAVAILABLE_ERROR_CODE: 14;
+        SEGMENT_BASE_LOADER_ERROR_CODE: 15;
+        TIME_SYNC_FAILED_ERROR_CODE: 16;
+        FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE: 17;
+        FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE: 18;
+        URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE: 19;
+        APPEND_ERROR_CODE: 20;
+        REMOVE_ERROR_CODE: 21;
+        DATA_UPDATE_FAILED_ERROR_CODE: 22;
+        CAPABILITY_MEDIASOURCE_ERROR_CODE: 23;
+        CAPABILITY_MEDIAKEYS_ERROR_CODE: 24;
+        DOWNLOAD_ERROR_ID_MANIFEST_CODE: 25;
+        DOWNLOAD_ERROR_ID_CONTENT_CODE: 27;
+        DOWNLOAD_ERROR_ID_INITIALIZATION_CODE: 28;
+        DOWNLOAD_ERROR_ID_XLINK_CODE: 29;
+        MANIFEST_ERROR_ID_PARSE_CODE: 31;
+        MANIFEST_ERROR_ID_NOSTREAMS_CODE: 32;
+        TIMED_TEXT_ERROR_ID_PARSE_CODE: 33;
+        MANIFEST_ERROR_ID_MULTIPLEXED_CODE: 34;
+        MEDIASOURCE_TYPE_UNSUPPORTED_CODE: 35;
+        MEDIA_KEYERR_CODE: 100;
+        MEDIA_KEYERR_UNKNOWN_CODE: 101;
+        MEDIA_KEYERR_CLIENT_CODE: 102;
+        MEDIA_KEYERR_SERVICE_CODE: 103;
+        MEDIA_KEYERR_OUTPUT_CODE: 104;
+        MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
+        MEDIA_KEYERR_DOMAIN_CODE: 106;
+        MEDIA_KEY_MESSAGE_ERROR_CODE: 107;
+        MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE: 108;
+        SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
+        KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
         MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE:                112;
-        KEY_SESSION_CREATED_ERROR_CODE:                     113;
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE:              114;
+        KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
+        KEY_SESSION_CREATED_ERROR_CODE: 113;
+        MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
         // MSS errors
-        MSS_NO_TFRF_CODE:                                   200;
-        MSS_UNSUPPORTED_CODEC_CODE:                         201;
+        MSS_NO_TFRF_CODE: 200;
+        MSS_UNSUPPORTED_CODEC_CODE: 201;
         // Offline errors
-        OFFLINE_ERROR:                                      11000;
-        INDEXEDDB_QUOTA_EXCEED_ERROR:                       11001;
-        INDEXEDDB_INVALID_STATE_ERROR:                      11002;
-        INDEXEDDB_NOT_READABLE_ERROR:                       11003;
-        INDEXEDDB_NOT_FOUND_ERROR:                          11004;
-        INDEXEDDB_NETWORK_ERROR:                            11005;
-        INDEXEDDB_DATA_ERROR:                               11006;
-        INDEXEDDB_TRANSACTION_INACTIVE_ERROR:               11007;
-        INDEXEDDB_NOT_ALLOWED_ERROR:                        11008;
-        INDEXEDDB_NOT_SUPPORTED_ERROR:                      11009;
-        INDEXEDDB_VERSION_ERROR:                            11010;
-        INDEXEDDB_TIMEOUT_ERROR:                            11011;
-        INDEXEDDB_ABORT_ERROR:                              11012;
-        INDEXEDDB_UNKNOWN_ERROR:                            11013;
+        OFFLINE_ERROR: 11000;
+        INDEXEDDB_QUOTA_EXCEED_ERROR: 11001;
+        INDEXEDDB_INVALID_STATE_ERROR: 11002;
+        INDEXEDDB_NOT_READABLE_ERROR: 11003;
+        INDEXEDDB_NOT_FOUND_ERROR: 11004;
+        INDEXEDDB_NETWORK_ERROR: 11005;
+        INDEXEDDB_DATA_ERROR: 11006;
+        INDEXEDDB_TRANSACTION_INACTIVE_ERROR: 11007;
+        INDEXEDDB_NOT_ALLOWED_ERROR: 11008;
+        INDEXEDDB_NOT_SUPPORTED_ERROR: 11009;
+        INDEXEDDB_VERSION_ERROR: 11010;
+        INDEXEDDB_TIMEOUT_ERROR: 11011;
+        INDEXEDDB_ABORT_ERROR: 11012;
+        INDEXEDDB_UNKNOWN_ERROR: 11013;
     }
 
     interface MediaPlayerEvents {
@@ -592,69 +762,74 @@ declare namespace dashjs {
         type: MediaPlayerEvents['ERROR'];
         error: {
             code: MediaPlayerErrors['MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE'] |
-                  MediaPlayerErrors['MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE'] |
-                  MediaPlayerErrors['XLINK_LOADER_LOADING_FAILURE_ERROR_CODE'] |
-                  MediaPlayerErrors['SEGMENTS_UPDATE_FAILED_ERROR_CODE'] |
-                  MediaPlayerErrors['SEGMENTS_UNAVAILABLE_ERROR_CODE'] |
-                  MediaPlayerErrors['SEGMENT_BASE_LOADER_ERROR_CODE'] |
-                  MediaPlayerErrors['TIME_SYNC_FAILED_ERROR_CODE'] |
-                  MediaPlayerErrors['FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE'] |
-                  MediaPlayerErrors['FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE'] |
-                  MediaPlayerErrors['URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE'] |
-                  MediaPlayerErrors['APPEND_ERROR_CODE'] |
-                  MediaPlayerErrors['REMOVE_ERROR_CODE'] |
-                  MediaPlayerErrors['DATA_UPDATE_FAILED_ERROR_CODE'] |
-                  MediaPlayerErrors['CAPABILITY_MEDIASOURCE_ERROR_CODE'] |
-                  MediaPlayerErrors['CAPABILITY_MEDIAKEYS_ERROR_CODE'] |
-                  MediaPlayerErrors['DOWNLOAD_ERROR_ID_MANIFEST_CODE'] |
-                  MediaPlayerErrors['DOWNLOAD_ERROR_ID_CONTENT_CODE'] |
-                  MediaPlayerErrors['DOWNLOAD_ERROR_ID_INITIALIZATION_CODE'] |
-                  MediaPlayerErrors['DOWNLOAD_ERROR_ID_XLINK_CODE'] |
-                  MediaPlayerErrors['MANIFEST_ERROR_ID_PARSE_CODE'] |
-                  MediaPlayerErrors['MANIFEST_ERROR_ID_NOSTREAMS_CODE'] |
-                  MediaPlayerErrors['TIMED_TEXT_ERROR_ID_PARSE_CODE'] |
-                  MediaPlayerErrors['MANIFEST_ERROR_ID_MULTIPLEXED_CODE'] |
-                  MediaPlayerErrors['MEDIASOURCE_TYPE_UNSUPPORTED_CODE'] |
-                  // Protection errors
-                  MediaPlayerErrors['MEDIA_KEYERR_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEYERR_UNKNOWN_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEYERR_CLIENT_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEYERR_SERVICE_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEYERR_OUTPUT_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEYERR_HARDWARECHANGE_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEYERR_DOMAIN_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEY_MESSAGE_ERROR_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE'] |
-                  MediaPlayerErrors['SERVER_CERTIFICATE_UPDATED_ERROR_CODE'] |
-                  MediaPlayerErrors['KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE'] |
-                  MediaPlayerErrors['KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE'] |
-                  MediaPlayerErrors['KEY_SESSION_CREATED_ERROR_CODE'] |
-                  MediaPlayerErrors['MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE'] |
-                  // Offline errors
-                  MediaPlayerErrors['OFFLINE_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_QUOTA_EXCEED_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_INVALID_STATE_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_NOT_READABLE_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_NOT_FOUND_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_NETWORK_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_DATA_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_TRANSACTION_INACTIVE_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_NOT_ALLOWED_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_NOT_SUPPORTED_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_VERSION_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_TIMEOUT_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_ABORT_ERROR'] |
-                  MediaPlayerErrors['INDEXEDDB_UNKNOWN_ERROR'] |
-                  // MSS errors
-                  MediaPlayerErrors['MSS_NO_TFRF_CODE'] |
-                  MediaPlayerErrors['MSS_UNSUPPORTED_CODEC_CODE'],
+                MediaPlayerErrors['MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE'] |
+                MediaPlayerErrors['XLINK_LOADER_LOADING_FAILURE_ERROR_CODE'] |
+                MediaPlayerErrors['SEGMENTS_UPDATE_FAILED_ERROR_CODE'] |
+                MediaPlayerErrors['SEGMENTS_UNAVAILABLE_ERROR_CODE'] |
+                MediaPlayerErrors['SEGMENT_BASE_LOADER_ERROR_CODE'] |
+                MediaPlayerErrors['TIME_SYNC_FAILED_ERROR_CODE'] |
+                MediaPlayerErrors['FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE'] |
+                MediaPlayerErrors['FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE'] |
+                MediaPlayerErrors['URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE'] |
+                MediaPlayerErrors['APPEND_ERROR_CODE'] |
+                MediaPlayerErrors['REMOVE_ERROR_CODE'] |
+                MediaPlayerErrors['DATA_UPDATE_FAILED_ERROR_CODE'] |
+                MediaPlayerErrors['CAPABILITY_MEDIASOURCE_ERROR_CODE'] |
+                MediaPlayerErrors['CAPABILITY_MEDIAKEYS_ERROR_CODE'] |
+                MediaPlayerErrors['DOWNLOAD_ERROR_ID_MANIFEST_CODE'] |
+                MediaPlayerErrors['DOWNLOAD_ERROR_ID_CONTENT_CODE'] |
+                MediaPlayerErrors['DOWNLOAD_ERROR_ID_INITIALIZATION_CODE'] |
+                MediaPlayerErrors['DOWNLOAD_ERROR_ID_XLINK_CODE'] |
+                MediaPlayerErrors['MANIFEST_ERROR_ID_PARSE_CODE'] |
+                MediaPlayerErrors['MANIFEST_ERROR_ID_NOSTREAMS_CODE'] |
+                MediaPlayerErrors['TIMED_TEXT_ERROR_ID_PARSE_CODE'] |
+                MediaPlayerErrors['MANIFEST_ERROR_ID_MULTIPLEXED_CODE'] |
+                MediaPlayerErrors['MEDIASOURCE_TYPE_UNSUPPORTED_CODE'] |
+                // Protection errors
+                MediaPlayerErrors['MEDIA_KEYERR_CODE'] |
+                MediaPlayerErrors['MEDIA_KEYERR_UNKNOWN_CODE'] |
+                MediaPlayerErrors['MEDIA_KEYERR_CLIENT_CODE'] |
+                MediaPlayerErrors['MEDIA_KEYERR_SERVICE_CODE'] |
+                MediaPlayerErrors['MEDIA_KEYERR_OUTPUT_CODE'] |
+                MediaPlayerErrors['MEDIA_KEYERR_HARDWARECHANGE_CODE'] |
+                MediaPlayerErrors['MEDIA_KEYERR_DOMAIN_CODE'] |
+                MediaPlayerErrors['MEDIA_KEY_MESSAGE_ERROR_CODE'] |
+                MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE'] |
+                MediaPlayerErrors['SERVER_CERTIFICATE_UPDATED_ERROR_CODE'] |
+                MediaPlayerErrors['KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE'] |
+                MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE'] |
+                MediaPlayerErrors['KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE'] |
+                MediaPlayerErrors['KEY_SESSION_CREATED_ERROR_CODE'] |
+                MediaPlayerErrors['MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE'] |
+                // Offline errors
+                MediaPlayerErrors['OFFLINE_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_QUOTA_EXCEED_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_INVALID_STATE_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_NOT_READABLE_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_NOT_FOUND_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_NETWORK_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_DATA_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_TRANSACTION_INACTIVE_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_NOT_ALLOWED_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_NOT_SUPPORTED_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_VERSION_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_TIMEOUT_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_ABORT_ERROR'] |
+                MediaPlayerErrors['INDEXEDDB_UNKNOWN_ERROR'] |
+                // MSS errors
+                MediaPlayerErrors['MSS_NO_TFRF_CODE'] |
+                MediaPlayerErrors['MSS_UNSUPPORTED_CODEC_CODE'],
             message: string,
             data: object,
         }
     }
 
-    export type ErrorEvent = GenericErrorEvent | DownloadErrorEvent | ManifestErrorEvent | TimedTextErrorEvent | MediaPlayerErrorEvent;
+    export type ErrorEvent =
+        GenericErrorEvent
+        | DownloadErrorEvent
+        | ManifestErrorEvent
+        | TimedTextErrorEvent
+        | MediaPlayerErrorEvent;
 
     export interface CaptionRenderedEvent extends Event {
         type: MediaPlayerEvents['CAPTION_RENDERED'];
@@ -668,7 +843,8 @@ declare namespace dashjs {
 
     export interface DynamicToStaticEvent extends Event {
         type: MediaPlayerEvents['DYNAMIC_TO_STATIC'];
-    }    
+    }
+
     export interface FragmentLoadingCompletedEvent extends Event {
         type: MediaPlayerEvents['FRAGMENT_LOADING_COMPLETED'];
         request: FragmentRequest;
@@ -685,6 +861,7 @@ declare namespace dashjs {
 
     export class KeyError {
         constructor(sessionToken: SessionToken, errorString: string);
+
         sessionToken: SessionToken;
         error: string;
     }
@@ -696,6 +873,7 @@ declare namespace dashjs {
 
     export class KeyMessage {
         constructor(sessionToken: SessionToken, message: ArrayBuffer, defaultURL: string, messageType?: string);
+
         sessionToken: SessionToken;
         message: ArrayBuffer;
         defaultURL: string;
@@ -822,7 +1000,6 @@ declare namespace dashjs {
     export interface ProtectionCreatedEvent extends Event {
         type: MediaPlayerEvents['PROTECTION_CREATED'];
         controller: object;
-        manifest: object;
     }
 
     export interface ProtectionDestroyedEvent extends Event {
@@ -924,22 +1101,35 @@ declare namespace dashjs {
     export interface SessionToken {
         session: MediaKeySession;
         initData: any;
+
         getSessionID(): string;
+
         getExpirationTime(): number;
+
         getKeyStatuses(): MediaKeyStatusMap;
+
         getSessionType(): string;
     }
 
     export interface Stream {
         initialize(streamInfo: StreamInfo, protectionController: ProtectionController): void;
+
         activate(MediaSource: MediaSource): void;
+
         deactivate(): void;
+
         getDuration(): number;
+
         getStartTime(): number;
+
         getId(): string;
+
         getStreamInfo(): StreamInfo | null;
+
         getBitrateListFor(type: MediaType): BitrateInfo[];
+
         updateData(updatedStreamInfo: StreamInfo): void;
+
         reset(): void;
     }
 
@@ -975,20 +1165,31 @@ declare namespace dashjs {
 
     export interface DashMetrics {
         getCurrentRepresentationSwitch(type: MediaType): ICurrentRepresentationSwitch;
+
         getCurrentBufferState(type: MediaType): IBufferState;
+
         getCurrentBufferLevel(type: MediaType): number;
+
         getCurrentHttpRequest(type: MediaType): object;
+
         getHttpRequests(type: MediaType): object[];
+
         getCurrentDroppedFrames(): IDroppedFrames;
+
         getCurrentSchedulingInfo(type: MediaType): object;
+
         getCurrentDVRInfo(type: MediaType): IDVRInfo[];
+
         getCurrentManifestUpdate(): any;
+
         getLatestFragmentRequestHeaderValueByID(id: string): string;
+
         getLatestMPDRequestHeaderValueByID(type: MediaType, id: string): string;
     }
 
     export interface DashAdapter {
         getBandwidthForRepresentation(representationId: string, periodIdx: number): number;
+
         getIndexForRepresentation(representationId: string, periodIdx: number): number;
 
         /**
@@ -1032,11 +1233,17 @@ declare namespace dashjs {
         systemString: string;
         uuid: string;
         schemeIdURI: string;
+
         getInitData(cp: object): ArrayBuffer;
+
         getRequestHeadersFromMessage(message: ArrayBuffer): object | null;
+
         getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array;
+
         getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
+
         getCDMData(): ArrayBuffer | null;
+
         getSessionId(): string | null;
     }
 
@@ -1159,6 +1366,7 @@ declare namespace dashjs {
     export type MetricType = 'ManifestUpdate' | 'RequestsQueue';
     export type TrackSwitchMode = 'alwaysReplace' | 'neverReplace';
     export type TrackSelectionMode = 'highestBitrate' | 'firstTrack' | 'highestEfficiency' | 'widestRange';
+
     export function supportsMediaSource(): boolean;
 
 }
diff --git a/package-lock.json b/package-lock.json
index 8365c9975c..202ad64d25 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "dashjs",
-  "version": "3.2.2",
+  "version": "4.0.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
diff --git a/package.json b/package.json
index 0a4bafd236..0346dca7c3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "dashjs",
-  "version": "3.2.2",
+  "version": "4.0.0",
   "description": "A reference client implementation for the playback of MPEG DASH via Javascript and compliant browsers.",
   "author": "Dash Industry Forum",
   "license": "BSD-3-Clause",
diff --git a/samples/advanced/settings.html b/samples/advanced/settings.html
index 49b2fa0614..12a52c2df3 100644
--- a/samples/advanced/settings.html
+++ b/samples/advanced/settings.html
@@ -11,21 +11,22 @@
 
     <script>
         var player;
+
         function init() {
             var video,
-                url = "https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd";
+                url = 'https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd';
 
-            video = document.querySelector("video");
+            video = document.querySelector('video');
             player = dashjs.MediaPlayer().create();
             player.initialize(video, url, true);
 
             applySettings()
 
-            player.on(dashjs.MediaPlayer.events["PLAYBACK_ENDED"], function() {
+            player.on(dashjs.MediaPlayer.events['PLAYBACK_ENDED'], function () {
                 clearInterval(eventPoller);
             });
 
-            var eventPoller = setInterval(function() {
+            var eventPoller = setInterval(function () {
                 var streamInfo = player.getActiveStream().getStreamInfo();
                 var dashMetrics = player.getDashMetrics();
                 var dashAdapter = player.getDashAdapter();
@@ -35,8 +36,8 @@
                     var repSwitch = dashMetrics.getCurrentRepresentationSwitch('video', true);
                     var bufferLevel = dashMetrics.getCurrentBufferLevel('video', true);
                     var bitrate = repSwitch ? Math.round(dashAdapter.getBandwidthForRepresentation(repSwitch.to, periodIdx) / 1000) : NaN;
-                    document.getElementById('currentBufferLevel').innerText = bufferLevel + " secs";
-                    document.getElementById('reportedBitrate').innerText = bitrate + " Kbps";
+                    document.getElementById('currentBufferLevel').innerText = bufferLevel + ' secs';
+                    document.getElementById('reportedBitrate').innerText = bitrate + ' Kbps';
                 }
             }, 1000);
         }
@@ -52,8 +53,10 @@
 
             player.updateSettings({
                 'streaming': {
-                    'stableBufferTime': stableBuffer,
-                    'bufferTimeAtTopQualityLongForm': bufferAtTopQuality,
+                    'buffer': {
+                        'bufferTimeAtTopQualityLongForm': bufferAtTopQuality,
+                        'stableBufferTime': stableBuffer
+                    },
                     'abr': {
                         'minBitrate': {
                             'video': minBitrate
@@ -80,6 +83,7 @@
         fieldset {
             width: 70%;
         }
+
         fieldset > div {
             margin-top: 20px;
         }
@@ -94,22 +98,30 @@
 <body>
 <div id="container">
     <div class="video-container">
-        <video  data-dashjs-player autoplay controls="true">
+        <video data-dashjs-player autoplay controls="true">
         </video>
     </div>
     <fieldset>
         <legend>Configuration parameters</legend>
         <div>
-            Max stable buffer (seconds): <input type="number" id="stableBuffer" value="20"> (Current Buffer: <span id="currentBufferLevel")>0</span> seconds)
-            <div class="description">The time that the internal buffer target will be set to post startup/seeks (NOT top quality).</div>
+            Max stable buffer (seconds): <input type="number" id="stableBuffer" value="20"> (Current Buffer: <span
+            id="currentBufferLevel" )>0</span> seconds)
+            <div class="description">The time that the internal buffer target will be set to post startup/seeks (NOT top
+                quality).
+            </div>
         </div>
         <div>
             Buffer lenght at top quality (seconds): <input type="number" id="topQualityBuffer" value="20">
-            <div class="description">The time that the internal buffer target will be set to once playing the top quality.</div>
+            <div class="description">The time that the internal buffer target will be set to once playing the top
+                quality.
+            </div>
         </div>
         <div>
-            Max selectable bitrate (Kbps): <input type="number" id="maxBitrate" value="5000"> (Downloading bitrate: <span id="reportedBitrate")>0</span>)
-            <div class="description">The maximum bitrate selectable by the ABR algorithms will choose. Use -1 for no limit.</div>
+            Max selectable bitrate (Kbps): <input type="number" id="maxBitrate" value="5000"> (Downloading bitrate:
+            <span id="reportedBitrate" )>0</span>)
+            <div class="description">The maximum bitrate selectable by the ABR algorithms will choose. Use -1 for no
+                limit.
+            </div>
         </div>
         <div>
             Min selectable bitrate (Kbps): <input type="number" id="minBitrate" value="-1">
@@ -117,7 +129,8 @@
         </div>
         <div>
             Limit Bitrate By Portal Size: <input type="checkbox" id="limitByPortal">
-            <div class="description">If true, the size of the video portal will limit the max chosen video resolution.</div>
+            <div class="description">If true, the size of the video portal will limit the max chosen video resolution.
+            </div>
         </div>
         <div>
             <button onclick="applySettings()">Apply changes</button>
@@ -125,7 +138,7 @@
     </fieldset>
 </div>
 <script>
-    document.addEventListener("DOMContentLoaded", function () {
+    document.addEventListener('DOMContentLoaded', function () {
         init();
     });
 </script>
diff --git a/samples/captioning/caption_vtt.html b/samples/captioning/caption_vtt.html
index a7539868d9..5744478985 100644
--- a/samples/captioning/caption_vtt.html
+++ b/samples/captioning/caption_vtt.html
@@ -19,7 +19,6 @@
 
             player = dashjs.MediaPlayer({}).create();
             player.initialize(video, url, true);
-            player.setTextDefaultEnabled(true);
         }
     </script>
 
diff --git a/samples/captioning/multi-track-captions.html b/samples/captioning/multi-track-captions.html
index b5bbb9cdd0..b537ad0fca 100644
--- a/samples/captioning/multi-track-captions.html
+++ b/samples/captioning/multi-track-captions.html
@@ -51,7 +51,7 @@
 
         function setTextDefaultEnabled() {
             var checkbox = document.getElementById("textDefaultEnabled");
-            player.setTextDefaultEnabled(checkbox.checked);
+            player.updateSettings({streaming: {text: {defaultEnabled: checkbox.checked}}});
         }
 
         function setLang() {
diff --git a/samples/captioning/ttml-ebutt-sample.html b/samples/captioning/ttml-ebutt-sample.html
index 663a3b4deb..7391ec0f23 100644
--- a/samples/captioning/ttml-ebutt-sample.html
+++ b/samples/captioning/ttml-ebutt-sample.html
@@ -32,7 +32,6 @@
 
             player = dashjs.MediaPlayer().create();
             player.initialize(videoElement, url, true);
-            player.setTextDefaultEnabled(true);
             player.attachTTMLRenderingDiv(TTMLRenderingDiv);
             controlbar = new ControlBar(player); // Checkout ControlBar.js for more info on how to target/add text tracks to UI
             controlbar.initialize();
diff --git a/samples/dash-if-reference-player/app/main.js b/samples/dash-if-reference-player/app/main.js
index 12d4d3d4da..962bdd7e61 100644
--- a/samples/dash-if-reference-player/app/main.js
+++ b/samples/dash-if-reference-player/app/main.js
@@ -75,6 +75,8 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         $scope.contributors = data.items;
     });
 
+
+    /* ======= Chart related stuff ======= */
     $scope.chartOptions = {
         legend: {
             labelBoxBorderColor: '#ffffff',
@@ -126,13 +128,11 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         },
         yaxes: []
     };
-
     $scope.chartEnabled = true;
     $scope.maxPointsToChart = 30;
     $scope.maxChartableItems = 5;
     $scope.chartCount = 0;
     $scope.chartData = [];
-
     $scope.chartState = {
         audio: {
             buffer: { data: [], selected: false, color: '#65080c', label: 'Audio Buffer Level' },
@@ -158,6 +158,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         }
     };
 
+    /* ======= General ======= */
     $scope.abrEnabled = true;
     $scope.toggleCCBubble = false;
     $scope.debugEnabled = false;
@@ -188,6 +189,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.videoBitrate = 0;
     $scope.videoIndex = 0;
     $scope.videoPendingIndex = 0;
+    $scope.videoPendingMaxIndex = 0;
     $scope.videoMaxIndex = 0;
     $scope.videoBufferLength = 0;
     $scope.videoDroppedFrames = 0;
@@ -202,6 +204,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.audioBitrate = 0;
     $scope.audioIndex = 0;
     $scope.audioPendingIndex = '';
+    $scope.audioPendingMaxIndex = '';
     $scope.audioMaxIndex = 0;
     $scope.audioBufferLength = 0;
     $scope.audioDroppedFrames = 0;
@@ -269,7 +272,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
                     'logLevel': dashjs.Debug.LOG_LEVEL_INFO
                 },
                 'streaming': {
-                    'fastSwitchEnabled': $scope.fastSwitchSelected,
+                    'buffer': {
+                        'fastSwitchEnabled': $scope.fastSwitchSelected,
+                    },
                     'jumpGaps': true,
                     'abr': {
                         'autoSwitchBitrate': {
@@ -283,8 +288,8 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         }
     };
 
-    reqConfig.open("GET", "dashjs_config.json", true);
-    reqConfig.setRequestHeader("Content-type", "application/json");
+    reqConfig.open('GET', 'dashjs_config.json', true);
+    reqConfig.setRequestHeader('Content-type', 'application/json');
     reqConfig.send();
 
     $scope.player.on(dashjs.MediaPlayer.events.ERROR, function (e) { /* jshint ignore:line */
@@ -326,17 +331,14 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
                         break;
                 }
             });
-            $("#errorModal").modal('show');
+            $('#errorModal').modal('show');
         }
     }, $scope);
 
 
     $scope.player.initialize($scope.video, null, $scope.autoPlaySelected);
+    $scope.player.attachTTMLRenderingDiv($('#video-caption')[0]);
 
-    // Add HTML-rendered TTML subtitles except for Firefox < v49 (issue #1164)
-    if (doesTimeMarchesOn()) {
-        $scope.player.attachTTMLRenderingDiv($('#video-caption')[0]);
-    }
 
     var currentConfig = $scope.player.getSettings();
 
@@ -365,23 +367,28 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         $scope.isDynamic = e.data.type === 'dynamic';
     }, $scope);
 
-    $scope.player.on(dashjs.MediaPlayer.events.QUALITY_CHANGE_REQUESTED, function (e) { /* jshint ignore:line */
-        $scope[e.mediaType + 'Index'] = e.oldQuality + 1;
+    $scope.player.on(dashjs.MediaPlayer.events.SETTING_PLAYBACK_QUALITY, function (e) { /* jshint ignore:line */
+        var dashAdapter = $scope.player.getDashAdapter();
+        var maxIndex = dashAdapter.getMaxIndexForBufferType(e.mediaType, e.streamInfo.index);
+        var bitrate = Math.round(e.bitrateInfo.bitrate / 1000);
+
         $scope[e.mediaType + 'PendingIndex'] = e.newQuality + 1;
+        $scope[e.mediaType + 'PendingMaxIndex'] = maxIndex;
+        $scope[e.mediaType + 'Bitrate'] = bitrate;
         $scope.plotPoint('pendingIndex', e.mediaType, e.newQuality + 1, getTimeForPlot());
         $scope.safeApply();
     }, $scope);
 
+    $scope.player.on(dashjs.MediaPlayer.events.PERIOD_SWITCH_COMPLETED, function (e) { /* jshint ignore:line */
+        $scope.currentStreamInfo = e.toStreamInfo;
+    }, $scope);
+
     $scope.player.on(dashjs.MediaPlayer.events.QUALITY_CHANGE_RENDERED, function (e) { /* jshint ignore:line */
         $scope[e.mediaType + 'Index'] = e.newQuality + 1;
         $scope.plotPoint('index', e.mediaType, e.newQuality + 1, getTimeForPlot());
         $scope.safeApply();
     }, $scope);
 
-    $scope.player.on(dashjs.MediaPlayer.events.PERIOD_SWITCH_COMPLETED, function (e) { /* jshint ignore:line */
-        $scope.streamInfo = e.toStreamInfo;
-    }, $scope);
-
     $scope.player.on(dashjs.MediaPlayer.events.STREAM_INITIALIZED, function (e) { /* jshint ignore:line */
         stopMetricsInterval();
 
@@ -422,7 +429,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
                 return violation.event.key === e.event.key;
             })
 
-            if(!existingViolation || existingViolation.length === 0) {
+            if (!existingViolation || existingViolation.length === 0) {
                 $scope.conformanceViolations.push(e);
             }
         }
@@ -467,7 +474,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.changeABRStrategy = function (strategy) {
         $scope.player.updateSettings({
             streaming: {
-                stallThreshold: 0.5,
+                buffer: {
+                    stallThreshold: 0.5
+                },
                 abr: {
                     ABRStrategy: strategy
                 }
@@ -477,7 +486,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         if (strategy === 'abrLoLP') {
             $scope.player.updateSettings({
                 streaming: {
-                    stallThreshold: 0.05
+                    buffer: {
+                        stallThreshold: 0.05
+                    }
                 }
             });
             $scope.changeFetchThroughputCalculation('abrFetchThroughputCalculationMoofParsing');
@@ -509,7 +520,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.toggleFastSwitch = function () {
         $scope.player.updateSettings({
             'streaming': {
-                'fastSwitchEnabled': $scope.fastSwitchSelected
+                'buffer': {
+                    'fastSwitchEnabled': $scope.fastSwitchSelected
+                }
             }
         });
     };
@@ -529,7 +542,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.toggleScheduleWhilePaused = function () {
         $scope.player.updateSettings({
             'streaming': {
-                'scheduleWhilePaused': $scope.scheduleWhilePausedSelected
+                'scheduling': {
+                    'scheduleWhilePaused': $scope.scheduleWhilePausedSelected
+                }
             }
         });
     };
@@ -544,8 +559,10 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
 
     $scope.toggleReuseExistingSourceBuffers = function () {
         $scope.player.updateSettings({
-            'streaming': {
-                'reuseExistingSourceBuffers': $scope.reuseExistingSourceBuffersSelected
+            streaming: {
+                buffer: {
+                    reuseExistingSourceBuffers: $scope.reuseExistingSourceBuffersSelected
+                }
             }
         });
     };
@@ -566,7 +583,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.toggleJumpGaps = function () {
         $scope.player.updateSettings({
             'streaming': {
-                'jumpGaps': $scope.jumpGapsSelected
+                'gaps': {
+                    'jumpGaps': $scope.jumpGapsSelected
+                }
             }
         });
     };
@@ -639,10 +658,14 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
 
         var config = {
             'streaming': {
-                'liveDelay': $scope.defaultLiveDelay,
-                'stableBufferTime': $scope.defaultStableBufferDelay,
-                'bufferTimeAtTopQuality': $scope.defaultBufferTimeAtTopQuality,
-                'bufferTimeAtTopQualityLongForm': $scope.defaultBufferTimeAtTopQualityLongForm,
+                'buffer': {
+                    'stableBufferTime': $scope.defaultStableBufferDelay,
+                    'bufferTimeAtTopQuality': $scope.defaultBufferTimeAtTopQuality,
+                    'bufferTimeAtTopQualityLongForm': $scope.defaultBufferTimeAtTopQualityLongForm,
+                },
+                'delay': {
+                    'liveDelay': $scope.defaultLiveDelay
+                },
                 'lowLatencyEnabled': $scope.lowLatencyModeSelected,
                 abr: {},
                 cmcd: {}
@@ -653,19 +676,19 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
             var selectedConfig = $scope.selectedItem.bufferConfig;
 
             if (selectedConfig.liveDelay) {
-                config.streaming.liveDelay = selectedConfig.liveDelay;
+                config.streaming.delay.liveDelay = selectedConfig.liveDelay;
             }
 
             if (selectedConfig.stableBufferTime) {
-                config.streaming.stableBufferTime = selectedConfig.stableBufferTime;
+                config.streaming.buffer.stableBufferTime = selectedConfig.stableBufferTime;
             }
 
             if (selectedConfig.bufferTimeAtTopQuality) {
-                config.streaming.bufferTimeAtTopQuality = selectedConfig.bufferTimeAtTopQuality;
+                config.streaming.buffer.bufferTimeAtTopQuality = selectedConfig.bufferTimeAtTopQuality;
             }
 
             if (selectedConfig.bufferTimeAtTopQualityLongForm) {
-                config.streaming.bufferTimeAtTopQualityLongForm = selectedConfig.bufferTimeAtTopQualityLongForm;
+                config.streaming.buffer.bufferTimeAtTopQualityLongForm = selectedConfig.bufferTimeAtTopQualityLongForm;
             }
 
             if (selectedConfig.lowLatencyMode !== undefined) {
@@ -675,7 +698,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
 
         const initialLiveDelay = parseFloat($scope.initialLiveDelay);
         if (!isNaN(initialLiveDelay)) {
-            config.streaming.liveDelay = initialLiveDelay;
+            config.streaming.delay.liveDelay = initialLiveDelay;
         }
 
         const initBitrate = parseInt($scope.initialVideoBitrate);
@@ -730,7 +753,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
                 });
             }
         }
-        $scope.player.setTextDefaultEnabled($scope.initialSettings.textEnabled);
+        $scope.player.updateSettings({ streaming: { text: { defaultEnabled: $scope.initialSettings.textEnabled } } });
         $scope.player.enableForcedTextStreaming($scope.initialSettings.forceTextStreaming);
         $scope.controlbar.enable();
     };
@@ -749,7 +772,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     };
 
     $scope.setLogLevel = function () {
-        var level = $("input[name='log-level']:checked").val();
+        var level = $('input[name=\'log-level\']:checked').val();
         switch (level) {
             case 'none':
                 $scope.player.updateSettings({ 'debug': { 'logLevel': dashjs.Debug.LOG_LEVEL_NONE } });
@@ -777,18 +800,18 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     };
 
     $scope.setCmcdMode = function () {
-        var mode = $("input[name='cmcd-mode']:checked").val();
+        var mode = $('input[name=\'cmcd-mode\']:checked').val();
         switch (mode) {
             case 'query':
-                $scope.player.updateSettings({ streaming: { cmcd: { mode: 'query' }}});
+                $scope.player.updateSettings({ streaming: { cmcd: { mode: 'query' } } });
                 break;
 
             case 'header':
-                $scope.player.updateSettings({ streaming: { cmcd: { mode: 'header' }}});
+                $scope.player.updateSettings({ streaming: { cmcd: { mode: 'header' } } });
                 break;
 
             default:
-                $scope.player.updateSettings({ streaming: { cmcd: { mode: 'query' }}});
+                $scope.player.updateSettings({ streaming: { cmcd: { mode: 'query' } } });
         }
     };
 
@@ -965,9 +988,9 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         var dashMetrics = $scope.player.getDashMetrics();
         var dashAdapter = $scope.player.getDashAdapter();
 
-        if (dashMetrics && $scope.streamInfo) {
-            var period = dashAdapter.getPeriodById($scope.streamInfo.id);
-            var periodIdx = period ? period.index : $scope.streamInfo.index;
+        if (dashMetrics && $scope.currentStreamInfo) {
+            var period = dashAdapter.getPeriodById($scope.currentStreamInfo.id);
+            var periodIdx = period ? period.index : $scope.currentStreamInfo.index;
 
             var maxIndex = dashAdapter.getMaxIndexForBufferType(type, periodIdx);
             var repSwitch = dashMetrics.getCurrentRepresentationSwitch(type, true);
@@ -984,7 +1007,6 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
 
             $scope[type + 'BufferLength'] = bufferLevel;
             $scope[type + 'MaxIndex'] = maxIndex;
-            $scope[type + 'Bitrate'] = bitrate;
             $scope[type + 'DroppedFrames'] = droppedFPS;
             $scope[type + 'LiveLatency'] = liveLatency;
 
@@ -1037,30 +1059,13 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     //
     ////////////////////////////////////////
 
-    function doesTimeMarchesOn() {
-        var version;
-        var REQUIRED_VERSION = 49.0;
-
-        if (typeof navigator !== 'undefined') {
-            if (!navigator.userAgent.match(/Firefox/)) {
-                return true;
-            }
-
-            version = parseFloat(navigator.userAgent.match(/rv:([0-9.]+)/)[1]);
-
-            if (!isNaN(version) && version >= REQUIRED_VERSION) {
-                return true;
-            }
-        }
-    }
-
     function setLatencyAttributes() {
         // get buffer default value
         var currentConfig = $scope.player.getSettings();
-        $scope.defaultLiveDelay = currentConfig.streaming.liveDelay;
-        $scope.defaultStableBufferDelay = currentConfig.streaming.stableBufferTime;
-        $scope.defaultBufferTimeAtTopQuality = currentConfig.streaming.bufferTimeAtTopQuality;
-        $scope.defaultBufferTimeAtTopQualityLongForm = currentConfig.streaming.bufferTimeAtTopQualityLongForm;
+        $scope.defaultLiveDelay = currentConfig.streaming.delay.liveDelay;
+        $scope.defaultStableBufferDelay = currentConfig.streaming.buffer.stableBufferTime;
+        $scope.defaultBufferTimeAtTopQuality = currentConfig.streaming.buffer.bufferTimeAtTopQuality;
+        $scope.defaultBufferTimeAtTopQualityLongForm = currentConfig.streaming.buffer.bufferTimeAtTopQualityLongForm;
         $scope.lowLatencyModeSelected = currentConfig.streaming.lowLatencyEnabled;
         $scope.liveCatchupEnabled = currentConfig.streaming.liveCatchup.enabled;
     }
@@ -1142,18 +1147,18 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
 
     let castPlayer;
 
-    $window['__onGCastApiAvailable'] = function(isAvailable) {
+    $window['__onGCastApiAvailable'] = function (isAvailable) {
         if (isAvailable) {
             castContext = cast.framework.CastContext.getInstance();
             castContext.setOptions({
-              receiverApplicationId: CAST_APP_ID,
-              autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED
+                receiverApplicationId: CAST_APP_ID,
+                autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED
             });
             castContext.addEventListener(cast.framework.CastContextEventType.CAST_STATE_CHANGED, function (e) {
                 console.log('[Cast]', e);
                 if (e.castState === cast.framework.CastState.CONNECTED) {
                     onCastReady();
-                } else if (e.castState === cast.framework.CastState.NOT_CONNECTED)  {
+                } else if (e.castState === cast.framework.CastState.NOT_CONNECTED) {
                     onCastEnd();
                 }
             });
@@ -1195,13 +1200,15 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         if (castSession) {
             castPlayer.reset();
             castSession.loadMedia(request).then(
-                function() {
+                function () {
                     let media = castSession.getMediaSession();
                     if (media) {
                         console.info('cast media: ', media);
                     }
                 },
-                function(errorCode) { console.log('Error code: ' + errorCode); }
+                function (errorCode) {
+                    console.log('Error code: ' + errorCode);
+                }
             );
         }
     }
diff --git a/samples/dash-if-reference-player/app/sources.json b/samples/dash-if-reference-player/app/sources.json
index 5ebc242c3a..a80a03b74a 100644
--- a/samples/dash-if-reference-player/app/sources.json
+++ b/samples/dash-if-reference-player/app/sources.json
@@ -58,6 +58,26 @@
             "acronym": "AWS",
             "name": "AWS",
             "url": "https://www.elemental.com/"
+        },
+        "dvb": {
+            "acronym": "DVB",
+            "name": "DVB",
+            "url": "https://dvb-2017-dm.s3.eu-central-1.amazonaws.com/overview.html"
+        },
+        "hbbtv": {
+            "acronym": "HbbTV",
+            "name": "HbbTV",
+            "url": "https://www.hbbtv.org/"
+        },
+        "google": {
+            "acronym": "Google",
+            "name": "Google",
+            "url": "https://www.google.com"    
+        },
+        "vdms": {
+            "acronym": "VDMS",
+            "name": "Verizon Media",
+            "url": "https://www.verizonmedia.com/"
         }
     },
     "items": [
@@ -149,6 +169,36 @@
                     "name": "Clear Static SegmentList",
                     "url": "//wowzaec2demo.streamlock.net/vod/_definst_/ElephantsDream/smil:ElephantsDream.smil/manifest_mvlist.mpd",
                     "provider": "wowza"
+                },
+                {
+                    "name": "Caminandes 01, Llama Drama (25fps, 75gop, 1080p) ",
+                    "url": "http://refapp.hbbtv.org/videos/01_llama_drama_1080p_25f75g6sv3/manifest.mpd",
+                    "provider": "hbbtv"
+                },
+                {
+                    "name": "Caminandes 02, Gran Dillama (25fps, 75gop, 1080p, KID=1236, subob,evtib) v5 ",
+                    "url": "http://refapp.hbbtv.org/videos/02_gran_dillama_1080p_25f75g6sv5/manifest_subob_evtib.mpd",
+                    "provider": "hbbtv"
+                },
+                {
+                    "name": "Tears of Steel (25fps, 75gop, 1080p, KID=1237) v3",
+                    "url": "http://refapp.hbbtv.org/videos/tears_of_steel_1080p_25f75g6sv3/manifest.mpd",
+                    "provider": "hbbtv"
+                },
+                {
+                    "name": "Caminandes 02, Gran Dillama (25fps, 75gop, 1080p, KID=1236), multiaudio v4",
+                    "url": "http://refapp.hbbtv.org/videos/02_gran_dillama_1080p_ma_25f75g6sv4/manifest_subob_evtib.mpd",
+                    "provider": "hbbtv"
+                },
+                {
+                    "name": "Caminandes 02, Gran Dillama (25fps, 75gop, 1080p, KID=1236), multiaudio v5",
+                    "url": "http://refapp.hbbtv.org/videos/02_gran_dillama_1080p_ma_25f75g6sv5/manifest.mpd",
+                    "provider": "hbbtv"
+                },
+                {
+                    "name": "Spring (25fps, 75gop, 1920x804(2.40) h264, KID=148D) v1",
+                    "url": "http://refapp.hbbtv.org/videos/spring_804p_v1/manifest.mpd",
+                    "provider": "hbbtv"
                 }
             ]
         },
@@ -205,6 +255,41 @@
                     "name": "Clear Dynamic SegmentList",
                     "url": "//wowzaec2demo.streamlock.net/live/bigbuckbunny/manifest_mvlist.mpd",
                     "provider": "wowza"
+                },
+                {
+                    "name": "Multiperiod - Number + Timeline - Compact manifest - Thumbnails (1 track) - In-the-clear",
+                    "url": "https://d24rwxnt7vw9qb.cloudfront.net/v1/dash/e6d234965645b411ad572802b6c9d5a10799c9c1/All_Reference_Streams/4577dca5f8a44756875ab5cc913cd1f1/index.mpd",
+                    "provider": "aws"
+                },
+                {
+                    "name": "Multiperiod - Number + Timeline - Full manifest - Thumbnails (1 track) - In-the-clear",
+                    "url": "https://d24rwxnt7vw9qb.cloudfront.net/v1/dash/e6d234965645b411ad572802b6c9d5a10799c9c1/All_Reference_Streams/ee565ea510cb4b4d8df5f48918c3d6dc/index.mpd",
+                    "provider": "aws"
+                },
+                {
+                    "name": "Multiperiod - Time + Timeline - Compact manifest - Thumbnails (1 track) - In-the-clear",
+                    "url": "https://d24rwxnt7vw9qb.cloudfront.net/v1/dash/e6d234965645b411ad572802b6c9d5a10799c9c1/All_Reference_Streams/91d37b0389de47e0b5266736d3633077/index.mpd",
+                    "provider": "aws"
+                },
+                {
+                    "name": "Multiperiod - Time + Timeline - Full manifest - Thumbnails (1 track) - In-the-clear",
+                    "url": "https://d24rwxnt7vw9qb.cloudfront.net/v1/dash/e6d234965645b411ad572802b6c9d5a10799c9c1/All_Reference_Streams/6ba06d17f65b4e1cbd1238eaa05c02c1/index.mpd",
+                    "provider": "aws"
+                },
+                {
+                    "name": "Single period - Number + Duration - Full manifest - Thumbnails (2 tracks: 174p/1080p) - In-the-clear",
+                    "url": "https://d10gktn8v7end7.cloudfront.net/out/v1/6ee19df3afa24fe190a8ae16c2c88560/index.mpd",
+                    "provider": "aws"
+                },
+                {
+                    "name": " Multiperiod DVB 2017 0.mpd Live Clear AVC + AAC",
+                    "url": "https://pl8q5ug7b6.execute-api.eu-central-1.amazonaws.com/0.mpd",
+                    "provider": "dvb"
+                },
+                {
+                    "name": "LiveSIM Caminandes 02, Gran Dillama (25fps, 25gop, 2sec, multi MOOF/MDAT, 1080p, KID=1236) v2",
+                    "url": "http://refapp.hbbtv.org/livesim/02_llamav2/manifest.mpd",
+                    "provider": "hbbtv"
                 }
             ]
         },
@@ -320,12 +405,66 @@
                     "url": "https://dash.akamaized.net/dash264/CTA/imsc1/IT1-20171027_dash.mpd",
                     "name": "IMSC1 Text Subtitles via sidecar file",
                     "provider": "cta"
+                },                
+                {
+                    "url": "https://pl8q5ug7b6.execute-api.eu-central-1.amazonaws.com/2.mpd",
+                    "name": "Subtitles in multi period live",
+                    "provider": "unified"
                 }
             ]
         },
         {
             "name": "DRM (modern)",
             "submenu": [
+                {
+                    "name": "Multiperiod - Number + Timeline - Compact manifest - Thumbnails (1 track) - Encryption (1 key) PlayReady/Widevine (DRMtoday) - Key rotation (60s)",
+                    "url": "https://d24rwxnt7vw9qb.cloudfront.net/v1/dash/e6d234965645b411ad572802b6c9d5a10799c9c1/All_Reference_Streams/2fc23947945841b9b1be9768f9c13e75/index.mpd",
+                    "protData": {
+                        "com.widevine.alpha": {
+                            "serverURL": "https://lic.staging.drmtoday.com/license-proxy-widevine/cenc/?specConform=true",
+                            "httpRequestHeaders": {
+                                "x-dt-custom-data": "ewogICAgInVzZXJJZCI6ICJhd3MtZWxlbWVudGFsOjpzcGVrZS10ZXN0aW5nIiwKICAgICJzZXNzaW9uSWQiOiAiZWxlbWVudGFsLXJlZnN0cmVhbSIsCiAgICAibWVyY2hhbnQiOiAiYXdzLWVsZW1lbnRhbCIKfQo="
+                            },
+                            "com.microsoft.playready": {
+                                "serverURL": "https://lic.staging.drmtoday.com/license-proxy-headerauth/drmtoday/RightsManager.asmx",
+                                "httpRequestHeaders": {
+                                    "x-dt-custom-data": "ewogICAgInVzZXJJZCI6ICJhd3MtZWxlbWVudGFsOjpzcGVrZS10ZXN0aW5nIiwKICAgICJzZXNzaW9uSWQiOiAiZWxlbWVudGFsLXJlZnN0cmVhbSIsCiAgICAibWVyY2hhbnQiOiAiYXdzLWVsZW1lbnRhbCIKfQo="
+                                }
+                            }
+                        }
+                    },
+                    "provider": "aws"
+                },
+                {
+                    "name": "Multiperiod - Number + Timeline - Compact manifest - Thumbnails (1 track) - Encryption (2 keys : audio + video) - No key rotation",
+                    "url": "https://d24rwxnt7vw9qb.cloudfront.net/v1/dash/e6d234965645b411ad572802b6c9d5a10799c9c1/All_Reference_Streams//6e16c26536564c2f9dbc5f725a820cff/index.mpd",
+                    "protData": {
+                        "com.widevine.alpha": {
+                            "serverURL": "https://lic.staging.drmtoday.com/license-proxy-widevine/cenc/?specConform=true",
+                            "httpRequestHeaders": {
+                                "x-dt-custom-data": "ewogICAgInVzZXJJZCI6ICJhd3MtZWxlbWVudGFsOjpzcGVrZS10ZXN0aW5nIiwKICAgICJzZXNzaW9uSWQiOiAiZWxlbWVudGFsLXJlZnN0cmVhbSIsCiAgICAibWVyY2hhbnQiOiAiYXdzLWVsZW1lbnRhbCIKfQo="
+                            },
+                            "com.microsoft.playready": {
+                                "serverURL": "https://lic.staging.drmtoday.com/license-proxy-headerauth/drmtoday/RightsManager.asmx",
+                                "httpRequestHeaders": {
+                                    "x-dt-custom-data": "ewogICAgInVzZXJJZCI6ICJhd3MtZWxlbWVudGFsOjpzcGVrZS10ZXN0aW5nIiwKICAgICJzZXNzaW9uSWQiOiAiZWxlbWVudGFsLXJlZnN0cmVhbSIsCiAgICAibWVyY2hhbnQiOiAiYXdzLWVsZW1lbnRhbCIKfQo="
+                                }
+                            }
+                        }
+                    },
+                    "provider": "aws"
+                },
+                {
+                    "name": "Shaka Demo Assets: Angel-One Widevine",
+                    "url": "https://storage.googleapis.com/shaka-demo-assets/angel-one-widevine/dash.mpd",
+                    "protData": {
+                        "com.widevine.alpha": {
+                            "serverURL": "https://widevine-proxy.appspot.com/proxy?video_id=&provider="
+                        }
+                    },
+                    "moreInfo": "https://github.com/Axinom/dash-test-vectors",
+                    "provider": "google"
+                },
                 {
                     "name": "1080p with Widevine DRM, license expired after 60s",
                     "url": "https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p.mpd",
@@ -819,6 +958,36 @@
                         }
                     },
                     "provider": "wowza"
+                },
+                {
+                    "name": "Live Dash WV and PR with unencrypted ad breaks -- Always starts in encrypted content - Keys never change",
+                    "url": "https://content.uplynk.com/playlist/6c526d97954b41deb90fe64328647a71.mpd?ad=bbbads&delay=25",
+                    "protData": {
+                        "com.widevine.alpha": {
+                            "serverURL": "https://content.uplynk.com/wv",
+                            "httpTimeout": 5000
+                        },
+                        "com.microsoft.playready": {
+                            "serverURL": "https://content.uplynk.com/pr",
+                            "httpTimeout": 5000
+                        }
+                    },
+                    "provider": "vdms"
+                },
+                {
+                    "name": "Live Dash WV and PR - Starting in unencrypted ad (preroll) - Moving into encrypted content - Keys never change",
+                    "url": "https://content.uplynk.com/playlist/4f1a9815a1af43d5ba64465d85bf11cf.mpd?ad=sintelads",
+                    "protData": {
+                        "com.widevine.alpha": {
+                            "serverURL": "https://content.uplynk.com/wv",
+                            "httpTimeout": 5000
+                        },
+                        "com.microsoft.playready": {
+                            "serverURL": "https://content.uplynk.com/pr",
+                            "httpTimeout": 5000
+                        }
+                    },
+                    "provider": "vdms"
                 }
             ]
         },
diff --git a/samples/dash-if-reference-player/dashjs_config.json b/samples/dash-if-reference-player/dashjs_config.json
index d4355a3c85..f1b3e72d65 100644
--- a/samples/dash-if-reference-player/dashjs_config.json
+++ b/samples/dash-if-reference-player/dashjs_config.json
@@ -1,72 +1,5 @@
 {
     "debug": {
         "logLevel": 5
-    },
-    "streaming": {
-        "metricsMaxListDepth": 50,
-        "abandonLoadTimeout": 10000,
-        "liveDelayFragmentCount": null,
-        "liveDelay": null,
-        "scheduleWhilePaused": true,
-        "fastSwitchEnabled": true,
-        "flushBufferAtTrackSwitch": false,
-        "bufferPruningInterval": 10,
-        "bufferToKeep": 20,
-        "jumpGaps": true,
-        "smallGapLimit": 1.5,
-        "stableBufferTime": -1,
-        "bufferTimeAtTopQuality": 30,
-        "bufferTimeAtTopQualityLongForm": 60,
-        "longFormContentDurationThreshold": 600,
-        "wallclockTimeUpdateInterval": 50,
-        "lowLatencyEnabled": false,
-        "keepProtectionMediaKeys": false,
-        "useManifestDateHeaderTimeSource": true,
-        "useSuggestedPresentationDelay": true,
-        "manifestUpdateRetryInterval": 100,
-        "liveCatchup": {
-            "minDrift": 0.02,
-            "maxDrift": 0,
-            "playbackRate": 0.5,
-            "latencyThreshold": null,
-            "enabled": false
-        },
-        "lastBitrateCachingInfo": { "enabled": true, "ttl": 360000},
-        "lastMediaSettingsCachingInfo": { "enabled": true, "ttl": 360000},
-        "cacheLoadThresholds": {"video": 50, "audio": 5},
-        "retryIntervals": {
-            "MPD":                       500,
-            "XLinkExpansion":            500,
-            "MediaSegment":              1000,
-            "InitializationSegment":     1000,
-            "BitstreamSwitchingSegment": 1000,
-            "IndexSegment":              1000,
-            "other":                     1000
-        },
-        "retryAttempts": {
-            "MPD":                         3,
-             "XLinkExpansion":             1,
-             "MediaSegment":               3,
-             "InitializationSegment":      3,
-             "BitstreamSwitchingSegment":  3,
-             "IndexSegment":               3,
-             "other":                      3
-        },
-        "abr": {
-            "movingAverageMethod": "slidingWindow",
-            "ABRStrategy": "abrDynamic",
-            "bandwidthSafetyFactor": 0.9,
-            "useDefaultABRRules": true,
-            "useBufferOccupancyABR": false,
-            "useDeadTimeLatency": true,
-            "limitBitrateByPortal": false,
-            "usePixelRatioInLimitBitrateByPortal": false,
-            "maxBitrate": { "audio": -1, "video": -1 },
-            "minBitrate": { "audio": -1, "video": -1 },
-            "maxRepresentationRatio": { "audio": 1, "video": 1 },
-            "initialBitrate": { "audio": -1, "video": -1 },
-            "initialRepresentationRatio": { "audio": -1, "video": -1 },
-            "autoSwitchBitrate": { "audio": true, "video": true }
-        }
     }
 }
\ No newline at end of file
diff --git a/samples/dash-if-reference-player/index.html b/samples/dash-if-reference-player/index.html
index c623e409df..aba93a1942 100644
--- a/samples/dash-if-reference-player/index.html
+++ b/samples/dash-if-reference-player/index.html
@@ -580,14 +580,14 @@
                                 <label class="text-primary" for="videoPendingIndexCB" data-toggle="tooltip"
                                        data-placement="top"
                                        title="The representation index being downloaded and appended to the buffer">Index
-                                    Downloading :</label> {{videoPendingIndex}}
+                                    Downloading :</label> {{videoPendingIndex}} / {{videoPendingMaxIndex}}
                             </div>
                             <div class="text-success">
                                 <input id="videoIndexCB" type="checkbox" ng-model="chartState.video.index.selected"
                                        ng-change="enableChartByName('index', 'video')">
                                 <label class="text-primary" for="videoIndexCB" data-toggle="tooltip"
                                        data-placement="top"
-                                       title="The representation index being rendered.">Current Index / Max Index
+                                       title="The representation index being rendered.">Index playing
                                     :</label> {{videoIndex}} / {{videoMaxIndex}}
                             </div>
                             <div class="text-success">
diff --git a/samples/drm/license-wrapping.html b/samples/drm/license-wrapping.html
index 5093278ad4..3909178df9 100644
--- a/samples/drm/license-wrapping.html
+++ b/samples/drm/license-wrapping.html
@@ -21,7 +21,7 @@
                 player,
                 url = "https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p.mpd";
 
-            var filterLicensRequest = function (request) {
+            var filterLicenseRequest = function (request) {
                 console.log('LICENSE REQUEST', request);
                 /* Here you can modify/overwrite the licens request (url, headers, data...) */
                 request.headers = {
@@ -39,7 +39,7 @@
             video = document.querySelector("video");
             player = dashjs.MediaPlayer().create();
 
-            player.registerLicenseRequestFilter(filterLicensRequest);
+            player.registerLicenseRequestFilter(filterLicenseRequest);
             player.registerLicenseResponseFilter(filterLicenseResponse);            
 
             player.initialize(video, url, true);
diff --git a/samples/getting-started/manual-load-with-custom-settings.html b/samples/getting-started/manual-load-with-custom-settings.html
index 89a37a8da7..a3ef047893 100644
--- a/samples/getting-started/manual-load-with-custom-settings.html
+++ b/samples/getting-started/manual-load-with-custom-settings.html
@@ -25,7 +25,9 @@
                 },
                 'streaming': {
                     'scheduleWhilePaused': false,   /* stops the player from loading segments while paused */
-                    'fastSwitchEnabled': true       /* enables buffer replacement when switching bitrates for faster switching */
+                    'buffer': {
+                        'fastSwitchEnabled': true   /* enables buffer replacement when switching bitrates for faster switching */
+                    }
                 }
             });
             player.setAutoPlay(false); /* remove this line if you want the player to start automatically on load */
diff --git a/samples/live-streaming/live-delay-comparison-custom-manifest.html b/samples/live-streaming/live-delay-comparison-custom-manifest.html
index eb12da5f3c..16fd12adc1 100644
--- a/samples/live-streaming/live-delay-comparison-custom-manifest.html
+++ b/samples/live-streaming/live-delay-comparison-custom-manifest.html
@@ -10,68 +10,71 @@
     <!--<script src="../../dist/dash.all.min.js"></script>-->
 
     <script class="code">
-        var player,firstLoad = true;
-        function init()
-        {
-            setInterval( function() {
-                if (player && player.isReady())
-                {
+        var player, firstLoad = true;
+
+        function init() {
+            setInterval(function () {
+                if (player && player.isReady()) {
                     var d = new Date();
                     var seconds = d.getSeconds();
-                    document.querySelector("#sec").innerHTML = ( seconds < 10 ? "0" : "" ) + seconds;
+                    document.querySelector('#sec').innerHTML = (seconds < 10 ? '0' : '') + seconds;
                     var minutes = d.getMinutes();
-                    document.querySelector("#min").innerHTML = ( minutes < 10 ? "0" : "" ) + minutes;
-                    document.querySelector("#videoDelay").innerHTML = Math.round((d.getTime()/1000) - Number(player.timeAsUTC()));
-                    document.querySelector("#videoBuffer").innerHTML = player.getBufferLength()+ "s";
+                    document.querySelector('#min').innerHTML = (minutes < 10 ? '0' : '') + minutes;
+                    document.querySelector('#videoDelay').innerHTML = Math.round((d.getTime() / 1000) - Number(player.timeAsUTC()));
+                    document.querySelector('#videoBuffer').innerHTML = player.getBufferLength() + 's';
                 }
-            },1000);
+            }, 1000);
         }
-        function load(button)
-        {
-            if (!firstLoad)
-            {
+
+        function load(button) {
+            if (!firstLoad) {
                 player.reset();
             }
             firstLoad = false;
-            var url =  document.getElementById("manifest").value;
+            var url = document.getElementById('manifest').value;
             player = dashjs.MediaPlayer().create();
-            player.updateSettings({ 'debug': { 'logLevel': dashjs.Debug.LOG_LEVEL_NONE }});
+            player.updateSettings({ 'debug': { 'logLevel': dashjs.Debug.LOG_LEVEL_NONE } });
 
             switch (document.querySelector('input[name="delay"]:checked').value) {
-                case "segments":
+                case 'segments':
                     player.updateSettings({
                         'streaming':
-                        {
-                            'liveDelayFragmentCount': document.querySelector("#delayInFragments").value
-                        }
+                            {
+                                'delay': {
+                                    'liveDelayFragmentCount': document.querySelector('#delayInFragments').value
+                                }
+
+                            }
                     });
 
                     break;
-                case "time":
+                case 'time':
                     player.updateSettings({
                         'streaming':
-                        {
-                            'liveDelay': document.querySelector("#delayInSeconds").value
-                        }
+                            {
+                                'delay': {
+                                    'liveDelay': document.querySelector('#delayInSeconds').value   
+                                }
+                            }
                     });
                     break;
             }
-            player.initialize(document.querySelector("video"), url, true);
+            player.initialize(document.querySelector('video'), url, true);
         }
-        function delaySelect(obj)
-        {
+
+        function delaySelect(obj) {
             switch (obj.value) {
-                case "default":
-                    document.querySelector("#fragmentsEntry").style.display = "none";
-                    document.querySelector("#secondsEntry").style.display = "none";
+                case 'default':
+                    document.querySelector('#fragmentsEntry').style.display = 'none';
+                    document.querySelector('#secondsEntry').style.display = 'none';
                     break;
-                case "segments":
-                    document.querySelector("#fragmentsEntry").style.display = "inline";
-                    document.querySelector("#secondsEntry").style.display = "none";
+                case 'segments':
+                    document.querySelector('#fragmentsEntry').style.display = 'inline';
+                    document.querySelector('#secondsEntry').style.display = 'none';
                     break;
-                case "time":
-                    document.querySelector("#fragmentsEntry").style.display = "none";
-                    document.querySelector("#secondsEntry").style.display = "inline";
+                case 'time':
+                    document.querySelector('#fragmentsEntry').style.display = 'none';
+                    document.querySelector('#secondsEntry').style.display = 'inline';
                     break;
             }
         }
@@ -82,32 +85,42 @@
             width: 640px;
             height: 360px;
         }
+
         #manifest {
-            width:300px;
+            width: 300px;
         }
+
         #loadButton {
             background-color: orange;
         }
+
         .clock {
-            color:#000; font-size: 40pt
+            color: #000;
+            font-size: 40pt
         }
-        #fragmentsEntry,#secondsEntry {
-            position:relative;
+
+        #fragmentsEntry, #secondsEntry {
+            position: relative;
             display: none;
-            width:50px;
+            width: 50px;
         }
-        #delayInFragments,#delayInSeconds {
-            width:50px;
+
+        #delayInFragments, #delayInSeconds {
+            width: 50px;
         }
     </style>
-    </head>
+</head>
 <body>
 
-This sample allows you to explore the two MediaPlayer APIS which control live delay - setLiveDelay and setLiveDelayFragmentCount.<br/>
+This sample allows you to explore the two MediaPlayer APIS which control live delay - setLiveDelay and
+setLiveDelayFragmentCount.<br/>
 The first takes the desired delay in seconds. The second takes the delay in terms of fragment count.
-If you use both together, setLiveDelay <br/> will take priority. If you set neither, the default delay of 4 segment durations will be used.
-Note that using either method will not result in the <br/> offset exactly matching the requested setings. The final achieved delay is a function of the segment duration, when the
-stream is requested <br/>with respect to the segment boundaries, as well as the amount of data the source buffers need to begin decoding.
+If you use both together, setLiveDelay <br/> will take priority. If you set neither, the default delay of 4 segment
+durations will be used.
+Note that using either method will not result in the <br/> offset exactly matching the requested setings. The final
+achieved delay is a function of the segment duration, when the
+stream is requested <br/>with respect to the segment boundaries, as well as the amount of data the source buffers need
+to begin decoding.
 Enter the URL to a live (dynamic) stream manifest :
 <input class="code" id="manifest" type="text" value="https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd"/><br/>
 <form class="code">
@@ -115,7 +128,8 @@
     <input type="radio" onclick="delaySelect(this)" name="delay" value="default" checked> Default<br/>
     <input type="radio" onclick="delaySelect(this)" name="delay" value="segments"> Fragment Count<br/>
     <div id="fragmentsEntry">
-        Enter the desired value for setLiveDelayFragmentCount in number of fragments <input id="delayInFragments" type="text"/> <br/>
+        Enter the desired value for setLiveDelayFragmentCount in number of fragments <input id="delayInFragments"
+                                                                                            type="text"/> <br/>
     </div>
     <input type="radio" onclick="delaySelect(this)" name="delay" value="time"> Time in seconds<br/>
     <div id="secondsEntry">
@@ -136,7 +150,7 @@
     </div>
 </div>
 <script class="code">
-    document.addEventListener("DOMContentLoaded", function () {
+    document.addEventListener('DOMContentLoaded', function () {
         init();
     });
 </script>
diff --git a/samples/live-streaming/live-delay-comparison-using-fragmentCount.html b/samples/live-streaming/live-delay-comparison-using-fragmentCount.html
index 2867dbe51c..662e1c2bb4 100644
--- a/samples/live-streaming/live-delay-comparison-using-fragmentCount.html
+++ b/samples/live-streaming/live-delay-comparison-using-fragmentCount.html
@@ -20,32 +20,32 @@
                 video = document.querySelector("#video1");
                 player1 = dashjs.MediaPlayer().create();
                 player1.initialize(video,MPD_2S_SEGMENTS ,true);
-                player1.updateSettings({'streaming': { 'liveDelayFragmentCount': 0 }});
+                player1.updateSettings({'streaming': { 'delay': {'liveDelayFragmentCount': 0 }}});
 
                 video = document.querySelector("#video2");
                 player2 = dashjs.MediaPlayer().create();
                 player2.initialize(video,MPD_2S_SEGMENTS ,true);
-                player2.updateSettings({'streaming': { 'liveDelayFragmentCount': 2 }});
+                player2.updateSettings({'streaming': { 'delay': {'liveDelayFragmentCount': 2 }}});
 
                 video = document.querySelector("#video3");
                 player3 = dashjs.MediaPlayer().create();
                 player3.initialize(video,MPD_2S_SEGMENTS ,true);
-                player3.updateSettings({'streaming': { 'liveDelayFragmentCount': 4 }});
+                player3.updateSettings({'streaming': { 'delay': {'liveDelayFragmentCount': 4 }}});
 
                 video = document.querySelector("#video4");
                 player4 = dashjs.MediaPlayer().create();
                 player4.initialize(video,MPD_6S_SEGMENTS ,true);
-                player4.updateSettings({'streaming': { 'liveDelayFragmentCount': 0 }});
+                player4.updateSettings({'streaming': { 'delay': {'liveDelayFragmentCount': 0 }}});
 
                 video = document.querySelector("#video5");
                 player5 = dashjs.MediaPlayer().create();
                 player5.initialize(video,MPD_6S_SEGMENTS ,true);
-                player5.updateSettings({'streaming': { 'liveDelayFragmentCount': 2 }});
+                player5.updateSettings({'streaming': { 'delay': {'liveDelayFragmentCount': 2 }}});
 
                 video = document.querySelector("#video6");
                 player6 = dashjs.MediaPlayer().create();
                 player6.initialize(video,MPD_6S_SEGMENTS ,true);
-                player6.updateSettings({'streaming': { 'liveDelayFragmentCount': 4 }});
+                player6.updateSettings({'streaming': { 'delay': {'liveDelayFragmentCount': 4 }}});
 
 
                 setInterval( function() {
diff --git a/samples/live-streaming/live-delay-comparison-using-setLiveDelay.html b/samples/live-streaming/live-delay-comparison-using-setLiveDelay.html
index a35efe6839..e337a2f8de 100644
--- a/samples/live-streaming/live-delay-comparison-using-setLiveDelay.html
+++ b/samples/live-streaming/live-delay-comparison-using-setLiveDelay.html
@@ -1,138 +1,159 @@
 <!DOCTYPE html>
 <html lang="en">
-    <head>
-        <meta charset="utf-8"/>
-        <title>Live delay comparison using setLiveDelay</title>
+<head>
+    <meta charset="utf-8"/>
+    <title>Live delay comparison using setLiveDelay</title>
 
-        <script src="../../dist/dash.all.debug.js"></script>
-        <!--dash.all.min.js should be used in production over dash.all.debug.js
+    <script src="../../dist/dash.all.debug.js"></script>
+    <!--dash.all.min.js should be used in production over dash.all.debug.js
 Debug files are not compressed or obfuscated making the file size much larger compared with dash.all.min.js-->
-        <!--<script src="../../dist/dash.all.min.js"></script>-->
-
-        <script>
-            function init()
-            {
-                var player1,player2,player3,player4,player5,player6, video;
-                var MPD_2S_SEGMENTS = "https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd";
-                var MPD_6S_SEGMENTS = "https://livesim.dashif.org/livesim/testpic_6s/Manifest.mpd";
-
-
-                video = document.querySelector("#video1");
-                player1 = dashjs.MediaPlayer().create();
-                player1.initialize(video,MPD_2S_SEGMENTS ,true);
-                player1.updateSettings({ 'streaming': { 'liveDelay': 2 }});
-
-                video = document.querySelector("#video2");
-                player2 = dashjs.MediaPlayer().create();
-                player2.initialize(video,MPD_2S_SEGMENTS ,true);
-                player2.updateSettings({ 'streaming': { 'liveDelay': 4 }});
-
-                video = document.querySelector("#video3");
-                player3 = dashjs.MediaPlayer().create();
-                player3.initialize(video,MPD_2S_SEGMENTS ,true);
-                player3.updateSettings({ 'streaming': { 'liveDelay': 8 }});
-
-                video = document.querySelector("#video4");
-                player4 = dashjs.MediaPlayer().create();
-                player4.initialize(video,MPD_6S_SEGMENTS ,true);
-                player4.updateSettings({ 'streaming': { 'liveDelay': 6 }});
-
-                video = document.querySelector("#video5");
-                player5 = dashjs.MediaPlayer().create();
-                player5.initialize(video,MPD_6S_SEGMENTS ,true);
-                player5.updateSettings({ 'streaming': { 'liveDelay': 12 }});
-
-                video = document.querySelector("#video6");
-                player6 = dashjs.MediaPlayer().create();
-                player6.initialize(video,MPD_6S_SEGMENTS ,true);
-                player6.updateSettings({ 'streaming': { 'liveDelay': 24 }});
-
-
-                setInterval( function() {
-                    var d = new Date();
-                    var seconds = d.getSeconds();
-                    document.querySelector("#sec").innerHTML = ( seconds < 10 ? "0" : "" ) + seconds;
-                    var minutes = d.getMinutes();
-                    document.querySelector("#min").innerHTML = ( minutes < 10 ? "0" : "" ) + minutes;
-                    for (var i=1;i < 7;i++)
-                    {
-                        var p = eval("player"+i);
-                        document.querySelector("#video" + i + "delay").innerHTML = Math.round((d.getTime()/1000) - Number(p.timeAsUTC()));
-                        document.querySelector("#video" + i + "buffer").innerHTML = p.getBufferLength()+ "s";
-                    }
-
-
-                },1000);
-
-            }
-        </script>
-        <style>
-
-            table {
-                border-spacing: 10px;
-            }
-            video {
-                width: 320px;
-                height: 180px;
-            }
-            .clock { border:1px solid #333; color:#000; font-size: 60pt}
-        </style>
-    </head>
-
-    <body>
-    This sample illustrates the combined effects of segment duration and the "<strong>setLiveDelay</strong>" MediaPlayer method on the latency of live stream playback.
-    The upper layer of videos are all playing a live stream with 2s segment duration, with setLiveDelay values of 2s, 4s, and 8s. The lower layer use 6s segment duration,
-    with setLiveDelay values of 6s, 12s, and 24s. Lowest latency is achieved with shorter segments and with a lower live delay value. Higher stability/robustness is achieved with a higher live delay which allows a larger forward buffer.
-    <table>
-            <tr><td>
-                2s segment, 2s target latency<br/>
-                <video id="video1" controls="true">
-                </video><br/>
-                Seconds behind live: <span id="video1delay"></span><br/>
-                Buffer length: <span id="video1buffer"></span>
-                </td><td>
-                2s segment, 4s target latency<br/>
-                <video id="video2" controls="true">
-                </video><br/>
-                Seconds behind live: <span id="video2delay"></span><br/>
-                Buffer length: <span id="video2buffer"></span>
-                </td><td>
-                2s segment,  8s target latency<br/>
-                <video id="video3" controls="true">
-                </video><br/>
-                Seconds behind live: <span id="video3delay"></span><br/>
-                Buffer length: <span id="video3buffer"></span>
-                </td>
-                <td>Wall clock time
-                    <div class="clock">
-                        <span id="min"> </span>:<span id="sec"></span>
-                    </div>
-                </td></tr>
-            <tr><td>
-                6s segment,  6s target latency<br/>
-                <video id="video4" controls="true">
-                </video><br/>
-                Seconds behind live: <span id="video4delay"></span><br/>
-                Buffer length: <span id="video4buffer"></span>
-                </td><td>
-                6s segment,  12s target latency<br/>
-                <video id="video5" controls="true">
-                </video><br/>
-                Seconds behind live: <span id="video5delay"></span><br/>
-                Buffer length: <span id="video5buffer"></span>
-                </td><td>
-                6s segment,  24s target latency<br/>
-                <video id="video6" controls="true">
-                </video><br/>
-                Seconds behind live: <span id="video6delay"></span><br/>
-                Buffer length: <span id="video6buffer"></span>
-                </td></tr>
-        </table>
-        <script>
-            document.addEventListener("DOMContentLoaded", function () {
-                init();
-            });
-        </script>
-    </body>
+    <!--<script src="../../dist/dash.all.min.js"></script>-->
+
+    <script>
+        function init() {
+            var player1, player2, player3, player4, player5, player6, video;
+            var MPD_2S_SEGMENTS = 'https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd';
+            var MPD_6S_SEGMENTS = 'https://livesim.dashif.org/livesim/testpic_6s/Manifest.mpd';
+
+
+            video = document.querySelector('#video1');
+            player1 = dashjs.MediaPlayer().create();
+            player1.initialize(video, MPD_2S_SEGMENTS, true);
+            player1.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 2 } } });
+
+            video = document.querySelector('#video2');
+            player2 = dashjs.MediaPlayer().create();
+            player2.initialize(video, MPD_2S_SEGMENTS, true);
+            player2.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 4 } } });
+
+            video = document.querySelector('#video3');
+            player3 = dashjs.MediaPlayer().create();
+            player3.initialize(video, MPD_2S_SEGMENTS, true);
+            player3.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 8 } } });
+
+            video = document.querySelector('#video4');
+            player4 = dashjs.MediaPlayer().create();
+            player4.initialize(video, MPD_6S_SEGMENTS, true);
+            player4.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 6 } } });
+
+            video = document.querySelector('#video5');
+            player5 = dashjs.MediaPlayer().create();
+            player5.initialize(video, MPD_6S_SEGMENTS, true);
+            player5.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 12 } } });
+
+            video = document.querySelector('#video6');
+            player6 = dashjs.MediaPlayer().create();
+            player6.initialize(video, MPD_6S_SEGMENTS, true);
+            player6.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 24 } } });
+
+
+            setInterval(function () {
+                var d = new Date();
+                var seconds = d.getSeconds();
+                document.querySelector('#sec').innerHTML = (seconds < 10 ? '0' : '') + seconds;
+                var minutes = d.getMinutes();
+                document.querySelector('#min').innerHTML = (minutes < 10 ? '0' : '') + minutes;
+                for (var i = 1; i < 7; i++) {
+                    var p = eval('player' + i);
+                    document.querySelector('#video' + i + 'delay').innerHTML = Math.round((d.getTime() / 1000) - Number(p.timeAsUTC()));
+                    document.querySelector('#video' + i + 'buffer').innerHTML = p.getBufferLength() + 's';
+                }
+
+
+            }, 1000);
+
+        }
+    </script>
+    <style>
+
+        table {
+            border-spacing: 10px;
+        }
+
+        video {
+            width: 320px;
+            height: 180px;
+        }
+
+        .clock {
+            border: 1px solid #333;
+            color: #000;
+            font-size: 60pt
+        }
+    </style>
+</head>
+
+<body>
+This sample illustrates the combined effects of segment duration and the "<strong>setLiveDelay</strong>" MediaPlayer
+method on the latency of live stream playback.
+The upper layer of videos are all playing a live stream with 2s segment duration, with setLiveDelay values of 2s, 4s,
+and 8s. The lower layer use 6s segment duration,
+with setLiveDelay values of 6s, 12s, and 24s. Lowest latency is achieved with shorter segments and with a lower live
+delay value. Higher stability/robustness is achieved with a higher live delay which allows a larger forward buffer.
+<table>
+    <tr>
+        <td>
+            2s segment, 2s target latency<br/>
+            <video id="video1" controls="true">
+            </video>
+            <br/>
+            Seconds behind live: <span id="video1delay"></span><br/>
+            Buffer length: <span id="video1buffer"></span>
+        </td>
+        <td>
+            2s segment, 4s target latency<br/>
+            <video id="video2" controls="true">
+            </video>
+            <br/>
+            Seconds behind live: <span id="video2delay"></span><br/>
+            Buffer length: <span id="video2buffer"></span>
+        </td>
+        <td>
+            2s segment, 8s target latency<br/>
+            <video id="video3" controls="true">
+            </video>
+            <br/>
+            Seconds behind live: <span id="video3delay"></span><br/>
+            Buffer length: <span id="video3buffer"></span>
+        </td>
+        <td>Wall clock time
+            <div class="clock">
+                <span id="min"> </span>:<span id="sec"></span>
+            </div>
+        </td>
+    </tr>
+    <tr>
+        <td>
+            6s segment, 6s target latency<br/>
+            <video id="video4" controls="true">
+            </video>
+            <br/>
+            Seconds behind live: <span id="video4delay"></span><br/>
+            Buffer length: <span id="video4buffer"></span>
+        </td>
+        <td>
+            6s segment, 12s target latency<br/>
+            <video id="video5" controls="true">
+            </video>
+            <br/>
+            Seconds behind live: <span id="video5delay"></span><br/>
+            Buffer length: <span id="video5buffer"></span>
+        </td>
+        <td>
+            6s segment, 24s target latency<br/>
+            <video id="video6" controls="true">
+            </video>
+            <br/>
+            Seconds behind live: <span id="video6delay"></span><br/>
+            Buffer length: <span id="video6buffer"></span>
+        </td>
+    </tr>
+</table>
+<script>
+    document.addEventListener('DOMContentLoaded', function () {
+        init();
+    });
+</script>
+</body>
 </html>
 
diff --git a/samples/live-streaming/synchronized-live-playback.html b/samples/live-streaming/synchronized-live-playback.html
index 0c3bc52195..da3f19d6f1 100644
--- a/samples/live-streaming/synchronized-live-playback.html
+++ b/samples/live-streaming/synchronized-live-playback.html
@@ -15,7 +15,9 @@
             var MPD_2S_SEGMENTS = "https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd";
             var settings = {
                 streaming: {
-                    liveDelay: 10, 
+                    delay: {
+                        liveDelay: 10
+                    },
                     liveCatchup: {
                         enabled: true
                     }
diff --git a/samples/low-latency/index.html b/samples/low-latency/index.html
index 5563429ac4..f3cf5f2f2e 100644
--- a/samples/low-latency/index.html
+++ b/samples/low-latency/index.html
@@ -34,7 +34,9 @@
 
             player.updateSettings({
                 streaming: {
-                    liveDelay: targetLatency,
+                    delay: {
+                        liveDelay: targetLatency
+                    },
                     liveCatchup: {
                         minDrift: minDrift,
                         playbackRate: catchupPlaybackRate,
diff --git a/samples/low-latency/l2all_index.html b/samples/low-latency/l2all_index.html
index 27657f9b04..b397468d37 100644
--- a/samples/low-latency/l2all_index.html
+++ b/samples/low-latency/l2all_index.html
@@ -42,7 +42,9 @@
 
             player.updateSettings({
                 streaming: {
-                    liveDelay: targetLatency,
+                    delay: {
+                        liveDelay: targetLatency
+                    },
                     liveCatchup: {
                         minDrift: minDrift,
                         playbackRate: catchupPlaybackRate,
diff --git a/samples/low-latency/lolp_index.html b/samples/low-latency/lolp_index.html
index bb8c4acf41..471f7a4a79 100644
--- a/samples/low-latency/lolp_index.html
+++ b/samples/low-latency/lolp_index.html
@@ -22,7 +22,9 @@
                     logLevel: dashjs.Debug.LOG_LEVEL_WARNING
                 },
                 streaming: {
-                    stallThreshold: 0.05,
+                    buffer: {
+                        stallThreshold: 0.05,
+                    },
                     lowLatencyEnabled: true,
                     abr: {
                         useDefaultABRRules: true,
@@ -46,7 +48,9 @@
 
             player.updateSettings({
                 streaming: {
-                    liveDelay: targetLatency,
+                    delay: {
+                        liveDelay: targetLatency
+                    },
                     liveCatchup: {
                         minDrift: minDrift,
                         playbackRate: catchupPlaybackRate
diff --git a/samples/offline/app/main.js b/samples/offline/app/main.js
index fca8dbae79..c0958f4f62 100644
--- a/samples/offline/app/main.js
+++ b/samples/offline/app/main.js
@@ -273,8 +273,12 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
                     'logLevel': dashjs.Debug.LOG_LEVEL_INFO
                 },
                 'streaming': {
-                    'fastSwitchEnabled': $scope.fastSwitchSelected,
-                    'jumpGaps': true,
+                    'buffer': {
+                        'fastSwitchEnabled': $scope.fastSwitchSelected
+                    },
+                    'gaps:': {
+                        'jumpGaps': true,
+                    },
                     'abr': {
                         'autoSwitchBitrate': {
                             'video': $scope.videoAutoSwitchSelected
@@ -349,14 +353,14 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
 
     // get buffer default value
     var currentConfig = $scope.player.getSettings();
-    $scope.defaultLiveDelay = currentConfig.streaming.liveDelay;
-    $scope.defaultStableBufferDelay = currentConfig.streaming.stableBufferTime;
-    $scope.defaultBufferTimeAtTopQuality = currentConfig.streaming.bufferTimeAtTopQuality;
-    $scope.defaultBufferTimeAtTopQualityLongForm = currentConfig.streaming.bufferTimeAtTopQualityLongForm;
+    $scope.defaultLiveDelay = currentConfig.streaming.delay.liveDelay;
+    $scope.defaultStableBufferDelay = currentConfig.streaming.buffer.stableBufferTime;
+    $scope.defaultBufferTimeAtTopQuality = currentConfig.streaming.buffer.bufferTimeAtTopQuality;
+    $scope.defaultBufferTimeAtTopQualityLongForm = currentConfig.streaming.buffer.bufferTimeAtTopQualityLongForm;
     $scope.lowLatencyModeSelected = currentConfig.streaming.lowLatencyEnabled;
 
-    var initVideoTrackSwitchMode = $scope.player.getTrackSwitchModeFor('video');
-    var initAudioTrackSwitchMode = $scope.player.getTrackSwitchModeFor('audio');
+    var initVideoTrackSwitchMode = currentConfig.streaming.trackSwitchMode.video;
+    var initAudioTrackSwitchMode = currentConfig.streaming.trackSwitchMode.audio;
 
     //get default track switch mode
     if (initVideoTrackSwitchMode === 'alwaysReplace') {
@@ -496,7 +500,9 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
     $scope.toggleFastSwitch = function () {
         $scope.player.updateSettings({
             'streaming': {
-                'fastSwitchEnabled': $scope.fastSwitchSelected
+                'buffer': {
+                    'fastSwitchEnabled': $scope.fastSwitchSelected
+                },
             }
         });
     };
@@ -516,7 +522,9 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
     $scope.toggleScheduleWhilePaused = function () {
         $scope.player.updateSettings({
             'streaming': {
-                'scheduleWhilePaused': $scope.scheduleWhilePausedSelected
+                'scheduling': {
+                    'scheduleWhilePaused': $scope.scheduleWhilePausedSelected
+                }
             }
         });
     };
@@ -537,7 +545,9 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
     $scope.toggleJumpGaps = function () {
         $scope.player.updateSettings({
             'streaming': {
-                'jumpGaps': $scope.jumpGapsSelected
+                'gaps': {
+                    'jumpGaps': $scope.jumpGapsSelected
+                }
             }
         });
     };
@@ -589,12 +599,16 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
         }
 
         var config = {
-            'streaming': {
-                'liveDelay': $scope.defaultLiveDelay,
-                'stableBufferTime': $scope.defaultStableBufferDelay,
-                'bufferTimeAtTopQuality': $scope.defaultBufferTimeAtTopQuality,
-                'bufferTimeAtTopQualityLongForm': $scope.defaultBufferTimeAtTopQualityLongForm,
-                'lowLatencyEnabled': $scope.lowLatencyModeSelected
+            streaming: {
+                delay: {
+                    liveDelay: $scope.defaultLiveDelay
+                },
+                buffer: {
+                    stableBufferTime: $scope.defaultStableBufferDelay,
+                    bufferTimeAtTopQuality: $scope.defaultBufferTimeAtTopQuality,
+                    bufferTimeAtTopQualityLongForm: $scope.defaultBufferTimeAtTopQualityLongForm,
+                },
+                lowLatencyEnabled: $scope.lowLatencyModeSelected
             }
         };
 
@@ -602,19 +616,19 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
             var selectedConfig = $scope.selectedItem.bufferConfig;
 
             if (selectedConfig.liveDelay) {
-                config.streaming.liveDelay = selectedConfig.liveDelay;
+                config.streaming.delay.liveDelay = selectedConfig.liveDelay;
             }
 
             if (selectedConfig.stableBufferTime) {
-                config.streaming.stableBufferTime = selectedConfig.stableBufferTime;
+                config.streaming.buffer.stableBufferTime = selectedConfig.stableBufferTime;
             }
 
             if (selectedConfig.bufferTimeAtTopQuality) {
-                config.streaming.bufferTimeAtTopQuality = selectedConfig.bufferTimeAtTopQuality;
+                config.streaming.buffer.bufferTimeAtTopQuality = selectedConfig.bufferTimeAtTopQuality;
             }
 
             if (selectedConfig.bufferTimeAtTopQualityLongForm) {
-                config.streaming.bufferTimeAtTopQualityLongForm = selectedConfig.bufferTimeAtTopQualityLongForm;
+                config.streaming.buffer.bufferTimeAtTopQualityLongForm = selectedConfig.bufferTimeAtTopQualityLongForm;
             }
 
             if (selectedConfig.lowLatencyMode !== undefined) {
@@ -990,7 +1004,8 @@ app.controller('DashController', function ($scope, $timeout, $q, sources, contri
         if (vars && vars.hasOwnProperty('stream')) {
             try {
                 item = JSON.parse(atob(vars.stream));
-            } catch (e) { }
+            } catch (e) {
+            }
         }
 
 
diff --git a/src/core/Settings.js b/src/core/Settings.js
index cc83ae1e86..81a7c8d5f1 100644
--- a/src/core/Settings.js
+++ b/src/core/Settings.js
@@ -83,6 +83,7 @@ import {HTTPRequest} from '../streaming/vo/metrics/HTTPRequest';
  *          stallThreshold: 0.5,
  *          filterUnsupportedEssentialProperties: true,
  *          eventControllerRefreshDelay: 100,
+ *          cacheInitSegments: true,
  *          utcSynchronization: {
  *              backgroundAttempts: 2,
  *              timeBetweenSyncAttempts: 30,
@@ -310,7 +311,7 @@ import {HTTPRequest} from '../streaming/vo/metrics/HTTPRequest';
  * Known issues:
  * 1. In IE11 with auto switching off, if a user switches to a quality they can not download in time the fragment may be appended in the same range as the playhead or even in the past, in IE11 it may cause a stutter or stall in playback.
  * @property {boolean} [flushBufferAtTrackSwitch=false]
- * When enabled, after a track switch and in case buffer is being replaced (see MediaPlayer.setTrackSwitchModeFor(Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE)), the video element is flushed (seek at current playback time) once a segment of the new track is appended in buffer in order to force video decoder to play new track.
+ * When enabled, after a track switch and in case buffer is being replaced, the video element is flushed (seek at current playback time) once a segment of the new track is appended in buffer in order to force video decoder to play new track.
  *
  * This can be required on some devices like GoogleCast devices to make track switching functional.
  *
@@ -368,6 +369,8 @@ import {HTTPRequest} from '../streaming/vo/metrics/HTTPRequest';
  * Stall threshold used in BufferController.js to determine whether a track should still be changed and which buffer range to prune.
  * @property {boolean} [filterUnsupportedEssentialProperties=true]
  * Enable to filter all the AdaptationSets and Representations which contain an unsupported \<EssentialProperty\> element.
+ * @property {boolean} [cacheInitSegments=true]
+ * Enables the caching of init segments to avoid requesting the init segments before each representation switch.
  * @property {number} [eventControllerRefreshDelay=100]
  * Defines the delay in milliseconds between two consecutive checks for events to be fired.
  * @property {module:Settings~UtcSynchronizationSettings} utcSynchronization Settings related to UTC clock synchronization
@@ -615,34 +618,43 @@ function Settings() {
             dispatchEvent: false
         },
         streaming: {
-            metricsMaxListDepth: 1000,
+            metricsMaxListDepth: 500,
             abandonLoadTimeout: 10000,
-            liveDelayFragmentCount: NaN,
-            liveDelay: null,
-            scheduleWhilePaused: true,
-            fastSwitchEnabled: false,
-            flushBufferAtTrackSwitch: false,
             calcSegmentAvailabilityRangeFromTimeline: false,
-            reuseExistingSourceBuffers: true,
-            bufferPruningInterval: 10,
-            bufferToKeep: 20,
-            jumpGaps: true,
-            jumpLargeGaps: true,
-            smallGapLimit: 1.5,
-            stableBufferTime: 12,
-            bufferTimeAtTopQuality: 30,
-            bufferTimeAtTopQualityLongForm: 60,
-            longFormContentDurationThreshold: 600,
-            wallclockTimeUpdateInterval: 50,
+            wallclockTimeUpdateInterval: 100,
             lowLatencyEnabled: false,
-            keepProtectionMediaKeys: false,
             useManifestDateHeaderTimeSource: true,
-            useSuggestedPresentationDelay: true,
-            useAppendWindow: true,
             manifestUpdateRetryInterval: 100,
-            stallThreshold: 0.5,
             filterUnsupportedEssentialProperties: true,
+            cacheInitSegments: true,
             eventControllerRefreshDelay: 100,
+            delay: {
+                liveDelayFragmentCount: NaN,
+                liveDelay: NaN,
+                useSuggestedPresentationDelay: true,
+            },
+            protection: {
+                keepProtectionMediaKeys: false
+            },
+            buffer: {
+                fastSwitchEnabled: true,
+                flushBufferAtTrackSwitch: false,
+                reuseExistingSourceBuffers: true,
+                bufferPruningInterval: 10,
+                bufferToKeep: 20,
+                bufferTimeAtTopQuality: 30,
+                bufferTimeAtTopQualityLongForm: 60,
+                initialBufferLevel: NaN,
+                stableBufferTime: 12,
+                longFormContentDurationThreshold: 600,
+                stallThreshold: 0.5,
+                useAppendWindow: true
+            },
+            gaps: {
+                jumpGaps: true,
+                jumpLargeGaps: true,
+                smallGapLimit: 1.5,
+            },
             utcSynchronization: {
                 backgroundAttempts: 2,
                 timeBetweenSyncAttempts: 30,
@@ -656,6 +668,14 @@ function Settings() {
                     value: 'http://time.akamai.com/?iso&ms'
                 }
             },
+            scheduling: {
+                defaultTimeout: 300,
+                lowLatencyTimeout: 100,
+                scheduleWhilePaused: true
+            },
+            text: {
+                defaultEnabled: true
+            },
             liveCatchup: {
                 minDrift: 0.02,
                 maxDrift: 0,
diff --git a/src/core/events/CoreEvents.js b/src/core/events/CoreEvents.js
index 2579f06f80..f5d1ac80ac 100644
--- a/src/core/events/CoreEvents.js
+++ b/src/core/events/CoreEvents.js
@@ -43,18 +43,17 @@ class CoreEvents extends EventsBase {
         this.ATTEMPT_BACKGROUND_SYNC = 'attemptBackgroundSync';
         this.BUFFERING_COMPLETED = 'bufferingCompleted';
         this.BUFFER_CLEARED = 'bufferCleared';
-        this.BUFFER_LEVEL_UPDATED = 'bufferLevelUpdated';
-        this.BYTES_APPENDED = 'bytesAppended';
+        this.BYTES_APPENDED_IN_SINK = 'bytesAppendedInSink';
         this.BYTES_APPENDED_END_FRAGMENT = 'bytesAppendedEndFragment';
         this.CHECK_FOR_EXISTENCE_COMPLETED = 'checkForExistenceCompleted';
         this.CURRENT_TRACK_CHANGED = 'currentTrackChanged';
         this.DATA_UPDATE_COMPLETED = 'dataUpdateCompleted';
-        this.DATA_UPDATE_STARTED = 'dataUpdateStarted';
         this.INBAND_EVENTS = 'inbandEvents';
-        this.INITIALIZATION_LOADED = 'initializationLoaded';
+        this.INITIAL_STREAM_SWITCH = 'initialStreamSwitch';
         this.INIT_FRAGMENT_LOADED = 'initFragmentLoaded';
         this.INIT_FRAGMENT_NEEDED = 'initFragmentNeeded';
         this.INTERNAL_MANIFEST_LOADED = 'internalManifestLoaded';
+        this.INTERNAL_BUFFER_UPDATED = 'internalBufferUpdated';
         this.ORIGINAL_MANIFEST_LOADED = 'originalManifestLoaded';
         this.LIVE_EDGE_SEARCH_COMPLETED = 'liveEdgeSearchCompleted';
         this.LOADING_COMPLETED = 'loadingCompleted';
@@ -65,24 +64,23 @@ class CoreEvents extends EventsBase {
         this.MEDIA_FRAGMENT_LOADED = 'mediaFragmentLoaded';
         this.MEDIA_FRAGMENT_NEEDED = 'mediaFragmentNeeded';
         this.QUOTA_EXCEEDED = 'quotaExceeded';
-        this.REPRESENTATION_UPDATE_STARTED = 'representationUpdateStarted';
-        this.REPRESENTATION_UPDATE_COMPLETED = 'representationUpdateCompleted';
         this.SEGMENTS_LOADED = 'segmentsLoaded';
         this.SERVICE_LOCATION_BLACKLIST_ADD = 'serviceLocationBlacklistAdd';
         this.SERVICE_LOCATION_BLACKLIST_CHANGED = 'serviceLocationBlacklistChanged';
-        this.SOURCEBUFFER_REMOVE_COMPLETED = 'sourceBufferRemoveCompleted';
+        this.SET_FRAGMENTED_TEXT_AFTER_DISABLED = 'setFragmentedTextAfterDisabled';
+        this.SET_NON_FRAGMENTED_TEXT = 'setNonFragmentedText';
         this.STREAMS_COMPOSED = 'streamsComposed';
         this.STREAM_BUFFERING_COMPLETED = 'streamBufferingCompleted';
-        this.STREAM_COMPLETED = 'streamCompleted';
+        this.STREAM_REQUESTING_COMPLETED = 'streamRequestingCompleted';
         this.TEXT_TRACKS_QUEUE_INITIALIZED = 'textTracksQueueInitialized';
         this.TIME_SYNCHRONIZATION_COMPLETED = 'timeSynchronizationComplete';
+        this.TRACK_REPLACEMENT_STARTED = 'trackReplacementStarted';
         this.UPDATE_TIME_SYNC_OFFSET = 'updateTimeSyncOffset';
         this.URL_RESOLUTION_FAILED = 'urlResolutionFailed';
         this.VIDEO_CHUNK_RECEIVED = 'videoChunkReceived';
         this.WALLCLOCK_TIME_UPDATED = 'wallclockTimeUpdated';
         this.XLINK_ELEMENT_LOADED = 'xlinkElementLoaded';
         this.XLINK_READY = 'xlinkReady';
-        this.SEGMENTBASE_INIT_REQUEST_NEEDED = 'segmentBaseInitRequestNeeded';
         this.SEGMENTBASE_SEGMENTSLIST_REQUEST_NEEDED = 'segmentBaseSegmentsListRequestNeeded';
         this.SEEK_TARGET = 'seekTarget';
     }
diff --git a/src/dash/DashAdapter.js b/src/dash/DashAdapter.js
index e06cbedf87..7987b8cf3d 100644
--- a/src/dash/DashAdapter.js
+++ b/src/dash/DashAdapter.js
@@ -48,7 +48,6 @@ function DashAdapter() {
         dashManifestModel,
         patchManifestModel,
         voPeriods,
-        voAdaptations,
         currentMediaInfo,
         constants,
         cea608parser;
@@ -65,10 +64,6 @@ function DashAdapter() {
 
     // #region PUBLIC FUNCTIONS
     // --------------------------------------------------
-    function getVoAdaptations() {
-        return voAdaptations;
-    }
-
     function getVoPeriods() {
         return voPeriods;
     }
@@ -110,7 +105,6 @@ function DashAdapter() {
             representationInfo.id = voRepresentation.id;
             representationInfo.quality = voRepresentation.index;
             representationInfo.bandwidth = dashManifestModel.getBandwidth(realRepresentation);
-            representationInfo.DVRWindow = voRepresentation.segmentAvailabilityRange;
             representationInfo.fragmentDuration = voRepresentation.segmentDuration || (voRepresentation.segments && voRepresentation.segments.length > 0 ? voRepresentation.segments[0].duration : NaN);
             representationInfo.MSETimeOffset = voRepresentation.MSETimeOffset;
             representationInfo.mediaInfo = convertAdaptationToMediaInfo(voRepresentation.adaptation);
@@ -137,14 +131,13 @@ function DashAdapter() {
         let selectedVoPeriod = getPeriodForStreamInfo(streamInfo, voPeriods);
         if (!selectedVoPeriod) return null;
 
-        let periodId = selectedVoPeriod.id;
-        voAdaptations[periodId] = voAdaptations[periodId] || dashManifestModel.getAdaptationsForPeriod(selectedVoPeriod);
+        const voAdaptations = dashManifestModel.getAdaptationsForPeriod(selectedVoPeriod);
 
         let realAdaptation = getAdaptationForType(streamInfo.index, type, streamInfo);
         if (!realAdaptation) return null;
         let idx = dashManifestModel.getIndexForAdaptation(realAdaptation, voPeriods[0].mpd.manifest, streamInfo.index);
 
-        return convertAdaptationToMediaInfo(voAdaptations[periodId][idx]);
+        return convertAdaptationToMediaInfo(voAdaptations[idx]);
     }
 
     /**
@@ -257,12 +250,12 @@ function DashAdapter() {
 
         if (!adaptationsForType || adaptationsForType.length === 0) return mediaArr;
 
-        voAdaptations[periodId] = voAdaptations[periodId] || dashManifestModel.getAdaptationsForPeriod(selectedVoPeriod);
+        const voAdaptations = dashManifestModel.getAdaptationsForPeriod(selectedVoPeriod);
 
         for (i = 0, ln = adaptationsForType.length; i < ln; i++) {
             data = adaptationsForType[i];
             idx = dashManifestModel.getIndexForAdaptation(data, manifest, streamInfo.index);
-            media = convertAdaptationToMediaInfo(voAdaptations[periodId][idx]);
+            media = convertAdaptationToMediaInfo(voAdaptations[idx]);
 
             if (type === constants.EMBEDDED_TEXT) {
                 let accessibilityLength = media.accessibility.length;
@@ -277,7 +270,7 @@ function DashAdapter() {
                         if (parts[0].substring(0, 2) === 'CC') {
                             for (j = 0; j < parts.length; j++) {
                                 if (!media) {
-                                    media = convertAdaptationToMediaInfo.call(this, voAdaptations[periodId][idx]);
+                                    media = convertAdaptationToMediaInfo.call(this, voAdaptations[idx]);
                                 }
                                 convertVideoInfoToEmbeddedTextInfo(media, parts[j].substring(0, 3), parts[j].substring(4));
                                 mediaArr.push(media);
@@ -286,7 +279,7 @@ function DashAdapter() {
                         } else {
                             for (j = 0; j < parts.length; j++) { // Only languages for CC1, CC2, ...
                                 if (!media) {
-                                    media = convertAdaptationToMediaInfo.call(this, voAdaptations[periodId][idx]);
+                                    media = convertAdaptationToMediaInfo.call(this, voAdaptations[idx]);
                                 }
                                 convertVideoInfoToEmbeddedTextInfo(media, 'CC' + (j + 1), parts[j]);
                                 mediaArr.push(media);
@@ -324,8 +317,6 @@ function DashAdapter() {
         checkConfig();
 
         voPeriods = getRegularPeriods(newManifest);
-
-        voAdaptations = {};
     }
 
     /**
@@ -806,7 +797,6 @@ function DashAdapter() {
 
     function reset() {
         voPeriods = [];
-        voAdaptations = {};
         currentMediaInfo = {};
     }
 
@@ -849,7 +839,7 @@ function DashAdapter() {
                     return;
                 }
 
-                let {name, target, leaf} = result;
+                let { name, target, leaf } = result;
 
                 // short circuit for attribute selectors
                 if (operation.xpath.findsAttribute()) {
@@ -945,8 +935,15 @@ function DashAdapter() {
     }
 
     function getAdaptationForMediaInfo(mediaInfo) {
-        if (!mediaInfo || !mediaInfo.streamInfo || mediaInfo.streamInfo.id === undefined || !voAdaptations[mediaInfo.streamInfo.id]) return null;
-        return voAdaptations[mediaInfo.streamInfo.id][mediaInfo.index];
+        try {
+            const selectedVoPeriod = getPeriodForStreamInfo(mediaInfo.streamInfo, voPeriods);
+            const voAdaptations = dashManifestModel.getAdaptationsForPeriod(selectedVoPeriod);
+
+            if (!mediaInfo || !mediaInfo.streamInfo || mediaInfo.streamInfo.id === undefined || !voAdaptations) return null;
+            return voAdaptations[mediaInfo.index];
+        } catch (e) {
+            return null;
+        }
     }
 
     function getPeriodForStreamInfo(streamInfo, voPeriodsArray) {
@@ -1017,7 +1014,7 @@ function DashAdapter() {
         }
 
         mediaInfo.isText = dashManifestModel.getIsTextTrack(mediaInfo.mimeType);
-        mediaInfo.supplementalProperties = dashManifestModel.getSupplementalPropperties(realAdaptation);
+        mediaInfo.supplementalProperties = dashManifestModel.getSupplementalProperties(realAdaptation);
 
         return mediaInfo;
     }
@@ -1170,7 +1167,6 @@ function DashAdapter() {
         getBaseURLsFromElement: getBaseURLsFromElement,
         getRepresentationSortFunction: getRepresentationSortFunction,
         getCodec: getCodec,
-        getVoAdaptations: getVoAdaptations,
         getVoPeriods: getVoPeriods,
         getPeriodById,
         setCurrentMediaInfo: setCurrentMediaInfo,
diff --git a/src/dash/DashHandler.js b/src/dash/DashHandler.js
index 17750a2d53..9c4797c80e 100644
--- a/src/dash/DashHandler.js
+++ b/src/dash/DashHandler.js
@@ -31,30 +31,26 @@
 import FragmentRequest from '../streaming/vo/FragmentRequest';
 import {HTTPRequest} from '../streaming/vo/metrics/HTTPRequest';
 import FactoryMaker from '../core/FactoryMaker';
+import MediaPlayerEvents from '../streaming/MediaPlayerEvents';
 import {
     replaceIDForTemplate,
-    unescapeDollarsInTemplate,
     replaceTokenForTemplate,
-    getTimeBasedSegment
+    unescapeDollarsInTemplate
 } from './utils/SegmentsUtils';
 
-import SegmentsController from './controllers/SegmentsController';
 
 function DashHandler(config) {
 
     config = config || {};
-    const context = this.context;
 
     const eventBus = config.eventBus;
-    const events = config.events;
     const debug = config.debug;
-    const dashConstants = config.dashConstants;
     const urlUtils = config.urlUtils;
     const type = config.type;
     const streamInfo = config.streamInfo;
+    const segmentsController = config.segmentsController;
 
     const timelineConverter = config.timelineConverter;
-    const dashMetrics = config.dashMetrics;
     const baseURLController = config.baseURLController;
 
     let instance,
@@ -63,20 +59,13 @@ function DashHandler(config) {
         lastSegment,
         requestedTime,
         isDynamicManifest,
-        dynamicStreamCompleted,
-        selectedMimeType,
-        segmentsController;
+        dynamicStreamCompleted;
 
     function setup() {
         logger = debug.getLogger(instance);
         resetInitialSettings();
 
-        segmentsController = SegmentsController(context).create(config);
-
-        eventBus.on(events.INITIALIZATION_LOADED, onInitializationLoaded, instance);
-        eventBus.on(events.SEGMENTS_LOADED, onSegmentsLoaded, instance);
-        eventBus.on(events.REPRESENTATION_UPDATE_STARTED, onRepresentationUpdateStarted, instance);
-        eventBus.on(events.DYNAMIC_TO_STATIC, onDynamicToStatic, instance);
+        eventBus.on(MediaPlayerEvents.DYNAMIC_TO_STATIC, onDynamicToStatic, instance);
     }
 
     function initialize(isDynamic) {
@@ -113,17 +102,11 @@ function DashHandler(config) {
     function resetInitialSettings() {
         resetIndex();
         requestedTime = null;
-        segmentsController = null;
-        selectedMimeType = null;
     }
 
     function reset() {
         resetInitialSettings();
-
-        eventBus.off(events.INITIALIZATION_LOADED, onInitializationLoaded, instance);
-        eventBus.off(events.SEGMENTS_LOADED, onSegmentsLoaded, instance);
-        eventBus.off(events.REPRESENTATION_UPDATE_STARTED, onRepresentationUpdateStarted, instance);
-        eventBus.off(events.DYNAMIC_TO_STATIC, onDynamicToStatic, instance);
+        eventBus.off(MediaPlayerEvents.DYNAMIC_TO_STATIC, onDynamicToStatic, instance);
     }
 
     function setRequestUrl(request, destination, representation) {
@@ -152,7 +135,12 @@ function DashHandler(config) {
         return true;
     }
 
-    function generateInitRequest(mediaInfo, representation, mediaType) {
+    function getInitRequest(mediaInfo, representation) {
+        if (!representation) return null;
+        return _generateInitRequest(mediaInfo, representation, getType());
+    }
+
+    function _generateInitRequest(mediaInfo, representation, mediaType) {
         const request = new FragmentRequest();
         const period = representation.adaptation.period;
         const presentationStartTime = period.start;
@@ -160,8 +148,8 @@ function DashHandler(config) {
         request.mediaType = mediaType;
         request.type = HTTPRequest.INIT_SEGMENT_TYPE;
         request.range = representation.range;
-        request.availabilityStartTime = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, period.mpd, isDynamicManifest);
-        request.availabilityEndTime = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationStartTime + period.duration, period.mpd, isDynamicManifest);
+        request.availabilityStartTime = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, representation, isDynamicManifest);
+        request.availabilityEndTime = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationStartTime + period.duration, representation, isDynamicManifest);
         request.quality = representation.index;
         request.mediaInfo = mediaInfo;
         request.representationId = representation.id;
@@ -172,42 +160,7 @@ function DashHandler(config) {
         }
     }
 
-    function getInitRequest(mediaInfo, representation) {
-        if (!representation) return null;
-        const request = generateInitRequest(mediaInfo, representation, getType());
-        return request;
-    }
-
-    function setMimeType(newMimeType) {
-        selectedMimeType = newMimeType;
-    }
-
-    function setExpectedLiveEdge(liveEdge) {
-        timelineConverter.setExpectedLiveEdge(liveEdge);
-        dashMetrics.updateManifestUpdateInfo({presentationStartTime: liveEdge});
-    }
-
-    function onRepresentationUpdateStarted(e) {
-        processRepresentation(e.representation);
-    }
-
-    function processRepresentation(voRepresentation) {
-        const hasInitialization = voRepresentation.hasInitialization();
-        const hasSegments = voRepresentation.hasSegments();
-
-        // If representation has initialization and segments information, REPRESENTATION_UPDATE_COMPLETED can be triggered immediately
-        // otherwise, it means that a request has to be made to get initialization and/or segments informations
-        if (hasInitialization && hasSegments) {
-            eventBus.trigger(events.REPRESENTATION_UPDATE_COMPLETED,
-                { representation: voRepresentation },
-                { streamId: streamInfo.id, mediaType: type }
-            );
-        } else {
-            segmentsController.update(voRepresentation, selectedMimeType, hasInitialization, hasSegments);
-        }
-    }
-
-    function getRequestForSegment(mediaInfo, segment) {
+    function _getRequestForSegment(mediaInfo, segment) {
         if (segment === null || segment === undefined) {
             return null;
         }
@@ -244,40 +197,39 @@ function DashHandler(config) {
         }
     }
 
-    function isMediaFinished(representation) {
+    function isMediaFinished(representation, bufferingTime) {
         let isFinished = false;
 
-        if (!representation) return isFinished;
+        if (!representation || !lastSegment) return isFinished;
 
-        if (!isDynamicManifest) {
-            if (segmentIndex >= representation.availableSegmentsNumber) {
-                isFinished = true;
-            }
-        } else {
-            if (dynamicStreamCompleted) {
-                isFinished = true;
-            } else if (lastSegment) {
-                const time = parseFloat((lastSegment.presentationStartTime - representation.adaptation.period.start).toFixed(5));
-                const endTime = lastSegment.duration > 0 ? time + 1.5 * lastSegment.duration : time;
-                const duration = representation.adaptation.period.duration;
-
-                isFinished = endTime >= duration;
-            }
+        // if the buffer is filled up we are done
+
+        // we are replacing existing stuff.
+        if (lastSegment.presentationStartTime + lastSegment.duration > bufferingTime) {
+            return false;
         }
+
+
+        if (isDynamicManifest && dynamicStreamCompleted) {
+            isFinished = true;
+        } else if (lastSegment) {
+            const time = parseFloat((lastSegment.presentationStartTime - representation.adaptation.period.start).toFixed(5));
+            const endTime = lastSegment.duration > 0 ? time + lastSegment.duration : time;
+            const duration = representation.adaptation.period.duration;
+
+            return isFinite(duration) && endTime >= duration - 0.05;
+        }
+
         return isFinished;
     }
 
-    function getSegmentRequestForTime(mediaInfo, representation, time, options) {
+    function getSegmentRequestForTime(mediaInfo, representation, time) {
         let request = null;
 
         if (!representation || !representation.segmentInfoType) {
             return request;
         }
 
-        const idx = segmentIndex;
-        const keepIdx = options ? options.keepIdx : false;
-        const ignoreIsFinished = (options && options.ignoreIsFinished) ? true : false;
-
         if (requestedTime !== time) { // When playing at live edge with 0 delay we may loop back with same time and index until it is available. Reduces verboseness of logs.
             requestedTime = time;
             logger.debug('Getting the request for time : ' + time);
@@ -288,21 +240,7 @@ function DashHandler(config) {
             segmentIndex = segment.availabilityIdx;
             lastSegment = segment;
             logger.debug('Index for time ' + time + ' is ' + segmentIndex);
-            request = getRequestForSegment(mediaInfo, segment);
-        } else {
-            const finished = !ignoreIsFinished ? isMediaFinished(representation) : false;
-            if (finished) {
-                request = new FragmentRequest();
-                request.action = FragmentRequest.ACTION_COMPLETE;
-                request.index = segmentIndex - 1;
-                request.mediaType = type;
-                request.mediaInfo = mediaInfo;
-                logger.debug('Signal complete in getSegmentRequestForTime');
-            }
-        }
-
-        if (keepIdx && idx >= 0) {
-            segmentIndex = representation.segmentInfoType === dashConstants.SEGMENT_TIMELINE && isDynamicManifest ? segmentIndex : idx;
+            request = _getRequestForSegment(mediaInfo, segment);
         }
 
         return request;
@@ -323,7 +261,7 @@ function DashHandler(config) {
             lastSegment ? lastSegment.mediaStartTime : -1
         );
         if (!segment) return null;
-        request = getRequestForSegment(mediaInfo, segment);
+        request = _getRequestForSegment(mediaInfo, segment);
         return request;
     }
 
@@ -352,7 +290,7 @@ function DashHandler(config) {
             return null;
         } else {
             if (segment) {
-                request = getRequestForSegment(mediaInfo, segment);
+                request = _getRequestForSegment(mediaInfo, segment);
                 segmentIndex = segment.availabilityIdx;
             } else {
                 if (isDynamicManifest) {
@@ -365,16 +303,6 @@ function DashHandler(config) {
 
         if (segment) {
             lastSegment = segment;
-        } else {
-            const finished = isMediaFinished(representation, segment);
-            if (finished) {
-                request = new FragmentRequest();
-                request.action = FragmentRequest.ACTION_COMPLETE;
-                request.index = segmentIndex - 1;
-                request.mediaType = getType();
-                request.mediaInfo = mediaInfo;
-                logger.debug('Signal complete');
-            }
         }
 
         return request;
@@ -384,96 +312,24 @@ function DashHandler(config) {
         return !isFinite(representation.adaptation.period.duration);
     }
 
-    function onInitializationLoaded(e) {
-        const representation = e.representation;
-        if (!representation.segments) return;
-
-        eventBus.trigger(events.REPRESENTATION_UPDATE_COMPLETED,
-            { representation: representation },
-            { streamId: streamInfo.id, mediaType: type }
-        );
-    }
-
-    function onSegmentsLoaded(e) {
-        if (e.error) return;
-
-        const fragments = e.segments;
-        const representation = e.representation;
-        const segments = [];
-        let count = 0;
-
-        let i,
-            len,
-            s,
-            seg;
-
-        for (i = 0, len = fragments ? fragments.length : 0; i < len; i++) {
-            s = fragments[i];
-
-            seg = getTimeBasedSegment(
-                timelineConverter,
-                isDynamicManifest,
-                representation,
-                s.startTime,
-                s.duration,
-                s.timescale,
-                s.media,
-                s.mediaRange,
-                count);
-
-            if (seg) {
-                segments.push(seg);
-                seg = null;
-                count++;
-            }
-        }
-
-        if (segments.length > 0) {
-            representation.segmentAvailabilityRange = {
-                start: segments[0].presentationStartTime,
-                end: segments[segments.length - 1].presentationStartTime
-            };
-            representation.availableSegmentsNumber = segments.length;
-            representation.segments = segments;
-
-            if (isDynamicManifest) {
-                const lastSegment = segments[segments.length - 1];
-                const liveEdge = lastSegment.presentationStartTime - 8;
-                // the last segment is the Expected, not calculated, live edge.
-                setExpectedLiveEdge(liveEdge);
-            }
-        }
-
-        if (!representation.hasInitialization()) {
-            return;
-        }
-
-        eventBus.trigger(events.REPRESENTATION_UPDATE_COMPLETED,
-            { representation: representation },
-            { streamId: streamInfo.id, mediaType: type }
-        );
-    }
-
     function onDynamicToStatic() {
         logger.debug('Dynamic stream complete');
         dynamicStreamCompleted = true;
     }
 
     instance = {
-        initialize: initialize,
-        getStreamId: getStreamId,
-        getType: getType,
-        getStreamInfo: getStreamInfo,
-        getInitRequest: getInitRequest,
-        getRequestForSegment: getRequestForSegment,
-        getSegmentRequestForTime: getSegmentRequestForTime,
-        getNextSegmentRequest: getNextSegmentRequest,
-        setCurrentIndex: setCurrentIndex,
-        getCurrentIndex: getCurrentIndex,
-        isMediaFinished: isMediaFinished,
-        reset: reset,
-        resetIndex: resetIndex,
-        setMimeType: setMimeType,
+        initialize,
+        getStreamId,
+        getType,
+        getStreamInfo,
+        getInitRequest,
+        getSegmentRequestForTime,
+        getNextSegmentRequest,
+        setCurrentIndex,
+        getCurrentIndex,
+        isMediaFinished,
+        reset,
+        resetIndex,
         getNextSegmentRequestIdempotent
     };
 
diff --git a/src/dash/SegmentBaseLoader.js b/src/dash/SegmentBaseLoader.js
index 9668fff815..741410aa94 100644
--- a/src/dash/SegmentBaseLoader.js
+++ b/src/dash/SegmentBaseLoader.js
@@ -131,14 +131,13 @@ function SegmentBaseLoader() {
         }
     }
 
-    function checkConfig() {
-        if (!baseURLController || !baseURLController.hasOwnProperty('resolve')) {
-            throw new Error('setConfig function has to be called previously');
-        }
+    function loadInitialization(representation, mediaType) {
+        return new Promise((resolve) => {
+            _loadInitializationRecursively(representation, mediaType, resolve);
+        });
     }
 
-    function loadInitialization(streamId, mediaType, representation, loadingInfo) {
-        checkConfig();
+    function _loadInitializationRecursively(representation, mediaType, resolve, loadingInfo) {
         let initRange = null;
         const baseUrl = representation ? baseURLController.resolve(representation.path) : null;
         const info = loadingInfo || {
@@ -166,33 +165,32 @@ function SegmentBaseLoader() {
                 representation.range = initRange;
                 // note that we don't explicitly set rep.initialization as this
                 // will be computed when all BaseURLs are resolved later
-                eventBus.trigger(events.INITIALIZATION_LOADED,
-                    { representation: representation },
-                    { streamId: streamId, mediaType: mediaType }
-                );
+                resolve(representation);
             } else {
                 info.range.end = info.bytesLoaded + info.bytesToLoad;
-                loadInitialization(streamId, mediaType, representation, info);
+                return _loadInitializationRecursively(representation, mediaType, resolve, info);
             }
         };
 
         const onerror = function () {
-            eventBus.trigger(events.INITIALIZATION_LOADED,
-                { representation: representation },
-                { streamId: streamId, mediaType: mediaType }
-            );
+            resolve(representation);
         };
 
-        urlLoader.load({request: request, success: onload, error: onerror});
+        urlLoader.load({ request: request, success: onload, error: onerror });
 
         logger.debug('Perform init search: ' + info.url);
     }
 
-    function loadSegments(streamId, mediaType, representation, range, callback, loadingInfo) {
-        checkConfig();
+    function loadSegments(representation, mediaType, range) {
+        return new Promise((resolve) => {
+            _loadSegmentsRecursively(representation, mediaType, range, resolve);
+        });
+    }
+
+    function _loadSegmentsRecursively(representation, mediaType, range, resolve, callback, loadingInfo) {
         if (range && (range.start === undefined || range.end === undefined)) {
             const parts = range ? range.toString().split('-') : null;
-            range = parts ? {start: parseFloat(parts[0]), end: parseFloat(parts[1])} : null;
+            range = parts ? { start: parseFloat(parts[0]), end: parseFloat(parts[1]) } : null;
         }
 
         callback = !callback ? onLoaded : callback;
@@ -226,7 +224,7 @@ function SegmentBaseLoader() {
                     info.range.end = info.range.start + (sidx.size || extraBytes);
                 } else if (loadedLength < info.bytesLoaded) {
                     // if we have reached a search limit or if we have reached the end of the file we have to stop trying to find sidx
-                    callback(streamId, mediaType, null, representation);
+                    callback(null, representation, resolve);
                     return;
                 } else {
                     const lastBox = isoFile.getLastBox();
@@ -238,7 +236,7 @@ function SegmentBaseLoader() {
                         info.range.end += extraBytes;
                     }
                 }
-                loadSegments(streamId, mediaType, representation, info.range, callback, info);
+                _loadSegmentsRecursively(representation, mediaType, info.range, resolve, null, info);
             } else {
                 const ref = sidx.references;
                 let loadMultiSidx,
@@ -256,7 +254,7 @@ function SegmentBaseLoader() {
                     let segs = [];
                     let count = 0;
                     let offset = (sidx.offset || info.range.start) + sidx.size;
-                    const tmpCallback = function (streamId, mediaType, result) {
+                    const tmpCallback = function (result) {
                         if (result) {
                             segs = segs.concat(result);
                             count++;
@@ -266,10 +264,10 @@ function SegmentBaseLoader() {
                                 segs.sort(function (a, b) {
                                     return a.startTime - b.startTime < 0 ? -1 : 0;
                                 });
-                                callback(streamId, mediaType, segs, representation);
+                                callback(segs, representation, resolve);
                             }
                         } else {
-                            callback(streamId, mediaType, null, representation);
+                            callback(null, representation, resolve);
                         }
                     };
 
@@ -277,24 +275,32 @@ function SegmentBaseLoader() {
                         ss = offset;
                         se = offset + ref[j].referenced_size - 1;
                         offset = offset + ref[j].referenced_size;
-                        r = {start: ss, end: se};
-                        loadSegments(streamId, mediaType, representation, r, tmpCallback, info);
+                        r = { start: ss, end: se };
+                        _loadSegmentsRecursively(representation, mediaType, r, resolve, tmpCallback, info);
                     }
 
                 } else {
                     logger.debug('Parsing segments from SIDX. representation ' + mediaType + ' - id: ' + representation.id + ' for range : ' + info.range.start + ' - ' + info.range.end);
                     segments = getSegmentsForSidx(sidx, info);
-                    callback(streamId, mediaType, segments, representation);
+                    callback(segments, representation, resolve);
                 }
             }
         };
 
         const onerror = function () {
-            callback(streamId, mediaType, null, representation);
+            callback(null, representation, resolve);
         };
 
-        urlLoader.load({request: request, success: onload, error: onerror});
-        logger.debug('Perform SIDX load: ' + info.url + ' with range : ' + info.range.start + ' - ' + info.range.end);
+        urlLoader.load({ request: request, success: onload, error: onerror });
+        logger.debug(`Perform SIDX load for type ${mediaType} : ${info.url} with range ${info.range.start} - ${info.range.end}`);
+    }
+
+    function onLoaded(segments, representation, resolve) {
+        resolve({
+            segments: segments,
+            representation: representation,
+            error: segments ? undefined : new DashJSError(errors.SEGMENT_BASE_LOADER_ERROR_CODE, errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE)
+        });
     }
 
     function reset() {
@@ -346,23 +352,12 @@ function SegmentBaseLoader() {
         return request;
     }
 
-    function onLoaded(streamId, mediaType, segments, representation) {
-        eventBus.trigger(events.SEGMENTS_LOADED,
-            {
-                segments: segments,
-                representation: representation,
-                error: segments ? undefined : new DashJSError(errors.SEGMENT_BASE_LOADER_ERROR_CODE, errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE)
-            },
-            { streamId: streamId, mediaType: mediaType }
-        );
-    }
-
     instance = {
-        setConfig: setConfig,
-        initialize: initialize,
-        loadInitialization: loadInitialization,
-        loadSegments: loadSegments,
-        reset: reset
+        setConfig,
+        initialize,
+        loadInitialization,
+        loadSegments,
+        reset
     };
 
     setup();
diff --git a/src/dash/WebmSegmentBaseLoader.js b/src/dash/WebmSegmentBaseLoader.js
index 888912bcd5..18ac29c2bc 100644
--- a/src/dash/WebmSegmentBaseLoader.js
+++ b/src/dash/WebmSegmentBaseLoader.js
@@ -128,14 +128,14 @@ function WebmSegmentBaseLoader() {
         ebmlParser.consumeTagAndSize(WebM.Segment.Cues);
 
         while (ebmlParser.moreData() &&
-            ebmlParser.consumeTagAndSize(WebM.Segment.Cues.CuePoint, true)) {
+        ebmlParser.consumeTagAndSize(WebM.Segment.Cues.CuePoint, true)) {
             cue = {};
 
             cue.CueTime = ebmlParser.parseTag(WebM.Segment.Cues.CuePoint.CueTime);
 
             cue.CueTracks = [];
             while (ebmlParser.moreData() &&
-                ebmlParser.consumeTag(WebM.Segment.Cues.CuePoint.CueTrackPositions, true)) {
+            ebmlParser.consumeTag(WebM.Segment.Cues.CuePoint.CueTrackPositions, true)) {
                 const cueTrackPositionSize = ebmlParser.getMatroskaCodedNum();
                 const startPos = ebmlParser.getPos();
                 cueTrack = {};
@@ -250,11 +250,11 @@ function WebmSegmentBaseLoader() {
 
         // skip over any top level elements to get to the segment info
         while (ebmlParser.moreData() &&
-            !ebmlParser.consumeTagAndSize(WebM.Segment.Info, true)) {
+        !ebmlParser.consumeTagAndSize(WebM.Segment.Info, true)) {
             if (!(ebmlParser.skipOverElement(WebM.Segment.SeekHead, true) ||
-                    ebmlParser.skipOverElement(WebM.Segment.Tracks, true) ||
-                    ebmlParser.skipOverElement(WebM.Segment.Cues, true) ||
-                    ebmlParser.skipOverElement(WebM.Void, true))) {
+                ebmlParser.skipOverElement(WebM.Segment.Tracks, true) ||
+                ebmlParser.skipOverElement(WebM.Segment.Cues, true) ||
+                ebmlParser.skipOverElement(WebM.Void, true))) {
                 throw new Error('no valid top level element found');
             }
         }
@@ -277,7 +277,7 @@ function WebmSegmentBaseLoader() {
         // once we have what we need from segment info, we jump right to the
         // cues
 
-        request = getFragmentRequest(info);
+        request = _getFragmentRequest(info);
 
         const onload = function (response) {
             segments = parseSegments(response, segmentStart, segmentEnd, duration);
@@ -298,113 +298,100 @@ function WebmSegmentBaseLoader() {
         logger.debug('Perform cues load: ' + info.url + ' bytes=' + info.range.start + '-' + info.range.end);
     }
 
-    function checkConfig() {
-        if (!baseURLController || !baseURLController.hasOwnProperty('resolve')) {
-            throw new Error('setConfig function has to be called previously');
-        }
-    }
-
-    function loadInitialization(streamId, mediaType, representation, loadingInfo) {
-        checkConfig();
-        let request = null;
-        let baseUrl = representation ? baseURLController.resolve(representation.path) : null;
-        let initRange = representation ? representation.range.split('-') : null;
-        let info = loadingInfo || {
-            range: {
-                start: initRange ? parseFloat(initRange[0]) : null,
-                end: initRange ? parseFloat(initRange[1]) : null
-            },
-            request: request,
-            url: baseUrl ? baseUrl.url : undefined,
-            init: true,
-            mediaType: mediaType
-        };
-
-        logger.info('Start loading initialization.');
-
-        request = getFragmentRequest(info);
-
-        const onload = function () {
-            // note that we don't explicitly set rep.initialization as this
-            // will be computed when all BaseURLs are resolved later
-            eventBus.trigger(events.INITIALIZATION_LOADED,
-                { representation: representation },
-                { streamId: streamId, mediaType: mediaType }
-            );
-        };
-
-        const onloadend = function () {
-            eventBus.trigger(events.INITIALIZATION_LOADED,
-                { representation: representation },
-                { streamId: streamId, mediaType: mediaType }
-            );
-        };
+    function loadInitialization(representation, mediaType) {
+        return new Promise((resolve) => {
+            let request = null;
+            let baseUrl = representation ? baseURLController.resolve(representation.path) : null;
+            let initRange = representation ? representation.range.split('-') : null;
+            let info = {
+                range: {
+                    start: initRange ? parseFloat(initRange[0]) : null,
+                    end: initRange ? parseFloat(initRange[1]) : null
+                },
+                request: request,
+                url: baseUrl ? baseUrl.url : undefined,
+                init: true,
+                mediaType: mediaType
+            };
+
+            logger.info('Start loading initialization.');
+
+            request = _getFragmentRequest(info);
+
+            const onload = function () {
+                // note that we don't explicitly set rep.initialization as this
+                // will be computed when all BaseURLs are resolved later
+                resolve(representation);
+            };
+
+            const onloadend = function () {
+                resolve(representation);
+            };
+
+            urlLoader.load({
+                request: request,
+                success: onload,
+                error: onloadend
+            });
 
-        urlLoader.load({
-            request: request,
-            success: onload,
-            error: onloadend
+            logger.debug('Perform init load: ' + info.url);
         });
-
-        logger.debug('Perform init load: ' + info.url);
     }
 
-    function loadSegments(streamId, mediaType, representation, theRange, callback) {
-        checkConfig();
-        let request = null;
-        let baseUrl = representation ? baseURLController.resolve(representation.path) : null;
-        let media = baseUrl ? baseUrl.url : undefined;
-        let bytesToLoad = 8192;
-        let info = {
-            bytesLoaded: 0,
-            bytesToLoad: bytesToLoad,
-            range: {
-                start: 0,
-                end: bytesToLoad
-            },
-            request: request,
-            url: media,
-            init: false,
-            mediaType: mediaType
-        };
-
-        callback = !callback ? onLoaded : callback;
-        request = getFragmentRequest(info);
-
-        // first load the header, but preserve the manifest range so we can
-        // load the cues after parsing the header
-        // NOTE: we expect segment info to appear in the first 8192 bytes
-        logger.debug('Parsing ebml header');
-
-        const onload = function (response) {
-            parseEbmlHeader(response, media, theRange, function (segments) {
-                callback(streamId, mediaType, segments, representation);
+    function loadSegments(representation, mediaType, theRange) {
+        return new Promise((resolve) => {
+            let request = null;
+            let baseUrl = representation ? baseURLController.resolve(representation.path) : null;
+            let media = baseUrl ? baseUrl.url : undefined;
+            let bytesToLoad = 8192;
+            let info = {
+                bytesLoaded: 0,
+                bytesToLoad: bytesToLoad,
+                range: {
+                    start: 0,
+                    end: bytesToLoad
+                },
+                request: request,
+                url: media,
+                init: false,
+                mediaType: mediaType
+            };
+
+            request = _getFragmentRequest(info);
+
+            // first load the header, but preserve the manifest range so we can
+            // load the cues after parsing the header
+            // NOTE: we expect segment info to appear in the first 8192 bytes
+            logger.debug('Parsing ebml header');
+
+            const onload = function (response) {
+                parseEbmlHeader(response, media, theRange, function (segments) {
+                    resolve({
+                        segments: segments,
+                        representation: representation,
+                        error: segments ? undefined : new DashJSError(errors.SEGMENT_BASE_LOADER_ERROR_CODE, errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE)
+                    });
+                });
+            };
+
+            const onloadend = function () {
+                resolve({
+                    representation: representation,
+                    error: new DashJSError(errors.SEGMENT_BASE_LOADER_ERROR_CODE, errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE)
+                });
+            };
+
+            urlLoader.load({
+                request: request,
+                success: onload,
+                error: onloadend
             });
-        };
-
-        const onloadend = function () {
-            callback(streamId, mediaType, null, representation);
-        };
-
-        urlLoader.load({
-            request: request,
-            success: onload,
-            error: onloadend
         });
-    }
 
-    function onLoaded(streamId, mediaType, segments, representation) {
-        eventBus.trigger(events.SEGMENTS_LOADED,
-            {
-                segments: segments,
-                representation: representation,
-                error: segments ? undefined : new DashJSError(errors.SEGMENT_BASE_LOADER_ERROR_CODE, errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE)
-            },
-            { streamId: streamId, mediaType: mediaType }
-        );
     }
 
-    function getFragmentRequest(info) {
+
+    function _getFragmentRequest(info) {
         const request = new FragmentRequest();
         request.setInfo(info);
         return request;
@@ -416,11 +403,11 @@ function WebmSegmentBaseLoader() {
     }
 
     instance = {
-        setConfig: setConfig,
-        initialize: initialize,
-        loadInitialization: loadInitialization,
-        loadSegments: loadSegments,
-        reset: reset
+        setConfig,
+        initialize,
+        loadInitialization,
+        loadSegments,
+        reset
     };
 
     setup();
diff --git a/src/dash/controllers/RepresentationController.js b/src/dash/controllers/RepresentationController.js
index 8e4e9257c6..bd535041ea 100644
--- a/src/dash/controllers/RepresentationController.js
+++ b/src/dash/controllers/RepresentationController.js
@@ -29,15 +29,14 @@
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 import Constants from '../../streaming/constants/Constants';
-import DashJSError from '../../streaming/vo/DashJSError';
 import FactoryMaker from '../../core/FactoryMaker';
+import {getTimeBasedSegment} from '../utils/SegmentsUtils';
 
 function RepresentationController(config) {
 
     config = config || {};
     const eventBus = config.eventBus;
     const events = config.events;
-    const errors = config.errors;
     const abrController = config.abrController;
     const dashMetrics = config.dashMetrics;
     const playbackController = config.playbackController;
@@ -45,6 +44,8 @@ function RepresentationController(config) {
     const type = config.type;
     const streamInfo = config.streamInfo;
     const dashConstants = config.dashConstants;
+    const segmentsController = config.segmentsController;
+    const isDynamic = config.isDynamic;
 
     let instance,
         realAdaptation,
@@ -56,8 +57,6 @@ function RepresentationController(config) {
         resetInitialSettings();
 
         eventBus.on(events.QUALITY_CHANGE_REQUESTED, onQualityChanged, instance);
-        eventBus.on(events.REPRESENTATION_UPDATE_COMPLETED, onRepresentationUpdated, instance);
-        eventBus.on(events.WALLCLOCK_TIME_UPDATED, onWallclockTimeUpdated, instance);
         eventBus.on(events.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
     }
 
@@ -95,8 +94,6 @@ function RepresentationController(config) {
 
     function reset() {
         eventBus.off(events.QUALITY_CHANGE_REQUESTED, onQualityChanged, instance);
-        eventBus.off(events.REPRESENTATION_UPDATE_COMPLETED, onRepresentationUpdated, instance);
-        eventBus.off(events.WALLCLOCK_TIME_UPDATED, onWallclockTimeUpdated, instance);
         eventBus.off(events.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
 
         resetInitialSettings();
@@ -105,7 +102,7 @@ function RepresentationController(config) {
     function updateData(newRealAdaptation, availableRepresentations, type, quality) {
         checkConfig();
 
-        startDataUpdate();
+        updating = true;
 
         voAvailableRepresentations = availableRepresentations;
 
@@ -114,10 +111,93 @@ function RepresentationController(config) {
 
         if (type !== Constants.VIDEO && type !== Constants.AUDIO && type !== Constants.FRAGMENTED_TEXT) {
             endDataUpdate();
-            return;
+            return Promise.resolve();
+        }
+
+        const promises = [];
+        for (let i = 0, ln = voAvailableRepresentations.length; i < ln; i++) {
+            const currentRep = voAvailableRepresentations[i];
+            promises.push(_updateRepresentation(currentRep));
         }
 
-        updateAvailabilityWindow(playbackController.getIsDynamic(), true);
+        return Promise.all(promises);
+    }
+
+    function _updateRepresentation(currentRep) {
+        return new Promise((resolve, reject) => {
+            const hasInitialization = currentRep.hasInitialization();
+            const hasSegments = currentRep.hasSegments();
+
+            // If representation has initialization and segments information we are done
+            // otherwise, it means that a request has to be made to get initialization and/or segments information
+            const promises = [];
+
+            promises.push(segmentsController.updateInitData(currentRep, hasInitialization));
+            promises.push(segmentsController.updateSegmentData(currentRep, hasSegments));
+
+            Promise.all(promises)
+                .then((data) => {
+                    if (data[0] && !data[0].error) {
+                        currentRep = _onInitLoaded(currentRep, data[0]);
+                    }
+                    if (data[1] && !data[1].error) {
+                        currentRep = _onSegmentsLoaded(currentRep, data[1]);
+                    }
+                    _onRepresentationUpdated(currentRep);
+                    resolve();
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
+    }
+
+    function _onInitLoaded(representation, e) {
+        if (!e || e.error || !e.representation) {
+            return representation;
+        }
+        return e.representation;
+    }
+
+    function _onSegmentsLoaded(representation, e) {
+        if (!e || e.error) return;
+
+        const fragments = e.segments;
+        const segments = [];
+        let count = 0;
+
+        let i,
+            len,
+            s,
+            seg;
+
+        for (i = 0, len = fragments ? fragments.length : 0; i < len; i++) {
+            s = fragments[i];
+
+            seg = getTimeBasedSegment(
+                timelineConverter,
+                isDynamic,
+                representation,
+                s.startTime,
+                s.duration,
+                s.timescale,
+                s.media,
+                s.mediaRange,
+                count);
+
+            if (seg) {
+                segments.push(seg);
+                seg = null;
+                count++;
+            }
+        }
+
+        if (segments.length > 0) {
+            representation.availableSegmentsNumber = segments.length;
+            representation.segments = segments;
+        }
+
+        return representation;
     }
 
     function addRepresentationSwitch() {
@@ -141,7 +221,7 @@ function RepresentationController(config) {
     function isAllRepresentationsUpdated() {
         for (let i = 0, ln = voAvailableRepresentations.length; i < ln; i++) {
             let segmentInfoType = voAvailableRepresentations[i].segmentInfoType;
-            if (voAvailableRepresentations[i].segmentAvailabilityRange === null || !voAvailableRepresentations[i].hasInitialization() ||
+            if (!voAvailableRepresentations[i].hasInitialization() ||
                 ((segmentInfoType === dashConstants.SEGMENT_BASE || segmentInfoType === dashConstants.BASE_URL) && !voAvailableRepresentations[i].segments)
             ) {
                 return false;
@@ -151,53 +231,6 @@ function RepresentationController(config) {
         return true;
     }
 
-    function setExpectedLiveEdge(liveEdge) {
-        timelineConverter.setExpectedLiveEdge(liveEdge);
-        dashMetrics.updateManifestUpdateInfo({presentationStartTime: liveEdge});
-    }
-
-    function updateRepresentation(representation, isDynamic) {
-        representation.segmentAvailabilityRange = timelineConverter.calcSegmentAvailabilityRange(representation, isDynamic);
-
-        if (representation.segmentAvailabilityRange.end < representation.segmentAvailabilityRange.start) {
-            let error = new DashJSError(errors.SEGMENTS_UNAVAILABLE_ERROR_CODE, errors.SEGMENTS_UNAVAILABLE_ERROR_MESSAGE, {availabilityDelay: representation.segmentAvailabilityRange.start - representation.segmentAvailabilityRange.end});
-            endDataUpdate(error);
-            return;
-        }
-
-        if (isDynamic) {
-            setExpectedLiveEdge(representation.segmentAvailabilityRange.end);
-        }
-    }
-
-    function updateAvailabilityWindow(isDynamic, notifyUpdate) {
-        checkConfig();
-
-        for (let i = 0, ln = voAvailableRepresentations.length; i < ln; i++) {
-            updateRepresentation(voAvailableRepresentations[i], isDynamic);
-            if (notifyUpdate) {
-                eventBus.trigger(events.REPRESENTATION_UPDATE_STARTED,
-                    { representation: voAvailableRepresentations[i] },
-                    { streamId: streamInfo.id, mediaType: type }
-                );
-            }
-        }
-    }
-
-    function resetAvailabilityWindow() {
-        voAvailableRepresentations.forEach(rep => {
-            rep.segmentAvailabilityRange = null;
-        });
-    }
-
-    function startDataUpdate() {
-        updating = true;
-        eventBus.trigger(events.DATA_UPDATE_STARTED,
-            {},
-            { streamId: streamInfo.id, mediaType: type }
-        );
-    }
-
     function endDataUpdate(error) {
         updating = false;
         eventBus.trigger(events.DATA_UPDATE_COMPLETED,
@@ -210,50 +243,14 @@ function RepresentationController(config) {
         );
     }
 
-    function postponeUpdate(postponeTimePeriod) {
-        let delay = postponeTimePeriod;
-        let update = function () {
-            if (isUpdating()) return;
-
-            startDataUpdate();
-
-            // clear the segmentAvailabilityRange for all reps.
-            // this ensures all are updated before the live edge search starts
-            resetAvailabilityWindow();
-
-            updateAvailabilityWindow(playbackController.getIsDynamic(), true);
-        };
-        eventBus.trigger(events.AST_IN_FUTURE, { delay: delay });
-        setTimeout(update, delay);
-    }
-
-    function onRepresentationUpdated(e) {
+    function _onRepresentationUpdated(r) {
         if (!isUpdating()) return;
 
-        if (e.error) {
-            endDataUpdate(e.error);
-            return;
-        }
-
-        let r = e.representation;
         let manifestUpdateInfo = dashMetrics.getCurrentManifestUpdate();
         let alreadyAdded = false;
-        let postponeTimePeriod = 0;
         let repInfo,
-            err,
             repSwitch;
 
-        if (r.adaptation.period.mpd.manifest.type === dashConstants.DYNAMIC && !r.adaptation.period.mpd.manifest.ignorePostponeTimePeriod && playbackController.getStreamController().getStreams().length <= 1) {
-            // We must put things to sleep unless till e.g. the startTime calculation in ScheduleController.onLiveEdgeSearchCompleted fall after the segmentAvailabilityRange.start
-            postponeTimePeriod = getRepresentationUpdatePostponeTimePeriod(r);
-        }
-
-        if (postponeTimePeriod > 0) {
-            postponeUpdate(postponeTimePeriod);
-            err = new DashJSError(errors.SEGMENTS_UPDATE_FAILED_ERROR_CODE, errors.SEGMENTS_UPDATE_FAILED_ERROR_MESSAGE);
-            endDataUpdate(err);
-            return;
-        }
 
         if (manifestUpdateInfo) {
             for (let i = 0; i < manifestUpdateInfo.representationInfo.length; i++) {
@@ -271,7 +268,10 @@ function RepresentationController(config) {
 
         if (isAllRepresentationsUpdated()) {
             abrController.setPlaybackQuality(getType(), streamInfo, getQualityForRepresentation(currentVoRepresentation));
-            dashMetrics.updateManifestUpdateInfo({latency: currentVoRepresentation.segmentAvailabilityRange.end - playbackController.getTime()});
+            const dvrInfo = dashMetrics.getCurrentDVRInfo();
+            if (dvrInfo) {
+                dashMetrics.updateManifestUpdateInfo({ latency: dvrInfo.range.end - playbackController.getTime() });
+            }
 
             repSwitch = dashMetrics.getCurrentRepresentationSwitch(getCurrentRepresentation().adaptation.type);
 
@@ -282,32 +282,6 @@ function RepresentationController(config) {
         }
     }
 
-    function getRepresentationUpdatePostponeTimePeriod(representation) {
-        try {
-            const streamController = playbackController.getStreamController();
-            const activeStreamInfo = streamController.getActiveStreamInfo();
-            let startTimeAnchor = representation.segmentAvailabilityRange.start;
-
-            if (activeStreamInfo && activeStreamInfo.id && activeStreamInfo.id !== streamInfo.id) {
-                // We need to consider the currently playing period if a period switch is performed.
-                startTimeAnchor = Math.min(playbackController.getTime(), startTimeAnchor);
-            }
-
-            let segmentAvailabilityTimePeriod = representation.segmentAvailabilityRange.end - startTimeAnchor;
-            let liveDelay = playbackController.getLiveDelay();
-
-            return (liveDelay - segmentAvailabilityTimePeriod) * 1000;
-        } catch (e) {
-            return 0;
-        }
-    }
-
-    function onWallclockTimeUpdated(e) {
-        if (e.isDynamic) {
-            updateAvailabilityWindow(e.isDynamic);
-        }
-    }
-
     function onQualityChanged(e) {
         currentVoRepresentation = getRepresentationForQuality(e.newQuality);
         addRepresentationSwitch();
@@ -324,14 +298,13 @@ function RepresentationController(config) {
     }
 
     instance = {
-        getStreamId: getStreamId,
-        getType: getType,
-        getData: getData,
-        isUpdating: isUpdating,
-        updateData: updateData,
-        updateRepresentation: updateRepresentation,
-        getCurrentRepresentation: getCurrentRepresentation,
-        getRepresentationForQuality: getRepresentationForQuality,
+        getStreamId,
+        getType,
+        getData,
+        isUpdating,
+        updateData,
+        getCurrentRepresentation,
+        getRepresentationForQuality,
         reset: reset
     };
 
diff --git a/src/dash/controllers/SegmentBaseController.js b/src/dash/controllers/SegmentBaseController.js
index 8feadcf039..91697d0b21 100644
--- a/src/dash/controllers/SegmentBaseController.js
+++ b/src/dash/controllers/SegmentBaseController.js
@@ -88,37 +88,37 @@ function SegmentBaseController(config) {
     }
 
     function initialize() {
-        eventBus.on(events.SEGMENTBASE_INIT_REQUEST_NEEDED, onInitSegmentBaseNeeded, instance);
-        eventBus.on(events.SEGMENTBASE_SEGMENTSLIST_REQUEST_NEEDED, onSegmentsListSegmentBaseNeeded, instance);
-
         segmentBaseLoader.initialize();
         webmSegmentBaseLoader.initialize();
     }
 
-    function onInitSegmentBaseNeeded(e) {
-        if (isWebM(e.mimeType)) {
-            webmSegmentBaseLoader.loadInitialization(e.streamId, e.mediaType, e.representation);
+    function getSegmentBaseInitSegment(data) {
+        if (isWebM(data.representation.mimeType)) {
+            return webmSegmentBaseLoader.loadInitialization(data.representation, data.mediaType);
         } else {
-            segmentBaseLoader.loadInitialization(e.streamId, e.mediaType, e.representation);
+            return segmentBaseLoader.loadInitialization(data.representation, data.mediaType);
         }
     }
 
-    function onSegmentsListSegmentBaseNeeded(e) {
+    function getSegmentList(e) {
         if (isWebM(e.mimeType)) {
-            webmSegmentBaseLoader.loadSegments(e.streamId, e.mediaType, e.representation, e.representation ? e.representation.indexRange : null, e.callback);
+            return webmSegmentBaseLoader.loadSegments(e.representation, e.mediaType, e.representation ? e.representation.indexRange : null);
         } else {
-            segmentBaseLoader.loadSegments(e.streamId, e.mediaType, e.representation, e.representation ? e.representation.indexRange : null, e.callback);
+            return segmentBaseLoader.loadSegments(e.representation, e.mediaType, e.representation ? e.representation.indexRange : null);
         }
     }
 
     function reset() {
-        eventBus.off(events.SEGMENTBASE_INIT_REQUEST_NEEDED, onInitSegmentBaseNeeded, instance);
-        eventBus.off(events.SEGMENTBASE_SEGMENTSLIST_REQUEST_NEEDED, onSegmentsListSegmentBaseNeeded, instance);
+        segmentBaseLoader.reset();
+        webmSegmentBaseLoader.reset();
     }
 
+
     instance = {
-        initialize: initialize,
-        reset: reset
+        initialize,
+        getSegmentBaseInitSegment,
+        getSegmentList,
+        reset
     };
 
     setup();
diff --git a/src/dash/controllers/SegmentsController.js b/src/dash/controllers/SegmentsController.js
index 00e0cdf800..c1944217e0 100644
--- a/src/dash/controllers/SegmentsController.js
+++ b/src/dash/controllers/SegmentsController.js
@@ -38,11 +38,9 @@ function SegmentsController(config) {
     config = config || {};
 
     const context = this.context;
-    const events = config.events;
-    const eventBus = config.eventBus;
     const dashConstants = config.dashConstants;
-    const streamInfo = config.streamInfo;
     const type = config.type;
+    const segmentBaseController = config.segmentBaseController;
 
     let instance,
         getters;
@@ -58,24 +56,25 @@ function SegmentsController(config) {
         getters[dashConstants.SEGMENT_BASE] = SegmentBaseGetter(context).create(config, isDynamic);
     }
 
-    function update(voRepresentation, mimeType, hasInitialization, hasSegments) {
-        if (!hasInitialization) {
-            eventBus.trigger(events.SEGMENTBASE_INIT_REQUEST_NEEDED, {
-                streamId: streamInfo.id,
-                mediaType: type,
-                mimeType: mimeType,
-                representation: voRepresentation
-            });
+    function updateInitData(voRepresentation, hasInitialization) {
+        if (hasInitialization) {
+            return Promise.resolve();
         }
+        return segmentBaseController.getSegmentBaseInitSegment({
+            representation: voRepresentation,
+            mediaType: type
+        });
+    }
 
-        if (!hasSegments) {
-            eventBus.trigger(events.SEGMENTBASE_SEGMENTSLIST_REQUEST_NEEDED, {
-                streamId: streamInfo.id,
-                mediaType: type,
-                mimeType: mimeType,
-                representation: voRepresentation
-            });
+    function updateSegmentData(voRepresentation, hasSegments) {
+        if (hasSegments) {
+            return Promise.resolve();
         }
+        return segmentBaseController.getSegmentList({
+            mimeType: voRepresentation.mimeType,
+            representation: voRepresentation,
+            mediaType: type
+        });
     }
 
     function getSegmentsGetter(representation) {
@@ -93,10 +92,11 @@ function SegmentsController(config) {
     }
 
     instance = {
-        initialize: initialize,
-        update: update,
-        getSegmentByIndex: getSegmentByIndex,
-        getSegmentByTime: getSegmentByTime
+        initialize,
+        updateInitData,
+        updateSegmentData,
+        getSegmentByIndex,
+        getSegmentByTime
     };
 
     setup();
diff --git a/src/dash/models/DashManifestModel.js b/src/dash/models/DashManifestModel.js
index f345c82e54..891cb04cd3 100644
--- a/src/dash/models/DashManifestModel.js
+++ b/src/dash/models/DashManifestModel.js
@@ -459,6 +459,9 @@ function DashManifestModel() {
                 if (realRepresentation.hasOwnProperty(DashConstants.CODECS)) {
                     voRepresentation.codecs = realRepresentation.codecs;
                 }
+                if (realRepresentation.hasOwnProperty(DashConstants.MIME_TYPE)) {
+                    voRepresentation.mimeType = realRepresentation[DashConstants.MIME_TYPE];
+                }
                 if (realRepresentation.hasOwnProperty(DashConstants.CODEC_PRIVATE_DATA)) {
                     voRepresentation.codecPrivateData = realRepresentation.codecPrivateData;
                 }
@@ -1113,7 +1116,7 @@ function DashManifestModel() {
         return serviceDescriptions;
     }
 
-    function getSupplementalPropperties(adaptation) {
+    function getSupplementalProperties(adaptation) {
         const supplementalProperties = {};
 
         if (adaptation && adaptation.hasOwnProperty(DashConstants.SUPPLEMENTAL_PROPERTY)) {
@@ -1139,53 +1142,53 @@ function DashManifestModel() {
     }
 
     instance = {
-        getIsTypeOf: getIsTypeOf,
-        getIsTextTrack: getIsTextTrack,
-        getLanguageForAdaptation: getLanguageForAdaptation,
-        getViewpointForAdaptation: getViewpointForAdaptation,
-        getRolesForAdaptation: getRolesForAdaptation,
-        getAccessibilityForAdaptation: getAccessibilityForAdaptation,
-        getAudioChannelConfigurationForAdaptation: getAudioChannelConfigurationForAdaptation,
-        getAudioChannelConfigurationForRepresentation: getAudioChannelConfigurationForRepresentation,
-        getAdaptationForIndex: getAdaptationForIndex,
-        getIndexForAdaptation: getIndexForAdaptation,
-        getAdaptationForId: getAdaptationForId,
-        getAdaptationsForType: getAdaptationsForType,
+        getIsTypeOf,
+        getIsTextTrack,
+        getLanguageForAdaptation,
+        getViewpointForAdaptation,
+        getRolesForAdaptation,
+        getAccessibilityForAdaptation,
+        getAudioChannelConfigurationForAdaptation,
+        getAudioChannelConfigurationForRepresentation,
+        getAdaptationForIndex,
+        getIndexForAdaptation,
+        getAdaptationForId,
+        getAdaptationsForType,
         getRealPeriods,
         getRealPeriodForIndex,
-        getCodec: getCodec,
-        getMimeType: getMimeType,
-        getKID: getKID,
-        getLabelsForAdaptation: getLabelsForAdaptation,
-        getContentProtectionData: getContentProtectionData,
-        getIsDynamic: getIsDynamic,
-        getId: getId,
-        hasProfile: hasProfile,
-        getDuration: getDuration,
-        getBandwidth: getBandwidth,
-        getManifestUpdatePeriod: getManifestUpdatePeriod,
-        getPublishTime: getPublishTime,
-        getRepresentationCount: getRepresentationCount,
-        getBitrateListForAdaptation: getBitrateListForAdaptation,
-        getRepresentationFor: getRepresentationFor,
-        getRepresentationsForAdaptation: getRepresentationsForAdaptation,
-        getAdaptationsForPeriod: getAdaptationsForPeriod,
-        getRegularPeriods: getRegularPeriods,
-        getMpd: getMpd,
-        getEventsForPeriod: getEventsForPeriod,
+        getCodec,
+        getMimeType,
+        getKID,
+        getLabelsForAdaptation,
+        getContentProtectionData,
+        getIsDynamic,
+        getId,
+        hasProfile,
+        getDuration,
+        getBandwidth,
+        getManifestUpdatePeriod,
+        getPublishTime,
+        getRepresentationCount,
+        getBitrateListForAdaptation,
+        getRepresentationFor,
+        getRepresentationsForAdaptation,
+        getAdaptationsForPeriod,
+        getRegularPeriods,
+        getMpd,
+        getEventsForPeriod,
         getEssentialPropertiesForRepresentation,
-        getEventStreamForAdaptationSet: getEventStreamForAdaptationSet,
-        getEventStreamForRepresentation: getEventStreamForRepresentation,
-        getUTCTimingSources: getUTCTimingSources,
-        getBaseURLsFromElement: getBaseURLsFromElement,
-        getRepresentationSortFunction: getRepresentationSortFunction,
-        getLocation: getLocation,
-        getPatchLocation: getPatchLocation,
-        getSuggestedPresentationDelay: getSuggestedPresentationDelay,
-        getAvailabilityStartTime: getAvailabilityStartTime,
-        getServiceDescriptions: getServiceDescriptions,
-        getSupplementalPropperties: getSupplementalPropperties,
-        setConfig: setConfig
+        getEventStreamForAdaptationSet,
+        getEventStreamForRepresentation,
+        getUTCTimingSources,
+        getBaseURLsFromElement,
+        getRepresentationSortFunction,
+        getLocation,
+        getPatchLocation,
+        getSuggestedPresentationDelay,
+        getAvailabilityStartTime,
+        getServiceDescriptions,
+        getSupplementalProperties,
+        setConfig
     };
 
     setup();
diff --git a/src/dash/utils/SegmentsUtils.js b/src/dash/utils/SegmentsUtils.js
index f5785332e7..ac8ad4c017 100644
--- a/src/dash/utils/SegmentsUtils.js
+++ b/src/dash/utils/SegmentsUtils.js
@@ -31,6 +31,7 @@
 
 import Segment from './../vo/Segment';
 
+
 function zeroPadToLength(numStr, minStrLength) {
     while (numStr.length < minStrLength) {
         numStr = '0' + numStr;
@@ -137,7 +138,7 @@ function getSegment(representation, duration, presentationStartTime, mediaStartT
     seg.presentationStartTime = presentationStartTime;
     seg.mediaStartTime = mediaStartTime;
     seg.availabilityStartTime = availabilityStartTime;
-    seg.availabilityEndTime = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation.adaptation.period.mpd, isDynamic);
+    seg.availabilityEndTime = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime + duration, representation, isDynamic);
     seg.wallStartTime = timelineConverter.calcWallTimeForSegment(seg, isDynamic);
     seg.replacementNumber = getNumberForSegment(seg, index);
     seg.availabilityIdx = index;
@@ -146,20 +147,27 @@ function getSegment(representation, duration, presentationStartTime, mediaStartT
 }
 
 function isSegmentAvailable(timelineConverter, representation, segment, isDynamic) {
-    const periodEnd = timelineConverter.getPeriodEnd(representation, isDynamic);
-    const periodRelativeEnd = timelineConverter.calcPeriodRelativeTimeFromMpdRelativeTime(representation, periodEnd);
-
-    const segmentTime = timelineConverter.calcPeriodRelativeTimeFromMpdRelativeTime(representation, segment.presentationStartTime);
-    if (segmentTime >= periodRelativeEnd) {
-        if (isDynamic) {
-            // segment is not available in current period, but it may be segment available in another period that current one (in DVR window)
-            // if not (time > segmentAvailabilityRange.end), then return false
-            if (representation.segmentAvailabilityRange && segment.presentationStartTime >= representation.segmentAvailabilityRange.end) {
-                return false;
-            }
-        } else {
-            return false;
+    const voPeriod = representation.adaptation.period;
+
+    // Avoid requesting segments that overlap the period boundary
+    if (isFinite(voPeriod.duration) && voPeriod.start + voPeriod.duration <= segment.presentationStartTime) {
+        return false;
+    }
+
+    if (isDynamic) {
+
+        if (representation.availabilityTimeOffset === 'INF') {
+            return true;
         }
+
+        // For dynamic manifests we check if the presentation start time + duration is included in the availability window
+        // SAST = Period@start + seg@presentationStartTime + seg@duration
+        // ASAST = SAST - ATO
+        // SAET = SAST + TSBD + seg@duration
+
+        const refTime = timelineConverter.getAvailabilityWindowAnchorTime();
+        return segment.availabilityStartTime.getTime() <= refTime && segment.availabilityEndTime.getTime() >= refTime;
+
     }
 
     return true;
@@ -170,6 +178,7 @@ export function getIndexBasedSegment(timelineConverter, isDynamic, representatio
         presentationStartTime,
         presentationEndTime;
 
+
     duration = representation.segmentDuration;
 
     /*
@@ -184,9 +193,10 @@ export function getIndexBasedSegment(timelineConverter, isDynamic, representatio
     presentationStartTime = parseFloat((representation.adaptation.period.start + (index * duration)).toFixed(5));
     presentationEndTime = parseFloat((presentationStartTime + duration).toFixed(5));
 
-    const segment = getSegment(representation, duration, presentationStartTime,
-        timelineConverter.calcMediaTimeFromPresentationTime(presentationStartTime, representation),
-        timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, representation.adaptation.period.mpd, isDynamic),
+    const mediaTime = timelineConverter.calcMediaTimeFromPresentationTime(presentationStartTime, representation);
+    const availabilityStartTime = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, isDynamic);
+
+    const segment = getSegment(representation, duration, presentationStartTime, mediaTime, availabilityStartTime,
         timelineConverter, presentationEndTime, isDynamic, index);
 
     if (!isSegmentAvailable(timelineConverter, representation, segment, isDynamic)) {
@@ -207,9 +217,11 @@ export function getTimeBasedSegment(timelineConverter, isDynamic, representation
     presentationStartTime = timelineConverter.calcPresentationTimeFromMediaTime(scaledTime, representation);
     presentationEndTime = presentationStartTime + scaledDuration;
 
+    const availabilityStartTime = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, isDynamic);
+
     seg = getSegment(representation, scaledDuration, presentationStartTime,
         scaledTime,
-        representation.adaptation.period.mpd.manifest.loadedTime,
+        availabilityStartTime,
         timelineConverter, presentationEndTime, isDynamic, index);
 
     if (!isSegmentAvailable(timelineConverter, representation, seg, isDynamic)) {
diff --git a/src/dash/utils/TemplateSegmentsGetter.js b/src/dash/utils/TemplateSegmentsGetter.js
index 30d742d60c..b0a77371fa 100644
--- a/src/dash/utils/TemplateSegmentsGetter.js
+++ b/src/dash/utils/TemplateSegmentsGetter.js
@@ -32,7 +32,7 @@
 import FactoryMaker from '../../core/FactoryMaker';
 import Constants from '../../streaming/constants/Constants';
 
-import { replaceTokenForTemplate, getIndexBasedSegment } from './SegmentsUtils';
+import {replaceTokenForTemplate, getIndexBasedSegment} from './SegmentsUtils';
 
 function TemplateSegmentsGetter(config, isDynamic) {
     config = config || {};
@@ -53,8 +53,7 @@ function TemplateSegmentsGetter(config, isDynamic) {
             return null;
         }
 
-        const template = representation.adaptation.period.mpd.manifest.Period_asArray[representation.adaptation.period.index].
-            AdaptationSet_asArray[representation.adaptation.index].Representation_asArray[representation.index].SegmentTemplate;
+        const template = representation.adaptation.period.mpd.manifest.Period_asArray[representation.adaptation.period.index].AdaptationSet_asArray[representation.adaptation.index].Representation_asArray[representation.index].SegmentTemplate;
 
         index = Math.max(index, 0);
 
@@ -69,12 +68,11 @@ function TemplateSegmentsGetter(config, isDynamic) {
         }
 
         const duration = representation.segmentDuration;
-        const availabilityWindow = representation.segmentAvailabilityRange;
+
         if (isNaN(duration)) {
             representation.availableSegmentsNumber = 1;
-        }
-        else {
-            representation.availableSegmentsNumber = Math.ceil((availabilityWindow.end - availabilityWindow.start) / duration);
+        } else {
+            representation.availableSegmentsNumber = Math.ceil(representation.adaptation.period.duration / duration);
         }
 
         return seg;
@@ -93,15 +91,15 @@ function TemplateSegmentsGetter(config, isDynamic) {
             return null;
         }
 
-        const periodTime = timelineConverter.calcPeriodRelativeTimeFromMpdRelativeTime(representation, requestedTime);
+        let periodTime = timelineConverter.calcPeriodRelativeTimeFromMpdRelativeTime(representation, requestedTime);
         const index = Math.floor(periodTime / duration);
 
         return getSegmentByIndex(representation, index);
     }
 
     instance = {
-        getSegmentByIndex: getSegmentByIndex,
-        getSegmentByTime: getSegmentByTime
+        getSegmentByIndex,
+        getSegmentByTime
     };
 
     return instance;
diff --git a/src/dash/utils/TimelineConverter.js b/src/dash/utils/TimelineConverter.js
index 34c8d6652d..18dde8dcd1 100644
--- a/src/dash/utils/TimelineConverter.js
+++ b/src/dash/utils/TimelineConverter.js
@@ -34,6 +34,7 @@ import FactoryMaker from '../../core/FactoryMaker';
 import DashConstants from '../constants/DashConstants';
 import DashManifestModel from '../models/DashManifestModel';
 import Settings from '../../core/Settings';
+import Constants from '../../streaming/constants/Constants';
 
 function TimelineConverter() {
 
@@ -45,6 +46,7 @@ function TimelineConverter() {
         dashManifestModel,
         clientServerTimeShift,
         isClientServerTimeSyncCompleted,
+        availabilityWindowAnchorOffset,
         expectedLiveEdge;
 
     function setup() {
@@ -65,48 +67,47 @@ function TimelineConverter() {
         clientServerTimeShift = value;
     }
 
-    function getExpectedLiveEdge() {
-        return expectedLiveEdge;
-    }
-
-    function setExpectedLiveEdge(value) {
-        expectedLiveEdge = value;
-    }
-
-    function calcAvailabilityTimeFromPresentationTime(presentationTime, mpd, isDynamic, calculateEnd) {
-        let availabilityTime = NaN;
+    function calcAvailabilityTimeFromPresentationTime(presentationEndTime, representation, isDynamic, calculateAvailabilityEndTime) {
+        let availabilityTime;
+        let mpd = representation.adaptation.period.mpd;
+        const availabilityStartTime = mpd.availabilityStartTime;
 
-        if (calculateEnd) {
+        if (calculateAvailabilityEndTime) {
             //@timeShiftBufferDepth specifies the duration of the time shifting buffer that is guaranteed
             // to be available for a Media Presentation with type 'dynamic'.
             // When not present, the value is infinite.
-            if (isDynamic && (mpd.timeShiftBufferDepth != Number.POSITIVE_INFINITY)) {
-                availabilityTime = new Date(mpd.availabilityStartTime.getTime() + ((presentationTime + mpd.timeShiftBufferDepth) * 1000));
+            if (isDynamic && mpd.timeShiftBufferDepth !== Number.POSITIVE_INFINITY) {
+                // SAET = SAST + TSBD + seg@duration
+                availabilityTime = new Date(availabilityStartTime.getTime() + ((presentationEndTime - clientServerTimeShift + mpd.timeShiftBufferDepth) * 1000));
             } else {
                 availabilityTime = mpd.availabilityEndTime;
             }
         } else {
-            if (isDynamic) {
-                availabilityTime = new Date(mpd.availabilityStartTime.getTime() + (presentationTime - clientServerTimeShift) * 1000);
+            if (isDynamic && mpd.timeShiftBufferDepth !== Number.POSITIVE_INFINITY) {
+                // SAST = Period@start + seg@presentationStartTime + seg@duration
+                // ASAST = SAST - ATO
+                const availabilityTimeOffset = representation.availabilityTimeOffset;
+                // presentationEndTime = Period@start + seg@presentationStartTime + Segment@duration
+                availabilityTime = new Date(availabilityStartTime.getTime() + (presentationEndTime - clientServerTimeShift - availabilityTimeOffset) * 1000);
             } else {
                 // in static mpd, all segments are available at the same time
-                availabilityTime = mpd.availabilityStartTime;
+                availabilityTime = availabilityStartTime;
             }
         }
 
         return availabilityTime;
     }
 
-    function calcAvailabilityStartTimeFromPresentationTime(presentationTime, mpd, isDynamic) {
-        return calcAvailabilityTimeFromPresentationTime.call(this, presentationTime, mpd, isDynamic);
+    function calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, isDynamic) {
+        return calcAvailabilityTimeFromPresentationTime.call(this, presentationEndTime, representation, isDynamic);
     }
 
-    function calcAvailabilityEndTimeFromPresentationTime(presentationTime, mpd, isDynamic) {
-        return calcAvailabilityTimeFromPresentationTime.call(this, presentationTime, mpd, isDynamic, true);
+    function calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, isDynamic) {
+        return calcAvailabilityTimeFromPresentationTime.call(this, presentationEndTime, representation, isDynamic, true);
     }
 
     function calcPresentationTimeFromWallTime(wallTime, period) {
-        return ((wallTime.getTime() - period.mpd.availabilityStartTime.getTime() + clientServerTimeShift * 1000) / 1000);
+        return ((wallTime.getTime() - period.mpd.availabilityStartTime.getTime() - clientServerTimeShift * 1000) / 1000);
     }
 
     function calcPresentationTimeFromMediaTime(mediaTime, representation) {
@@ -137,37 +138,154 @@ function TimelineConverter() {
         return wallTime;
     }
 
-    function calcSegmentAvailabilityRange(voRepresentation, isDynamic) {
-        // Static Range Finder
-        const voPeriod = voRepresentation.adaptation.period;
-        const range = {start: voPeriod.start, end: voPeriod.start + voPeriod.duration};
-        if (!isDynamic) return range;
+    function getAvailabilityWindowAnchorTime() {
+        return Date.now() - clientServerTimeShift * 1000;
+    }
 
-        if (!isClientServerTimeSyncCompleted && voRepresentation.segmentAvailabilityRange) {
-            return voRepresentation.segmentAvailabilityRange;
+    /**
+     * Calculates the timeshiftbuffer range. This range might overlap multiple periods and is not limited to period boundaries. However, we make sure that the range is potentially covered by period.
+     * @param {Array} streams
+     * @param {boolean} isDynamic
+     * @return {{start: number, end: number}}
+     */
+    function calcTimeShiftBufferWindow(streams, isDynamic) {
+        // Static manifests. The availability window is equal to the DVR window
+        if (!isDynamic) {
+            return _calcTimeshiftBufferForStaticManifest(streams);
         }
 
-        // Dynamic Range Finder
-        const d = voRepresentation.segmentDuration || (voRepresentation.segments && voRepresentation.segments.length ? voRepresentation.segments[voRepresentation.segments.length - 1].duration : 0);
+        // Specific use case of SegmentTimeline
+        if (settings.get().streaming.calcSegmentAvailabilityRangeFromTimeline) {
+            return _calcTimeShiftBufferWindowForDynamicTimelineManifest(streams);
+        }
+
+        return _calcTimeShiftBufferWindowForDynamicManifest(streams);
+    }
+
+    function _calcTimeshiftBufferForStaticManifest(streams) {
+        // Static Range Finder. We iterate over all periods and return the total duration
+        const range = {start: NaN, end: NaN};
+        let duration = 0;
+        let start = NaN;
+        streams.forEach((stream) => {
+            const streamInfo = stream.getStreamInfo();
+            duration += streamInfo.duration;
+
+            if (isNaN(start) || streamInfo.start < start) {
+                start = streamInfo.start;
+            }
+        });
+
+        range.start = start;
+        range.end = start + duration;
+
+        return range;
+    }
 
-        // Specific use case of SegmentTimeline without timeShiftBufferDepth
-        if (voRepresentation.segmentInfoType === DashConstants.SEGMENT_TIMELINE && settings.get().streaming.calcSegmentAvailabilityRangeFromTimeline) {
-            return calcSegmentAvailabilityRangeFromTimeline(voRepresentation);
+    function _calcTimeShiftBufferWindowForDynamicManifest(streams) {
+        const range = {start: NaN, end: NaN};
+
+        if (!streams || streams.length === 0) {
+            return range;
         }
 
+        const voPeriod = streams[0].getAdapter().getRegularPeriods()[0];
         const now = calcPresentationTimeFromWallTime(new Date(), voPeriod);
-        const periodEnd = voPeriod.start + voPeriod.duration;
-        range.start = Math.max((now - voPeriod.mpd.timeShiftBufferDepth), voPeriod.start);
+        const timeShiftBufferDepth = voPeriod.mpd.timeShiftBufferDepth;
+        const start = !isNaN(timeShiftBufferDepth) ? now - timeShiftBufferDepth : 0;
+        // check if we find a suitable period for that starttime. Otherwise we use the time closest to that
+        range.start = _adjustTimeBasedOnPeriodRanges(streams, start);
+        range.end = !isNaN(range.start) && now < range.start ? now : _adjustTimeBasedOnPeriodRanges(streams, now, true);
+
+        if (!isNaN(timeShiftBufferDepth) && range.end < now - timeShiftBufferDepth) {
+            range.end = NaN;
+        }
 
-        const endOffset = voRepresentation.availabilityTimeOffset !== undefined &&
-        voRepresentation.availabilityTimeOffset < d ? d - voRepresentation.availabilityTimeOffset : d;
+        return range;
+    }
 
-        range.end = now >= periodEnd && now - endOffset < periodEnd ? periodEnd : now - endOffset;
+    function _calcTimeShiftBufferWindowForDynamicTimelineManifest(streams) {
+        const range = {start: NaN, end: NaN};
+        const voPeriod = streams[0].getAdapter().getRegularPeriods()[0];
+        const now = calcPresentationTimeFromWallTime(new Date(), voPeriod);
+
+        if (!streams || streams.length === 0) {
+            return range;
+        }
+
+        streams.forEach((stream) => {
+            const adapter = stream.getAdapter();
+            const mediaInfo = adapter.getMediaInfoForType(stream.getStreamInfo(), Constants.VIDEO) || adapter.getMediaInfoForType(stream.getStreamInfo(), Constants.AUDIO);
+            const voRepresentations = adapter.getVoRepresentations(mediaInfo);
+            const voRepresentation = voRepresentations[0];
+            let periodRange = {start: NaN, end: NaN};
+
+            if (voRepresentation) {
+                if (voRepresentation.segmentInfoType === DashConstants.SEGMENT_TIMELINE) {
+                    periodRange = _calcRangeForTimeline(voRepresentation);
+                } else {
+                    const currentVoPeriod = voRepresentation.adaptation.period;
+                    periodRange.start = currentVoPeriod.start;
+                    periodRange.end = Math.max(now, currentVoPeriod.start + currentVoPeriod.duration);
+                }
+            }
+
+            if (!isNaN(periodRange.start) && (isNaN(range.start) || range.start > periodRange.start)) {
+                range.start = periodRange.start;
+            }
+            if (!isNaN(periodRange.end) && (isNaN(range.end) || range.end < periodRange.end)) {
+                range.end = periodRange.end;
+            }
+        });
+
+
+        range.end = range.end > now ? now : range.end;
+        const adjustedEndTime = _adjustTimeBasedOnPeriodRanges(streams, range.end, true);
+
+        // if range is NaN all periods are in the future. we should return range.start > range.end in this case
+        range.end = isNaN(adjustedEndTime) ? range.end : adjustedEndTime;
+
+        range.start = voPeriod && voPeriod.mpd && voPeriod.mpd.timeShiftBufferDepth && !isNaN(voPeriod.mpd.timeShiftBufferDepth) && !isNaN(range.end) ? Math.max(range.end - voPeriod.mpd.timeShiftBufferDepth, range.start) : range.start;
+        range.start = _adjustTimeBasedOnPeriodRanges(streams, range.start);
 
         return range;
     }
 
-    function calcSegmentAvailabilityRangeFromTimeline(voRepresentation) {
+    function _adjustTimeBasedOnPeriodRanges(streams, time, isEndOfDvrWindow = false) {
+        try {
+            let i = 0;
+            let found = false;
+            let adjustedTime = NaN;
+
+            while (!found && i < streams.length) {
+                const streamInfo = streams[i].getStreamInfo();
+
+                // We found a period which contains the target time.
+                if (streamInfo.start <= time && (!isFinite(streamInfo.duration) || (streamInfo.start + streamInfo.duration >= time))) {
+                    adjustedTime = time;
+                    found = true;
+                }
+
+                // Adjust the time for the start of the DVR window. The current period starts after the target time. We use the starttime of this period as adjusted time
+                else if (!isEndOfDvrWindow && (streamInfo.start > time && (isNaN(adjustedTime) || streamInfo.start < adjustedTime))) {
+                    adjustedTime = streamInfo.start;
+                }
+
+                // Adjust the time for the end of the DVR window. The current period ends before the targettime. We use the end time of this period as the adjusted time
+                else if (isEndOfDvrWindow && ((streamInfo.start + streamInfo.duration) < time && (isNaN(adjustedTime) || (streamInfo.start + streamInfo.duration > adjustedTime)))) {
+                    adjustedTime = streamInfo.start + streamInfo.duration;
+                }
+
+                i += 1;
+            }
+
+            return adjustedTime;
+        } catch (e) {
+            return time;
+        }
+    }
+
+    function _calcRangeForTimeline(voRepresentation) {
         const adaptation = voRepresentation.adaptation.period.mpd.manifest.Period_asArray[voRepresentation.adaptation.period.index].AdaptationSet_asArray[voRepresentation.adaptation.index];
         const representation = dashManifestModel.getRepresentationFor(voRepresentation.index, adaptation);
         const timeline = representation.SegmentTemplate.SegmentTimeline;
@@ -196,38 +314,11 @@ function TimelineConverter() {
         return range;
     }
 
-    function getPeriodEnd(voRepresentation, isDynamic) {
-        // Static Range Finder
-        const voPeriod = voRepresentation.adaptation.period;
-        if (!isDynamic) {
-            return voPeriod.start + voPeriod.duration;
-        }
-
-        if (!isClientServerTimeSyncCompleted && voRepresentation.segmentAvailabilityRange) {
-            return voRepresentation.segmentAvailabilityRange;
-        }
-
-        // Dynamic Range Finder
-        const d = voRepresentation.segmentDuration || (voRepresentation.segments && voRepresentation.segments.length ? voRepresentation.segments[voRepresentation.segments.length - 1].duration : 0);
-        const now = calcPresentationTimeFromWallTime(new Date(), voPeriod);
-        const periodEnd = voPeriod.start + voPeriod.duration;
-
-        const endOffset = voRepresentation.availabilityTimeOffset !== undefined &&
-        voRepresentation.availabilityTimeOffset < d ? d - voRepresentation.availabilityTimeOffset : d;
-
-        return Math.min(now - endOffset, periodEnd);
-    }
-
     function calcPeriodRelativeTimeFromMpdRelativeTime(representation, mpdRelativeTime) {
         const periodStartTime = representation.adaptation.period.start;
         return mpdRelativeTime - periodStartTime;
     }
 
-    /*
-    * We need to figure out if we want to timesync for segmentTimeine where useCalculatedLiveEdge = true
-    * seems we figure out client offset based on logic in liveEdgeFinder getLiveEdge timelineConverter.setClientTimeOffset(liveEdge - representationInfo.DVRWindow.end);
-    * FYI StreamController's onManifestUpdated entry point to timeSync
-    * */
     function _onUpdateTimeSyncOffset(e) {
         if (e.offset !== undefined) {
             setClientTimeOffset(e.offset / 1000);
@@ -237,6 +328,7 @@ function TimelineConverter() {
 
     function resetInitialSettings() {
         clientServerTimeShift = 0;
+        availabilityWindowAnchorOffset = 0;
         isClientServerTimeSyncCompleted = false;
         expectedLiveEdge = NaN;
     }
@@ -247,21 +339,19 @@ function TimelineConverter() {
     }
 
     instance = {
-        initialize: initialize,
-        getClientTimeOffset: getClientTimeOffset,
-        setClientTimeOffset: setClientTimeOffset,
-        getExpectedLiveEdge: getExpectedLiveEdge,
-        setExpectedLiveEdge: setExpectedLiveEdge,
-        calcAvailabilityStartTimeFromPresentationTime: calcAvailabilityStartTimeFromPresentationTime,
-        calcAvailabilityEndTimeFromPresentationTime: calcAvailabilityEndTimeFromPresentationTime,
-        calcPresentationTimeFromWallTime: calcPresentationTimeFromWallTime,
-        calcPresentationTimeFromMediaTime: calcPresentationTimeFromMediaTime,
-        calcPeriodRelativeTimeFromMpdRelativeTime: calcPeriodRelativeTimeFromMpdRelativeTime,
-        calcMediaTimeFromPresentationTime: calcMediaTimeFromPresentationTime,
-        calcSegmentAvailabilityRange: calcSegmentAvailabilityRange,
-        getPeriodEnd: getPeriodEnd,
-        calcWallTimeForSegment: calcWallTimeForSegment,
-        reset: reset
+        initialize,
+        getClientTimeOffset,
+        setClientTimeOffset,
+        calcAvailabilityStartTimeFromPresentationTime,
+        calcAvailabilityEndTimeFromPresentationTime,
+        calcPresentationTimeFromWallTime,
+        calcPresentationTimeFromMediaTime,
+        calcPeriodRelativeTimeFromMpdRelativeTime,
+        calcMediaTimeFromPresentationTime,
+        calcWallTimeForSegment,
+        calcTimeShiftBufferWindow,
+        getAvailabilityWindowAnchorTime,
+        reset
     };
 
     setup();
diff --git a/src/dash/utils/TimelineSegmentsGetter.js b/src/dash/utils/TimelineSegmentsGetter.js
index 6df815066e..920b720b81 100644
--- a/src/dash/utils/TimelineSegmentsGetter.js
+++ b/src/dash/utils/TimelineSegmentsGetter.js
@@ -32,27 +32,25 @@
 import FactoryMaker from '../../core/FactoryMaker';
 import Constants from '../../streaming/constants/Constants';
 
-import { getTimeBasedSegment } from './SegmentsUtils';
+import {getTimeBasedSegment} from './SegmentsUtils';
 
 function TimelineSegmentsGetter(config, isDynamic) {
 
     config = config || {};
     const timelineConverter = config.timelineConverter;
+    const dashMetrics = config.dashMetrics;
 
     let instance;
 
     function checkConfig() {
-        if (!timelineConverter || !timelineConverter.hasOwnProperty('calcMediaTimeFromPresentationTime') ||
-            !timelineConverter.hasOwnProperty('calcSegmentAvailabilityRange')) {
+        if (!timelineConverter) {
             throw new Error(Constants.MISSING_CONFIG_ERROR);
         }
     }
 
     function iterateSegments(representation, iterFunc) {
-        const base = representation.adaptation.period.mpd.manifest.Period_asArray[representation.adaptation.period.index].
-            AdaptationSet_asArray[representation.adaptation.index].Representation_asArray[representation.index].SegmentTemplate ||
-            representation.adaptation.period.mpd.manifest.Period_asArray[representation.adaptation.period.index].
-                AdaptationSet_asArray[representation.adaptation.index].Representation_asArray[representation.index].SegmentList;
+        const base = representation.adaptation.period.mpd.manifest.Period_asArray[representation.adaptation.period.index].AdaptationSet_asArray[representation.adaptation.index].Representation_asArray[representation.index].SegmentTemplate ||
+            representation.adaptation.period.mpd.manifest.Period_asArray[representation.adaptation.period.index].AdaptationSet_asArray[representation.adaptation.index].Representation_asArray[representation.index].SegmentList;
         const timeline = base.SegmentTimeline;
         const list = base.SegmentURL_asArray;
 
@@ -96,12 +94,24 @@ function TimelineSegmentsGetter(config, isDynamic) {
                 if (nextFrag && nextFrag.hasOwnProperty('t')) {
                     repeatEndTime = nextFrag.t / fTimescale;
                 } else {
-                    const availabilityEnd = representation.segmentAvailabilityRange ? representation.segmentAvailabilityRange.end : (timelineConverter.calcSegmentAvailabilityRange(representation, isDynamic).end);
-                    repeatEndTime = timelineConverter.calcMediaTimeFromPresentationTime(availabilityEnd, representation);
-                    representation.segmentDuration = frag.d / fTimescale;
+                    try {
+                        let availabilityEnd = 0;
+                        if (!isNaN(representation.adaptation.period.start) && !isNaN(representation.adaptation.period.duration) && isFinite(representation.adaptation.period.duration)) {
+                            // use end of the Period
+                            availabilityEnd = representation.adaptation.period.start + representation.adaptation.period.duration;
+                        } else {
+                            // use DVR window
+                            const dvrWindow = dashMetrics.getCurrentDVRInfo();
+                            availabilityEnd = !isNaN(dvrWindow.end) ? dvrWindow.end : 0;
+                        }
+                        repeatEndTime = timelineConverter.calcMediaTimeFromPresentationTime(availabilityEnd, representation);
+                        representation.segmentDuration = frag.d / fTimescale;
+                    } catch (e) {
+                        repeatEndTime = 0;
+                    }
                 }
 
-                repeat = Math.ceil((repeatEndTime - scaledTime) / (frag.d / fTimescale)) - 1;
+                repeat = Math.max(Math.ceil((repeatEndTime - scaledTime) / (frag.d / fTimescale)) - 1, 0);
             }
 
             for (j = 0; j <= repeat && !breakIterator; j++) {
diff --git a/src/dash/vo/Representation.js b/src/dash/vo/Representation.js
index d56210ad4c..7b5ccaaac0 100644
--- a/src/dash/vo/Representation.js
+++ b/src/dash/vo/Representation.js
@@ -43,6 +43,7 @@ class Representation {
         this.segmentInfoType = null;
         this.initialization = null;
         this.codecs = null;
+        this.mimeType = null;
         this.codecPrivateData = null;
         this.segmentDuration = NaN;
         this.timescale = 1;
@@ -52,7 +53,6 @@ class Representation {
         this.presentationTimeOffset = 0;
         // Set the source buffer timeOffset to this
         this.MSETimeOffset = NaN;
-        this.segmentAvailabilityRange = null;
         this.availableSegmentsNumber = 0;
         this.bandwidth = NaN;
         this.width = NaN;
diff --git a/src/dash/vo/RepresentationInfo.js b/src/dash/vo/RepresentationInfo.js
index 0711217c04..9d55e8c460 100644
--- a/src/dash/vo/RepresentationInfo.js
+++ b/src/dash/vo/RepresentationInfo.js
@@ -36,7 +36,6 @@ class RepresentationInfo {
     constructor() {
         this.id = null;
         this.quality = null;
-        this.DVRWindow = null;
         this.fragmentDuration = null;
         this.mediaInfo = null;
         this.MSETimeOffset = null;
diff --git a/src/mss/MssFragmentMoofProcessor.js b/src/mss/MssFragmentMoofProcessor.js
index 20c83d1e8f..61dfd20942 100644
--- a/src/mss/MssFragmentMoofProcessor.js
+++ b/src/mss/MssFragmentMoofProcessor.js
@@ -186,7 +186,6 @@ function MssFragmentMoofProcessor(config) {
             updateDVR(type, range, streamProcessor.getStreamInfo().manifestInfo);
         }
 
-        representationController.updateRepresentation(representation, true);
     }
 
     function updateDVR(type, range, manifestInfo) {
diff --git a/src/mss/parser/MssParser.js b/src/mss/parser/MssParser.js
index 72a5be2ef5..c72911d868 100644
--- a/src/mss/parser/MssParser.js
+++ b/src/mss/parser/MssParser.js
@@ -363,7 +363,7 @@ function MssParser(config) {
         let segment,
             prevSegment,
             tManifest,
-            i,j,r;
+            i, j, r;
         let duration = 0;
 
         for (i = 0; i < chunks.length; i++) {
@@ -426,7 +426,7 @@ function MssParser(config) {
                     segment.t = prevSegment.t + prevSegment.d;
                     segment.d = prevSegment.d;
                     if (prevSegment.tManifest) {
-                        segment.tManifest  = BigInt(prevSegment.tManifest).add(BigInt(prevSegment.d)).toString();
+                        segment.tManifest = BigInt(prevSegment.tManifest).add(BigInt(prevSegment.d)).toString();
                     }
                     duration += segment.d;
                     segments.push(segment);
@@ -571,7 +571,7 @@ function MssParser(config) {
         i += 8;
 
         // Set SystemID ('edef8ba9-79d6-4ace-a3c8-27dcd51d21ed')
-        pssh.set([0xed, 0xef, 0x8b, 0xa9,  0x79, 0xd6, 0x4a, 0xce, 0xa3, 0xc8, 0x27, 0xdc, 0xd5, 0x1d, 0x21, 0xed], i);
+        pssh.set([0xed, 0xef, 0x8b, 0xa9, 0x79, 0xd6, 0x4a, 0xce, 0xa3, 0xc8, 0x27, 0xdc, 0xd5, 0x1d, 0x21, 0xed], i);
         i += 16;
 
         // Set data length value
@@ -613,7 +613,7 @@ function MssParser(config) {
         manifest.protocol = 'MSS';
         manifest.profiles = 'urn:mpeg:dash:profile:isoff-live:2011';
         manifest.type = getAttributeAsBoolean(smoothStreamingMedia, 'IsLive') ? 'dynamic' : 'static';
-        timescale =  smoothStreamingMedia.getAttribute('TimeScale');
+        timescale = smoothStreamingMedia.getAttribute('TimeScale');
         manifest.timescale = timescale ? parseFloat(timescale) : DEFAULT_TIME_SCALE;
         let dvrWindowLength = parseFloat(smoothStreamingMedia.getAttribute('DVRWindowLength'));
         // If the DVRWindowLength field is omitted for a live presentation or set to 0, the DVR window is effectively infinite
@@ -705,7 +705,7 @@ function MssParser(config) {
                 // Set minBufferTime to one segment duration
                 manifest.minBufferTime = segmentDuration;
 
-                if (manifest.type === 'dynamic' ) {
+                if (manifest.type === 'dynamic') {
                     // Match timeShiftBufferDepth to video segment timeline duration
                     if (manifest.timeShiftBufferDepth > 0 &&
                         manifest.timeShiftBufferDepth !== Infinity &&
@@ -726,7 +726,7 @@ function MssParser(config) {
         if (manifest.type === 'dynamic') {
             let targetLiveDelay = mediaPlayerModel.getLiveDelay();
             if (!targetLiveDelay) {
-                const liveDelayFragmentCount = settings.get().streaming.liveDelayFragmentCount !== null && !isNaN(settings.get().streaming.liveDelayFragmentCount) ? settings.get().streaming.liveDelayFragmentCount : 4;
+                const liveDelayFragmentCount = settings.get().streaming.delay.liveDelayFragmentCount !== null && !isNaN(settings.get().streaming.delay.liveDelayFragmentCount) ? settings.get().streaming.delay.liveDelayFragmentCount : 4;
                 targetLiveDelay = segmentDuration * liveDelayFragmentCount;
             }
             let targetDelayCapping = Math.max(manifest.timeShiftBufferDepth - 10/*END_OF_PLAYLIST_PADDING*/, manifest.timeShiftBufferDepth / 2);
@@ -737,21 +737,29 @@ function MssParser(config) {
             // Store initial buffer settings
             initialBufferSettings = {
                 'streaming': {
+                    'buffer': {
+                        'stableBufferTime': settings.get().streaming.buffer.stableBufferTime,
+                        'bufferTimeAtTopQuality': settings.get().streaming.buffer.bufferTimeAtTopQuality,
+                        'bufferTimeAtTopQualityLongForm': settings.get().streaming.buffer.bufferTimeAtTopQualityLongForm
+                    },
                     'calcSegmentAvailabilityRangeFromTimeline': settings.get().streaming.calcSegmentAvailabilityRangeFromTimeline,
-                    'liveDelay': settings.get().streaming.liveDelay,
-                    'stableBufferTime': settings.get().streaming.stableBufferTime,
-                    'bufferTimeAtTopQuality': settings.get().streaming.bufferTimeAtTopQuality,
-                    'bufferTimeAtTopQualityLongForm': settings.get().streaming.bufferTimeAtTopQualityLongForm
+                    'delay': {
+                        'liveDelay': settings.get().streaming.delay.liveDelay
+                    }
                 }
             };
 
             settings.update({
                 'streaming': {
+                    'buffer': {
+                        'stableBufferTime': bufferTime,
+                        'bufferTimeAtTopQuality': bufferTime,
+                        'bufferTimeAtTopQualityLongForm': bufferTime
+                    },
                     'calcSegmentAvailabilityRangeFromTimeline': true,
-                    'liveDelay': liveDelay,
-                    'stableBufferTime': bufferTime,
-                    'bufferTimeAtTopQuality': bufferTime,
-                    'bufferTimeAtTopQualityLongForm': bufferTime
+                    'delay': {
+                        'liveDelay': liveDelay
+                    }
                 }
             });
         }
diff --git a/src/offline/OfflineStreamProcessor.js b/src/offline/OfflineStreamProcessor.js
index b70187c006..0beeb0395d 100644
--- a/src/offline/OfflineStreamProcessor.js
+++ b/src/offline/OfflineStreamProcessor.js
@@ -131,7 +131,7 @@ function OfflineStreamProcessor(config) {
             events: events
         });
 
-        eventBus.on(events.STREAM_COMPLETED, onStreamCompleted, instance);
+        eventBus.on(events.STREAM_REQUESTING_COMPLETED, onStreamRequestingCompleted, instance);
         eventBus.on(events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, instance);
     }
 
@@ -174,7 +174,7 @@ function OfflineStreamProcessor(config) {
         }
     }
 
-    function onStreamCompleted(e) {
+    function onStreamRequestingCompleted(e) {
         if (e.fragmentModel !== fragmentModel) {
             return;
         }
@@ -343,7 +343,7 @@ function OfflineStreamProcessor(config) {
         resetInitialSettings();
         indexHandler.reset();
 
-        eventBus.off(events.STREAM_COMPLETED, onStreamCompleted, instance);
+        eventBus.off(events.STREAM_REQUESTING_COMPLETED, onStreamRequestingCompleted, instance);
         eventBus.off(events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, instance);
     }
 
diff --git a/src/streaming/FragmentLoader.js b/src/streaming/FragmentLoader.js
index 9f82097231..ed00441ad6 100644
--- a/src/streaming/FragmentLoader.js
+++ b/src/streaming/FragmentLoader.js
@@ -42,6 +42,7 @@ function FragmentLoader(config) {
     const events = config.events;
     const urlUtils = config.urlUtils;
     const errors = config.errors;
+    const streamId = config.streamId;
 
     let instance,
         urlLoader;
@@ -103,7 +104,8 @@ function FragmentLoader(config) {
                 progress: function (event) {
                     eventBus.trigger(events.LOADING_PROGRESS, {
                         request: request,
-                        stream: event.stream
+                        stream: event.stream,
+                        streamId
                     });
                     if (event.data) {
                         eventBus.trigger(events.LOADING_DATA_PROGRESS, {
diff --git a/src/streaming/ManifestUpdater.js b/src/streaming/ManifestUpdater.js
index 2afb5aee9a..a5c4bdb9c7 100644
--- a/src/streaming/ManifestUpdater.js
+++ b/src/streaming/ManifestUpdater.js
@@ -30,6 +30,7 @@
  */
 import EventBus from '../core/EventBus';
 import Events from '../core/events/Events';
+import MediaPlayerEvents from '../streaming/MediaPlayerEvents';
 import FactoryMaker from '../core/FactoryMaker';
 import Debug from '../core/Debug';
 import Errors from '../core/errors/Errors';
@@ -83,8 +84,8 @@ function ManifestUpdater() {
         resetInitialSettings();
 
         eventBus.on(Events.STREAMS_COMPOSED, onStreamsComposed, this);
-        eventBus.on(Events.PLAYBACK_STARTED, onPlaybackStarted, this);
-        eventBus.on(Events.PLAYBACK_PAUSED, onPlaybackPaused, this);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_STARTED, onPlaybackStarted, this);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_PAUSED, onPlaybackPaused, this);
         eventBus.on(Events.INTERNAL_MANIFEST_LOADED, onManifestLoaded, this);
     }
 
@@ -102,8 +103,8 @@ function ManifestUpdater() {
 
     function reset() {
 
-        eventBus.off(Events.PLAYBACK_STARTED, onPlaybackStarted, this);
-        eventBus.off(Events.PLAYBACK_PAUSED, onPlaybackPaused, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_STARTED, onPlaybackStarted, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_PAUSED, onPlaybackPaused, this);
         eventBus.off(Events.STREAMS_COMPOSED, onStreamsComposed, this);
         eventBus.off(Events.INTERNAL_MANIFEST_LOADED, onManifestLoaded, this);
 
@@ -251,7 +252,7 @@ function ManifestUpdater() {
     }
 
     function onPlaybackPaused(/*e*/) {
-        isPaused = !settings.get().streaming.scheduleWhilePaused;
+        isPaused = !settings.get().streaming.scheduling.scheduleWhilePaused;
 
         if (isPaused) {
             stopManifestRefreshTimer();
diff --git a/src/streaming/MediaPlayer.js b/src/streaming/MediaPlayer.js
index 093285f5a9..17af9cdce4 100644
--- a/src/streaming/MediaPlayer.js
+++ b/src/streaming/MediaPlayer.js
@@ -41,9 +41,7 @@ import ManifestLoader from './ManifestLoader';
 import ErrorHandler from './utils/ErrorHandler';
 import Capabilities from './utils/Capabilities';
 import CapabilitiesFilter from './utils/CapabilitiesFilter';
-import TextTracks from './text/TextTracks';
 import RequestModifier from './utils/RequestModifier';
-import TextController from './text/TextController';
 import URIFragmentModel from './models/URIFragmentModel';
 import ManifestModel from './models/ManifestModel';
 import MediaPlayerModel from './models/MediaPlayerModel';
@@ -62,7 +60,7 @@ import Settings from '../core/Settings';
 import {
     getVersionString
 }
-    from './../core/Version';
+    from '../core/Version';
 
 //Dash
 import SegmentBaseController from '../dash/controllers/SegmentBaseController';
@@ -79,6 +77,7 @@ import {checkParameterType} from './utils/SupervisorTools';
 import ManifestUpdater from './ManifestUpdater';
 import URLUtils from '../streaming/utils/URLUtils';
 import BoxParser from './utils/BoxParser';
+import TextController from './text/TextController';
 
 /* jscs:disable */
 /**
@@ -149,13 +148,13 @@ function MediaPlayer() {
         capabilities,
         capabilitiesFilter,
         streamController,
+        textController,
         gapController,
         playbackController,
         dashMetrics,
         manifestModel,
         cmcdModel,
         videoModel,
-        textController,
         uriFragmentModel,
         domStorage,
         segmentBaseController,
@@ -210,6 +209,9 @@ function MediaPlayer() {
         if (config.streamController) {
             streamController = config.streamController;
         }
+        if (config.textController) {
+            textController = config.textController;
+        }
         if (config.gapController) {
             gapController = config.gapController;
         }
@@ -307,7 +309,7 @@ function MediaPlayer() {
         dashMetrics = DashMetrics(context).getInstance({
             settings: settings
         });
-        textController = TextController(context).getInstance();
+
         domStorage = DOMStorage(context).getInstance({
             settings: settings
         });
@@ -353,7 +355,7 @@ function MediaPlayer() {
         setAutoPlay(AutoPlay !== undefined ? AutoPlay : true);
 
         // Detect and initialize offline module to support offline contents playback
-        detectOffline();
+        _detectOffline();
 
         if (view) {
             attachView(view);
@@ -482,28 +484,6 @@ function MediaPlayer() {
     ---------------------------------------------------------------------------
     */
 
-    /**
-     * Causes the player to begin streaming the media as set by the {@link module:MediaPlayer#attachSource attachSource()}
-     * method in preparation for playing. It specifically does not require a view to be attached with {@link module:MediaPlayer#attachSource attachView()} to begin preloading.
-     * When a view is attached after preloading, the buffered data is transferred to the attached mediaSource buffers.
-     *
-     * @see {@link module:MediaPlayer#attachSource attachSource()}
-     * @see {@link module:MediaPlayer#attachView attachView()}
-     * @memberof module:MediaPlayer
-     * @throws {@link module:MediaPlayer~SOURCE_NOT_ATTACHED_ERROR SOURCE_NOT_ATTACHED_ERROR} if called before attachSource function
-     * @instance
-     */
-    function preload() {
-        if (videoModel.getElement() || streamingInitialized) {
-            return false;
-        }
-        if (source) {
-            initializePlayback();
-        } else {
-            throw SOURCE_NOT_ATTACHED_ERROR;
-        }
-    }
-
     /**
      * The play method initiates playback of the media defined by the {@link module:MediaPlayer#attachSource attachSource()} method.
      * This method will call play on the native Video Element.
@@ -708,7 +688,7 @@ function MediaPlayer() {
     /**
      * The timeShiftBufferLength (DVR Window), in seconds.
      *
-     * @returns {number} The window of allowable play time behind the live point of a live stream.
+     * @returns {number} The window of allowable play time behind the live point of a live stream as defined in the manifest.
      * @memberof module:MediaPlayer
      * @instance
      */
@@ -779,7 +759,7 @@ function MediaPlayer() {
     /**
      * Duration of the media's playback, in seconds.
      *
-     * @returns {number} The current duration of the media.
+     * @returns {number} The current duration of the media. For a dynamic stream this will return DVRWindow.end - DVRWindow.start
      * @memberof module:MediaPlayer
      * @throws {@link module:MediaPlayer~PLAYBACK_NOT_INITIALIZED_ERROR PLAYBACK_NOT_INITIALIZED_ERROR} if called before initializePlayback function
      * @instance
@@ -813,7 +793,7 @@ function MediaPlayer() {
         if (time() < 0) {
             return NaN;
         }
-        return getAsUTC(time());
+        return _getAsUTC(time());
     }
 
     /**
@@ -829,7 +809,7 @@ function MediaPlayer() {
         if (!playbackInitialized) {
             throw PLAYBACK_NOT_INITIALIZED_ERROR;
         }
-        return getAsUTC(duration());
+        return _getAsUTC(duration());
     }
 
     /*
@@ -963,7 +943,7 @@ function MediaPlayer() {
     /**
      * @memberof module:MediaPlayer
      * @instance
-     * @returns {number|NaN} Current live stream latency in seconds. It is the difference between current time and time position at the playback head.
+     * @returns {number|NaN} Current live stream latency in seconds. It is the difference between now time and time position at the playback head.
      * @throws {@link module:MediaPlayer~MEDIA_PLAYER_NOT_INITIALIZED_ERROR MEDIA_PLAYER_NOT_INITIALIZED_ERROR} if called before initialize function
      */
     function getCurrentLiveLatency() {
@@ -1146,7 +1126,7 @@ function MediaPlayer() {
      * @instance
      */
     function getOfflineController() {
-        return detectOffline();
+        return _detectOffline();
     }
 
     /*
@@ -1176,70 +1156,6 @@ function MediaPlayer() {
 
     ---------------------------------------------------------------------------
     */
-    /**
-     * Set default language for text. If default language is not one of text tracks, dash will choose the first one.
-     *
-     * @param {string} lang - default language
-     * @memberof module:MediaPlayer
-     * @instance
-     * @deprecated will be removed in version 3.2.0. Please use setInitialMediaSettingsFor("fragmentedText", { lang: lang }) instead
-     */
-    function setTextDefaultLanguage(lang) {
-        logger.warn('setTextDefaultLanguage is deprecated and will be removed in version 3.2.0. Please use setInitialMediaSettingsFor("fragmentedText", { lang: lang }) instead');
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
-        }
-        textController.setTextDefaultLanguage(lang);
-    }
-
-    /**
-     * Get default language for text.
-     *
-     * @return {string} the default language if it has been set using setTextDefaultLanguage
-     * @memberof module:MediaPlayer
-     * @instance
-     * @deprecated will be removed in version 3.2.0. Please use getInitialMediaSettingsFor("fragmentedText").lang instead
-     */
-    function getTextDefaultLanguage() {
-        logger.warn('getTextDefaultLanguage is deprecated and will be removed in version 3.2.0. Please use getInitialMediaSettingsFor("fragmentedText").lang instead');
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
-        }
-
-        return textController.getTextDefaultLanguage();
-    }
-
-    /**
-     * Set enabled default state.
-     * This is used to enable/disable text when a file is loaded.
-     * During playback, use enableText to enable text for the file
-     *
-     * @param {boolean} enable - true to enable text, false otherwise
-     * @memberof module:MediaPlayer
-     * @instance
-     */
-    function setTextDefaultEnabled(enable) {
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
-        }
-
-        textController.setTextDefaultEnabled(enable);
-    }
-
-    /**
-     * Get enabled default state.
-     *
-     * @return {boolean}  default enable state
-     * @memberof module:MediaPlayer
-     * @instance
-     */
-    function getTextDefaultEnabled() {
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
-        }
-
-        return textController.getTextDefaultEnabled();
-    }
 
     /**
      * Enable/disable text
@@ -1250,11 +1166,13 @@ function MediaPlayer() {
      * @instance
      */
     function enableText(enable) {
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
+        const activeStreamInfo = streamController.getActiveStreamInfo();
+
+        if (!activeStreamInfo || !textController) {
+            return false;
         }
 
-        textController.enableText(enable);
+        return textController.enableText(activeStreamInfo.id, enable);
     }
 
     /**
@@ -1266,11 +1184,13 @@ function MediaPlayer() {
      * @instance
      */
     function enableForcedTextStreaming(enable) {
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
+        const activeStreamInfo = streamController.getActiveStreamInfo();
+
+        if (!activeStreamInfo || !textController) {
+            return false;
         }
 
-        textController.enableForcedTextStreaming(enable);
+        return textController.enableForcedTextStreaming(activeStreamInfo.id, enable);
     }
 
     /**
@@ -1281,11 +1201,13 @@ function MediaPlayer() {
      * @instance
      */
     function isTextEnabled() {
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
+        const activeStreamInfo = streamController.getActiveStreamInfo();
+
+        if (!activeStreamInfo || !textController) {
+            return false;
         }
 
-        return textController.isTextEnabled();
+        return textController.isTextEnabled(activeStreamInfo);
     }
 
     /**
@@ -1302,35 +1224,27 @@ function MediaPlayer() {
             throw PLAYBACK_NOT_INITIALIZED_ERROR;
         }
 
-        if (textController === undefined) {
-            textController = TextController(context).getInstance();
+        const activeStreamInfo = streamController.getActiveStreamInfo();
+
+        if (!activeStreamInfo || !textController) {
+            return;
         }
 
-        textController.setTextTrack(idx);
+        textController.setTextTrack(activeStreamInfo.id, idx);
     }
 
     function getCurrentTextTrackIndex() {
         let idx = NaN;
-        if (textController) {
-            idx = textController.getCurrentTrackIdx();
+
+        const activeStreamInfo = streamController.getActiveStreamInfo();
+
+        if (!activeStreamInfo || !textController) {
+            return;
         }
-        return idx;
-    }
 
-    /**
-     * This method serves to control captions z-index value. If 'true' is passed, the captions will have the highest z-index and be
-     * displayed on top of other html elements. Default value is 'false' (z-index is not set).
-     * @param {boolean} value
-     * @memberof module:MediaPlayer
-     * @instance
-     */
-    function displayCaptionsOnTop(value) {
-        let textTracks = TextTracks(context).getInstance();
-        textTracks.setConfig({
-            videoModel: videoModel
-        });
-        textTracks.initialize();
-        textTracks.setDisplayCConTop(value);
+        idx = textController.getCurrentTrackIdx(activeStreamInfo.id);
+
+        return idx;
     }
 
     /*
@@ -1371,9 +1285,9 @@ function MediaPlayer() {
         videoModel.setElement(element);
 
         if (element) {
-            detectProtection();
-            detectMetricsReporting();
-            detectMss();
+            _detectProtection();
+            _detectMetricsReporting();
+            _detectMss();
 
             if (streamController) {
                 streamController.switchToVideoElement();
@@ -1381,10 +1295,10 @@ function MediaPlayer() {
         }
 
         if (playbackInitialized) { //Reset if we have been playing before, so this is a new element.
-            resetPlaybackControllers();
+            _resetPlaybackControllers();
         }
 
-        initializePlayback();
+        _initializePlayback();
     }
 
     /**
@@ -1462,7 +1376,7 @@ function MediaPlayer() {
             throw STREAMING_NOT_INITIALIZED_ERROR;
         }
         let streamInfo = streamController.getActiveStreamInfo();
-        return mediaController.getTracksFor(type, streamInfo);
+        return mediaController.getTracksFor(type, streamInfo.id);
     }
 
     /**
@@ -1498,7 +1412,7 @@ function MediaPlayer() {
             throw STREAMING_NOT_INITIALIZED_ERROR;
         }
         let streamInfo = streamController.getActiveStreamInfo();
-        return mediaController.getCurrentTrackFor(type, streamInfo);
+        return mediaController.getCurrentTrackFor(type, streamInfo.id);
     }
 
     /**
@@ -1522,9 +1436,6 @@ function MediaPlayer() {
             throw MEDIA_PLAYER_NOT_INITIALIZED_ERROR;
         }
         mediaController.setInitialSettings(type, value);
-        if (type === Constants.FRAGMENTED_TEXT) {
-            textController.setInitialSettings(value);
-        }
     }
 
     /**
@@ -1562,88 +1473,6 @@ function MediaPlayer() {
         mediaController.setTrack(track);
     }
 
-    /**
-     * This method returns the current track switch mode.
-     *
-     * @param {MediaType} type
-     * @returns {string} mode
-     * @memberof module:MediaPlayer
-     * @throws {@link module:MediaPlayer~MEDIA_PLAYER_NOT_INITIALIZED_ERROR MEDIA_PLAYER_NOT_INITIALIZED_ERROR} if called before initialize function
-     * @instance
-     */
-    function getTrackSwitchModeFor(type) {
-        if (!mediaPlayerInitialized) {
-            throw MEDIA_PLAYER_NOT_INITIALIZED_ERROR;
-        }
-        return mediaController.getSwitchMode(type);
-    }
-
-    /**
-     * This method sets the current track switch mode. Available options are:
-     *
-     * Constants.TRACK_SWITCH_MODE_NEVER_REPLACE
-     * (used to forbid clearing the buffered data (prior to current playback position) after track switch.
-     * Defers to fastSwitchEnabled for placement of new data. Default for video)
-     *
-     * Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE
-     * (used to clear the buffered data (prior to current playback position) after track switch. Default for audio)
-     *
-     * @param {MediaType} type
-     * @param {string} mode
-     * @memberof module:MediaPlayer
-     * @throws {@link module:MediaPlayer~MEDIA_PLAYER_NOT_INITIALIZED_ERROR MEDIA_PLAYER_NOT_INITIALIZED_ERROR} if called before initialize function
-     * @instance
-     */
-    function setTrackSwitchModeFor(type, mode) {
-        if (!mediaPlayerInitialized) {
-            throw MEDIA_PLAYER_NOT_INITIALIZED_ERROR;
-        }
-        mediaController.setSwitchMode(type, mode);
-    }
-
-    /**
-     * This method sets the selection mode for the initial track. This mode defines how the initial track will be selected
-     * if no initial media settings are set. If initial media settings are set this parameter will be ignored. Available options are:
-     *
-     * Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE
-     * This mode makes the player select the track with a highest bitrate. This mode is a default mode.
-     *
-     * Constants.TRACK_SELECTION_MODE_FIRST_TRACK
-     * This mode makes the player select the select the first track found in the manifest.
-     *
-     * Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY
-     * This mode makes the player select the track with the lowest bitrate per pixel average.
-     *
-     * Constants.TRACK_SELECTION_MODE_WIDEST_RANGE
-     * This mode makes the player select the track with a widest range of bitrates.
-     *
-     * @param {string} mode
-     * @memberof module:MediaPlayer
-     * @throws {@link module:MediaPlayer~MEDIA_PLAYER_NOT_INITIALIZED_ERROR MEDIA_PLAYER_NOT_INITIALIZED_ERROR} if called before initialize function
-     * @instance
-     */
-    function setSelectionModeForInitialTrack(mode) {
-        if (!mediaPlayerInitialized) {
-            throw MEDIA_PLAYER_NOT_INITIALIZED_ERROR;
-        }
-        mediaController.setSelectionModeForInitialTrack(mode);
-    }
-
-    /**
-     * This method returns the track selection mode.
-     *
-     * @returns {string} mode
-     * @memberof module:MediaPlayer
-     * @throws {@link module:MediaPlayer~MEDIA_PLAYER_NOT_INITIALIZED_ERROR MEDIA_PLAYER_NOT_INITIALIZED_ERROR} if called before initialize function
-     * @instance
-     */
-    function getSelectionModeForInitialTrack() {
-        if (!mediaPlayerInitialized) {
-            throw MEDIA_PLAYER_NOT_INITIALIZED_ERROR;
-        }
-        return mediaController.getSelectionModeForInitialTrack();
-    }
-
     /*
     ---------------------------------------------------------------------------
 
@@ -1658,7 +1487,7 @@ function MediaPlayer() {
      * @instance
      */
     function getProtectionController() {
-        return detectProtection();
+        return _detectProtection();
     }
 
     /**
@@ -1846,7 +1675,7 @@ function MediaPlayer() {
      * @instance
      */
     function retrieveManifest(url, callback) {
-        let manifestLoader = createManifestLoader();
+        let manifestLoader = _createManifestLoader();
         let self = this;
 
         const handler = function (e) {
@@ -1905,11 +1734,11 @@ function MediaPlayer() {
         source = urlOrManifest;
 
         if (streamingInitialized || playbackInitialized) {
-            resetPlaybackControllers();
+            _resetPlaybackControllers();
         }
 
         if (isReady()) {
-            initializePlayback();
+            _initializePlayback();
         }
     }
 
@@ -1934,7 +1763,7 @@ function MediaPlayer() {
      * @example
      * player.updateSettings({
      *      streaming: {
-     *          liveDelayFragmentCount: 8
+     *          lowLatencyEnabled: false,
      *          abr: {
      *              maxBitrate: { audio: 100, video: 1000 }
      *          }
@@ -2038,11 +1867,23 @@ function MediaPlayer() {
         return streamInfo ? streamController.getStreamById(streamInfo.id) : null;
     }
 
+    /**
+     * Returns the DashAdapter.js Module.
+     *
+     * @see {@link module:DashAdapter}
+     * @returns {Object}
+     * @memberof module:MediaPlayer
+     * @instance
+     */
+    function getDashAdapter() {
+        return adapter;
+    }
+
     //***********************************
     // PRIVATE METHODS
     //***********************************
 
-    function resetPlaybackControllers() {
+    function _resetPlaybackControllers() {
         playbackInitialized = false;
         streamingInitialized = false;
         adapter.reset();
@@ -2051,52 +1892,67 @@ function MediaPlayer() {
         playbackController.reset();
         abrController.reset();
         mediaController.reset();
-        textController.reset();
         if (protectionController) {
-            if (settings.get().streaming.keepProtectionMediaKeys) {
+            if (settings.get().streaming.protection.keepProtectionMediaKeys) {
                 protectionController.stop();
             } else {
                 protectionController.reset();
                 protectionController = null;
-                detectProtection();
+                _detectProtection();
             }
         }
+        textController.reset();
         cmcdModel.reset();
     }
 
-    function createPlaybackControllers() {
+    function _createPlaybackControllers() {
         // creates or get objects instances
-        const manifestLoader = createManifestLoader();
+        const manifestLoader = _createManifestLoader();
 
         if (!streamController) {
             streamController = StreamController(context).getInstance();
         }
 
+        if (!textController) {
+            textController = TextController(context).create({
+                errHandler,
+                manifestModel,
+                adapter,
+                mediaController,
+                videoModel,
+                settings
+            });
+        }
+
         capabilitiesFilter.setConfig({
             capabilities,
             adapter,
-            settings
+            settings,
+            manifestModel,
+            errHandler
         });
         capabilitiesFilter.setCustomCapabilitiesFilters(customCapabilitiesFilters);
 
         streamController.setConfig({
-            capabilities: capabilities,
+            capabilities,
             capabilitiesFilter,
-            manifestLoader: manifestLoader,
-            manifestModel: manifestModel,
-            mediaPlayerModel: mediaPlayerModel,
-            protectionController: protectionController,
-            adapter: adapter,
-            dashMetrics: dashMetrics,
-            errHandler: errHandler,
-            timelineConverter: timelineConverter,
-            videoModel: videoModel,
-            playbackController: playbackController,
-            abrController: abrController,
-            mediaController: mediaController,
-            textController: textController,
-            settings: settings,
-            baseURLController: baseURLController
+            manifestLoader,
+            manifestModel,
+            mediaPlayerModel,
+            protectionController,
+            textController,
+            adapter,
+            dashMetrics,
+            errHandler,
+            timelineConverter,
+            videoModel,
+            playbackController,
+            abrController,
+            mediaController,
+            settings,
+            baseURLController,
+            uriFragmentModel,
+            segmentBaseController
         });
 
         gapController.setConfig({
@@ -2109,33 +1965,23 @@ function MediaPlayer() {
         });
 
         playbackController.setConfig({
-            streamController: streamController,
-            dashMetrics: dashMetrics,
-            mediaPlayerModel: mediaPlayerModel,
-            adapter: adapter,
-            videoModel: videoModel,
-            timelineConverter: timelineConverter,
-            uriFragmentModel: uriFragmentModel,
-            settings: settings
+            streamController,
+            dashMetrics,
+            mediaPlayerModel,
+            adapter,
+            videoModel,
+            timelineConverter,
+            settings
         });
 
         abrController.setConfig({
-            streamController: streamController,
-            domStorage: domStorage,
-            mediaPlayerModel: mediaPlayerModel,
-            dashMetrics: dashMetrics,
-            adapter: adapter,
-            videoModel: videoModel,
-            settings: settings
-        });
-
-        textController.setConfig({
-            errHandler: errHandler,
-            manifestModel: manifestModel,
-            adapter: adapter,
-            mediaController: mediaController,
-            streamController: streamController,
-            videoModel: videoModel
+            streamController,
+            domStorage,
+            mediaPlayerModel,
+            dashMetrics,
+            adapter,
+            videoModel,
+            settings
         });
 
         cmcdModel.setConfig({
@@ -2145,12 +1991,14 @@ function MediaPlayer() {
         });
 
         // initialises controller
+        abrController.initialize();
         streamController.initialize(autoPlay, protectionData);
+        textController.initialize();
         gapController.initialize();
         cmcdModel.initialize();
     }
 
-    function createManifestLoader() {
+    function _createManifestLoader() {
         return ManifestLoader(context).create({
             debug: debug,
             errHandler: errHandler,
@@ -2162,7 +2010,7 @@ function MediaPlayer() {
         });
     }
 
-    function detectProtection() {
+    function _detectProtection() {
         if (protectionController) {
             return protectionController;
         }
@@ -2200,7 +2048,7 @@ function MediaPlayer() {
         return null;
     }
 
-    function detectMetricsReporting() {
+    function _detectMetricsReporting() {
         if (metricsReportingController) {
             return;
         }
@@ -2222,7 +2070,7 @@ function MediaPlayer() {
         }
     }
 
-    function detectMss() {
+    function _detectMss() {
         if (mssHandler) {
             return;
         }
@@ -2251,7 +2099,7 @@ function MediaPlayer() {
         }
     }
 
-    function detectOffline() {
+    function _detectOffline() {
         if (!mediaPlayerInitialized) {
             throw MEDIA_PLAYER_NOT_INITIALIZED_ERROR;
         }
@@ -2270,7 +2118,7 @@ function MediaPlayer() {
             });
             Errors.extend(OfflineController.errors);
 
-            const manifestLoader = createManifestLoader();
+            const manifestLoader = _createManifestLoader();
             const manifestUpdater = ManifestUpdater(context).create();
 
             manifestUpdater.setConfig({
@@ -2308,7 +2156,7 @@ function MediaPlayer() {
         return null;
     }
 
-    function getAsUTC(valToConvert) {
+    function _getAsUTC(valToConvert) {
         let metric = dashMetrics.getCurrentDVRInfo();
         let availableFrom,
             utcValue;
@@ -2321,7 +2169,7 @@ function MediaPlayer() {
         return utcValue;
     }
 
-    function initializePlayback() {
+    function _initializePlayback() {
 
         if (offlineController) {
             offlineController.resetRecords();
@@ -2330,7 +2178,7 @@ function MediaPlayer() {
         if (!streamingInitialized && source) {
             streamingInitialized = true;
             logger.info('Streaming Initialized');
-            createPlaybackControllers();
+            _createPlaybackControllers();
 
             if (typeof source === 'string') {
                 streamController.load(source);
@@ -2345,114 +2193,92 @@ function MediaPlayer() {
         }
     }
 
-    /**
-     * Returns the DashAdapter.js Module.
-     *
-     * @see {@link module:DashAdapter}
-     * @returns {Object}
-     * @memberof module:MediaPlayer
-     * @instance
-     */
-    function getDashAdapter() {
-        return adapter;
-    }
-
     instance = {
-        initialize: initialize,
-        setConfig: setConfig,
-        on: on,
-        off: off,
-        extend: extend,
-        attachView: attachView,
-        attachSource: attachSource,
-        isReady: isReady,
-        preload: preload,
-        play: play,
-        isPaused: isPaused,
-        pause: pause,
-        isSeeking: isSeeking,
-        isDynamic: isDynamic,
-        seek: seek,
-        setPlaybackRate: setPlaybackRate,
-        getPlaybackRate: getPlaybackRate,
-        setMute: setMute,
-        isMuted: isMuted,
-        setVolume: setVolume,
-        getVolume: getVolume,
-        time: time,
-        duration: duration,
-        timeAsUTC: timeAsUTC,
-        durationAsUTC: durationAsUTC,
-        getActiveStream: getActiveStream,
-        getDVRWindowSize: getDVRWindowSize,
-        getDVRSeekOffset: getDVRSeekOffset,
-        convertToTimeCode: convertToTimeCode,
-        formatUTC: formatUTC,
-        getVersion: getVersion,
-        getDebug: getDebug,
-        getBufferLength: getBufferLength,
-        getTTMLRenderingDiv: getTTMLRenderingDiv,
-        getVideoElement: getVideoElement,
-        getSource: getSource,
-        getCurrentLiveLatency: getCurrentLiveLatency,
-        getTopBitrateInfoFor: getTopBitrateInfoFor,
-        setAutoPlay: setAutoPlay,
-        getAutoPlay: getAutoPlay,
-        getDashMetrics: getDashMetrics,
-        getQualityFor: getQualityFor,
-        setQualityFor: setQualityFor,
-        updatePortalSize: updatePortalSize,
-        setTextDefaultLanguage: setTextDefaultLanguage,
-        getTextDefaultLanguage: getTextDefaultLanguage,
-        setTextDefaultEnabled: setTextDefaultEnabled,
-        getTextDefaultEnabled: getTextDefaultEnabled,
-        enableText: enableText,
-        enableForcedTextStreaming: enableForcedTextStreaming,
-        isTextEnabled: isTextEnabled,
-        setTextTrack: setTextTrack,
-        getBitrateInfoListFor: getBitrateInfoListFor,
-        getStreamsFromManifest: getStreamsFromManifest,
-        getTracksFor: getTracksFor,
-        getTracksForTypeFromManifest: getTracksForTypeFromManifest,
-        getCurrentTrackFor: getCurrentTrackFor,
-        setInitialMediaSettingsFor: setInitialMediaSettingsFor,
-        getInitialMediaSettingsFor: getInitialMediaSettingsFor,
-        setCurrentTrack: setCurrentTrack,
-        getTrackSwitchModeFor: getTrackSwitchModeFor,
-        setTrackSwitchModeFor: setTrackSwitchModeFor,
-        setSelectionModeForInitialTrack: setSelectionModeForInitialTrack,
-        getSelectionModeForInitialTrack: getSelectionModeForInitialTrack,
-        addABRCustomRule: addABRCustomRule,
-        removeABRCustomRule: removeABRCustomRule,
-        removeAllABRCustomRule: removeAllABRCustomRule,
-        getAverageThroughput: getAverageThroughput,
-        retrieveManifest: retrieveManifest,
-        addUTCTimingSource: addUTCTimingSource,
-        removeUTCTimingSource: removeUTCTimingSource,
-        clearDefaultUTCTimingSources: clearDefaultUTCTimingSources,
-        restoreDefaultUTCTimingSources: restoreDefaultUTCTimingSources,
-        setXHRWithCredentialsForType: setXHRWithCredentialsForType,
-        getXHRWithCredentialsForType: getXHRWithCredentialsForType,
-        getProtectionController: getProtectionController,
-        attachProtectionController: attachProtectionController,
-        setProtectionData: setProtectionData,
-        registerLicenseRequestFilter: registerLicenseRequestFilter,
-        registerLicenseResponseFilter: registerLicenseResponseFilter,
-        unregisterLicenseRequestFilter: unregisterLicenseRequestFilter,
-        unregisterLicenseResponseFilter: unregisterLicenseResponseFilter,
+        initialize,
+        setConfig,
+        on,
+        off,
+        extend,
+        attachView,
+        attachSource,
+        isReady,
+        play,
+        isPaused,
+        pause,
+        isSeeking,
+        isDynamic,
+        seek,
+        setPlaybackRate,
+        getPlaybackRate,
+        setMute,
+        isMuted,
+        setVolume,
+        getVolume,
+        time,
+        duration,
+        timeAsUTC,
+        durationAsUTC,
+        getActiveStream,
+        getDVRWindowSize,
+        getDVRSeekOffset,
+        convertToTimeCode,
+        formatUTC,
+        getVersion,
+        getDebug,
+        getBufferLength,
+        getTTMLRenderingDiv,
+        getVideoElement,
+        getSource,
+        getCurrentLiveLatency,
+        getTopBitrateInfoFor,
+        setAutoPlay,
+        getAutoPlay,
+        getDashMetrics,
+        getQualityFor,
+        setQualityFor,
+        updatePortalSize,
+        enableText,
+        enableForcedTextStreaming,
+        isTextEnabled,
+        setTextTrack,
+        getBitrateInfoListFor,
+        getStreamsFromManifest,
+        getTracksFor,
+        getTracksForTypeFromManifest,
+        getCurrentTrackFor,
+        setInitialMediaSettingsFor,
+        getInitialMediaSettingsFor,
+        setCurrentTrack,
+        addABRCustomRule,
+        removeABRCustomRule,
+        removeAllABRCustomRule,
+        getAverageThroughput,
+        retrieveManifest,
+        addUTCTimingSource,
+        removeUTCTimingSource,
+        clearDefaultUTCTimingSources,
+        restoreDefaultUTCTimingSources,
+        setXHRWithCredentialsForType,
+        getXHRWithCredentialsForType,
+        getProtectionController,
+        attachProtectionController,
+        setProtectionData,
+        registerLicenseRequestFilter,
+        registerLicenseResponseFilter,
+        unregisterLicenseRequestFilter,
+        unregisterLicenseResponseFilter,
         registerCustomCapabilitiesFilter,
         unregisterCustomCapabilitiesFilter,
-        displayCaptionsOnTop: displayCaptionsOnTop,
-        attachTTMLRenderingDiv: attachTTMLRenderingDiv,
-        getCurrentTextTrackIndex: getCurrentTextTrackIndex,
-        provideThumbnail: provideThumbnail,
-        getDashAdapter: getDashAdapter,
-        getOfflineController: getOfflineController,
-        getSettings: getSettings,
-        updateSettings: updateSettings,
-        resetSettings: resetSettings,
-        reset: reset,
-        destroy: destroy
+        attachTTMLRenderingDiv,
+        getCurrentTextTrackIndex,
+        provideThumbnail,
+        getDashAdapter,
+        getOfflineController,
+        getSettings,
+        updateSettings,
+        resetSettings,
+        reset,
+        destroy
     };
 
     setup();
diff --git a/src/streaming/MediaPlayerEvents.js b/src/streaming/MediaPlayerEvents.js
index 74867f6d0b..418b2fd344 100644
--- a/src/streaming/MediaPlayerEvents.js
+++ b/src/streaming/MediaPlayerEvents.js
@@ -69,6 +69,12 @@ class MediaPlayerEvents extends EventsBase {
          */
         this.BUFFER_LEVEL_STATE_CHANGED = 'bufferStateChanged';
 
+        /**
+         * Triggered when the buffer level of a media type has been updated
+         * @event MediaPlayerEvents#BUFFER_LEVEL_UPDATED
+         */
+        this.BUFFER_LEVEL_UPDATED = 'bufferLevelUpdated';
+
         /**
          * Triggered when a dynamic stream changed to static (transition phase between Live and On-Demand).
          * @event MediaPlayerEvents#DYNAMIC_TO_STATIC
@@ -147,10 +153,10 @@ class MediaPlayerEvents extends EventsBase {
         this.PERIOD_SWITCH_COMPLETED = 'periodSwitchCompleted';
 
         /**
-         * Triggered when a new period starts.
-         * @event MediaPlayerEvents#PERIOD_SWITCH_STARTED
+         * Triggered when a new stream (period) starts.
+         * @event MediaPlayerEvents#STREAM_SWITCH_STARTED
          */
-        this.PERIOD_SWITCH_STARTED = 'periodSwitchStarted';
+        this.STREAM_SWITCH_STARTED = 'streamSwitchStarted';
 
         /**
          * Triggered when an ABR up /down switch is initiated; either by user in manual mode or auto mode via ABR rules.
@@ -189,7 +195,19 @@ class MediaPlayerEvents extends EventsBase {
         this.STREAM_UPDATED = 'streamUpdated';
 
         /**
-         * Triggered when a stream (period) is updated
+         * Triggered when a stream (period) is activated
+         * @event MediaPlayerEvents#STREAM_ACTIVATED
+         */
+        this.STREAM_ACTIVATED = 'streamActivated';
+
+        /**
+         * Triggered when a stream (period) is deactivated
+         * @event MediaPlayerEvents#STREAM_DEACTIVATED
+         */
+        this.STREAM_DEACTIVATED = 'streamDeactivated';
+
+        /**
+         * Triggered when a stream (period) is activated
          * @event MediaPlayerEvents#STREAM_INITIALIZED
          */
         this.STREAM_INITIALIZED = 'streamInitialized';
@@ -244,6 +262,12 @@ class MediaPlayerEvents extends EventsBase {
          */
         this.CAN_PLAY = 'canPlay';
 
+        /**
+         * This corresponds to the CAN_PLAY_THROUGH readyState.
+         * @event MediaPlayerEvents#CAN_PLAY_THROUGH
+         */
+        this.CAN_PLAY_THROUGH = 'canPlayThrough';
+
         /**
          * Sent when playback completes.
          * @event MediaPlayerEvents#PLAYBACK_ENDED
@@ -270,6 +294,13 @@ class MediaPlayerEvents extends EventsBase {
          */
         this.PLAYBACK_METADATA_LOADED = 'playbackMetaDataLoaded';
 
+        /**
+         * The media's metadata has finished loading; all attributes now
+         * contain as much useful information as they're going to.
+         * @event MediaPlayerEvents#PLAYBACK_METADATA_LOADED
+         */
+        this.PLAYBACK_LOADED_DATA = 'playbackLoadedData';
+
         /**
          * Sent when playback is paused.
          * @event MediaPlayerEvents#PLAYBACK_PAUSED
@@ -349,18 +380,6 @@ class MediaPlayerEvents extends EventsBase {
          */
         this.MANIFEST_VALIDITY_CHANGED = 'manifestValidityChanged';
 
-        /**
-         * A gap occured in the timeline which requires a seek to the next period
-         * @event MediaPlayerEvents#GAP_CAUSED_SEEK_TO_PERIOD_END
-         */
-        this.GAP_CAUSED_SEEK_TO_PERIOD_END = 'gapCausedSeekToPeriodEnd';
-
-        /**
-         * A gap occured in the timeline which requires an internal seek
-         * @event MediaPlayerEvents#GAP_CAUSED_INTERNAL_SEEK
-         */
-        this.GAP_CAUSED_INTERNAL_SEEK = 'gapCausedInternalSeek';
-
         /**
          * Dash events are triggered at their respective start points on the timeline.
          * @event MediaPlayerEvents#EVENT_MODE_ON_START
@@ -378,6 +397,12 @@ class MediaPlayerEvents extends EventsBase {
          * @event MediaPlayerEvents#CONFORMANCE_VIOLATION
          */
         this.CONFORMANCE_VIOLATION = 'conformanceViolation';
+
+        /**
+         * Event that is dispatched whenever the player is attempting to switch the quality
+         * @event MediaPlayerEvents#REPRESENTATION_CHANGED
+         */
+        this.SETTING_PLAYBACK_QUALITY = 'settingPlaybackQuality'
     }
 }
 
diff --git a/src/streaming/PreBufferSink.js b/src/streaming/PreBufferSink.js
index a6960223c6..57ca04af14 100644
--- a/src/streaming/PreBufferSink.js
+++ b/src/streaming/PreBufferSink.js
@@ -61,7 +61,9 @@ function PreBufferSink(onAppendedCallback) {
     function append(chunk) {
         if (chunk.segmentType !== 'InitializationSegment') { //Init segments are stored in the initCache.
             chunks.push(chunk);
-            chunks.sort(function (a, b) { return a.start - b.start; });
+            chunks.sort(function (a, b) {
+                return a.start - b.start;
+            });
             outstandingInit = null;
         } else {//We need to hold an init chunk for when a corresponding media segment is being downloaded when the discharge happens.
             outstandingInit = chunk;
@@ -76,7 +78,7 @@ function PreBufferSink(onAppendedCallback) {
     }
 
     function remove(start, end) {
-        chunks = chunks.filter( a => !((isNaN(end) || a.start < end) && (isNaN(start) || a.end > start))); //The opposite of the getChunks predicate.
+        chunks = chunks.filter(a => !((isNaN(end) || a.start < end) && (isNaN(start) || a.end > start))); //The opposite of the getChunks predicate.
     }
 
     //Nothing async, nothing to abort.
@@ -89,7 +91,7 @@ function PreBufferSink(onAppendedCallback) {
         for (let i = 0; i < chunks.length; i++) {
             let chunk = chunks[i];
             if (ranges.length === 0 || chunk.start > ranges[ranges.length - 1].end) {
-                ranges.push({ start: chunk.start, end: chunk.end });
+                ranges.push({start: chunk.start, end: chunk.end});
             } else {
                 ranges[ranges.length - 1].end = chunk.end;
             }
@@ -114,10 +116,6 @@ function PreBufferSink(onAppendedCallback) {
         return timeranges;
     }
 
-    function hasDiscontinuitiesAfter() {
-        return false;
-    }
-
     function updateTimestampOffset() {
         // Nothing to do
     }
@@ -148,7 +146,7 @@ function PreBufferSink(onAppendedCallback) {
     }
 
     function getChunksAt(start, end) {
-        return chunks.filter( a => ((isNaN(end) || a.start < end) && (isNaN(start) || a.end > start)) );
+        return chunks.filter(a => ((isNaN(end) || a.start < end) && (isNaN(start) || a.end > start)));
     }
 
     function waitForUpdateEnd(callback) {
@@ -163,7 +161,6 @@ function PreBufferSink(onAppendedCallback) {
         discharge: discharge,
         reset: reset,
         updateTimestampOffset: updateTimestampOffset,
-        hasDiscontinuitiesAfter: hasDiscontinuitiesAfter,
         waitForUpdateEnd: waitForUpdateEnd,
         getBuffer: getBuffer
     };
diff --git a/src/streaming/SourceBufferSink.js b/src/streaming/SourceBufferSink.js
index 2732d7dad9..6c442e0aae 100644
--- a/src/streaming/SourceBufferSink.js
+++ b/src/streaming/SourceBufferSink.js
@@ -30,38 +30,80 @@
  */
 import Debug from '../core/Debug';
 import DashJSError from './vo/DashJSError';
-import EventBus from '../core/EventBus';
-import Events from '../core/events/Events';
 import FactoryMaker from '../core/FactoryMaker';
-import TextController from './text/TextController';
 import Errors from '../core/errors/Errors';
+import Settings from '../core/Settings';
 
-const MAX_ALLOWED_DISCONTINUITY = 0.1; // 100 milliseconds
+const APPEND_WINDOW_START_OFFSET = 0.1;
+const APPEND_WINDOW_END_OFFSET = 0.01;
 
 /**
  * @class SourceBufferSink
  * @ignore
  * @implements FragmentSink
  */
-function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer) {
+
+const CHECK_INTERVAL = 50;
+
+function SourceBufferSink(config) {
     const context = this.context;
-    const eventBus = EventBus(context).getInstance();
+    const settings = Settings(context).getInstance();
+    const textController = config.textController;
 
     let instance,
         type,
         logger,
         buffer,
-        isAppendingInProgress,
+        mediaInfo,
         intervalId;
 
     let callbacks = [];
     let appendQueue = [];
-    let onAppended = onAppendedCallback;
+    let isAppendingInProgress = false;
+    let mediaSource = config.mediaSource;
 
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
-        isAppendingInProgress = false;
+    }
+
+    function initializeForStreamSwitch(mInfo, selectedRepresentation, oldSourceBufferSink) {
+        mediaInfo = mInfo;
+        type = mediaInfo.type;
+        const codec = mediaInfo.codec;
+
+        _copyPreviousSinkData(oldSourceBufferSink);
+        _addEventListeners();
+
+        const promises = [];
+
+        promises.push(_abortBeforeAppend);
+        promises.push(updateAppendWindow(mediaInfo.streamInfo));
+        promises.push(changeType(codec));
+
+        if (selectedRepresentation && selectedRepresentation.MSETimeOffset !== undefined) {
+            promises.push(updateTimestampOffset(selectedRepresentation.MSETimeOffset));
+        }
 
+        return Promise.all(promises);
+    }
+
+    function changeType(codec) {
+        return new Promise((resolve) => {
+            waitForUpdateEnd(() => {
+                if (buffer.changeType) {
+                    buffer.changeType(codec);
+                }
+                resolve();
+            });
+        });
+    }
+
+    function _copyPreviousSinkData(oldSourceBufferSink) {
+        buffer = oldSourceBufferSink.getBuffer();
+    }
+
+    function initializeForFirstUse(streamInfo, mInfo, selectedRepresentation) {
+        mediaInfo = mInfo;
         type = mediaInfo.type;
         const codec = mediaInfo.codec;
         try {
@@ -70,40 +112,52 @@ function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer)
             // - currently no browser does, so check for it and use our own
             // implementation. The same is true for codecs="wvtt".
             if (codec.match(/application\/mp4;\s*codecs="(stpp|wvtt).*"/i)) {
-                throw new Error('not really supported');
-            }
-            buffer = oldBuffer ? oldBuffer : mediaSource.addSourceBuffer(codec);
-            if (buffer.changeType && oldBuffer) {
-                logger.debug('Doing period transition with changeType');
-                buffer.changeType(codec);
+                return _initializeForText(streamInfo);
             }
 
-            updateAppendWindow();
+            buffer = mediaSource.addSourceBuffer(codec);
 
-            const CHECK_INTERVAL = 50;
-            // use updateend event if possible
-            if (typeof buffer.addEventListener === 'function') {
-                try {
-                    buffer.addEventListener('updateend', updateEndHandler, false);
-                    buffer.addEventListener('error', errHandler, false);
-                    buffer.addEventListener('abort', errHandler, false);
+            _addEventListeners();
 
-                } catch (err) {
-                    // use setInterval to periodically check if updating has been completed
-                    intervalId = setInterval(checkIsUpdateEnded, CHECK_INTERVAL);
-                }
-            } else {
-                // use setInterval to periodically check if updating has been completed
-                intervalId = setInterval(checkIsUpdateEnded, CHECK_INTERVAL);
+            const promises = [];
+
+            promises.push(updateAppendWindow(mediaInfo.streamInfo));
+
+            if (selectedRepresentation && selectedRepresentation.MSETimeOffset !== undefined) {
+                promises.push(updateTimestampOffset(selectedRepresentation.MSETimeOffset));
             }
-        } catch (ex) {
+
+            return Promise.all(promises);
+
+        } catch (e) {
             // Note that in the following, the quotes are open to allow for extra text after stpp and wvtt
             if ((mediaInfo.isText) || (codec.indexOf('codecs="stpp') !== -1) || (codec.indexOf('codecs="wvtt') !== -1)) {
-                const textController = TextController(context).getInstance();
-                buffer = textController.getTextSourceBuffer();
-            } else {
-                throw ex;
+                return _initializeForText(streamInfo);
             }
+            return Promise.reject(e);
+        }
+    }
+
+    function _initializeForText(streamInfo) {
+        buffer = textController.getTextSourceBuffer(streamInfo);
+        return Promise.resolve();
+    }
+
+    function _addEventListeners() {
+        // use updateend event if possible
+        if (typeof buffer.addEventListener === 'function') {
+            try {
+                buffer.addEventListener('updateend', updateEndHandler, false);
+                buffer.addEventListener('error', errHandler, false);
+                buffer.addEventListener('abort', errHandler, false);
+
+            } catch (err) {
+                // use setInterval to periodically check if updating has been completed
+                intervalId = setInterval(updateEndHandler, CHECK_INTERVAL);
+            }
+        } else {
+            // use setInterval to periodically check if updating has been completed
+            intervalId = setInterval(updateEndHandler, CHECK_INTERVAL);
         }
     }
 
@@ -111,30 +165,97 @@ function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer)
         return type;
     }
 
-    function reset(keepBuffer) {
-        if (buffer) {
+    function _removeEventListeners() {
+        try {
             if (typeof buffer.removeEventListener === 'function') {
                 buffer.removeEventListener('updateend', updateEndHandler, false);
                 buffer.removeEventListener('error', errHandler, false);
                 buffer.removeEventListener('abort', errHandler, false);
             }
             clearInterval(intervalId);
-            callbacks = [];
-            if (!keepBuffer) {
+        } catch (e) {
+            logger.error(e);
+        }
+    }
+
+    function updateAppendWindow(sInfo) {
+        return new Promise((resolve) => {
+
+            if (!buffer || !settings.get().streaming.buffer.useAppendWindow) {
+                resolve();
+                return;
+            }
+
+            waitForUpdateEnd(() => {
+                try {
+                    if (!buffer) {
+                        resolve();
+                        return;
+                    }
+
+                    let appendWindowEnd = mediaSource.duration;
+                    let appendWindowStart = 0;
+                    if (sInfo && !isNaN(sInfo.start) && !isNaN(sInfo.duration) && isFinite(sInfo.duration)) {
+                        appendWindowEnd = sInfo.start + sInfo.duration;
+                    }
+                    if (sInfo && !isNaN(sInfo.start)) {
+                        appendWindowStart = sInfo.start;
+                    }
+                    if (buffer.appendWindowEnd !== appendWindowEnd || buffer.appendWindowStart !== appendWindowStart) {
+                        buffer.appendWindowStart = 0;
+                        buffer.appendWindowEnd = appendWindowEnd + APPEND_WINDOW_END_OFFSET;
+                        buffer.appendWindowStart = Math.max(appendWindowStart - APPEND_WINDOW_START_OFFSET, 0);
+                        logger.debug(`Updated append window for ${mediaInfo.type}. Set start to ${buffer.appendWindowStart} and end to ${buffer.appendWindowEnd}`);
+                    }
+
+                    resolve();
+                } catch (e) {
+                    logger.warn(`Failed to set append window`);
+                    resolve();
+                }
+            });
+        });
+    }
+
+    function updateTimestampOffset(MSETimeOffset) {
+        return new Promise((resolve) => {
+
+            if (!buffer) {
+                resolve();
+                return;
+            }
+
+            waitForUpdateEnd(() => {
                 try {
-                    if (!buffer.getClassName || buffer.getClassName() !== 'TextSourceBuffer') {
-                        logger.debug(`Removing sourcebuffer from media source`);
-                        mediaSource.removeSourceBuffer(buffer);
+                    if (buffer.timestampOffset !== MSETimeOffset && !isNaN(MSETimeOffset)) {
+                        buffer.timestampOffset = MSETimeOffset;
+                        logger.debug(`Set MSE timestamp offset to ${MSETimeOffset}`);
                     }
+                    resolve();
                 } catch (e) {
-                    logger.error('Failed to remove source buffer from media source.');
+                    resolve();
                 }
-                buffer = null;
+            });
+        });
+    }
+
+
+    function reset() {
+        if (buffer) {
+            try {
+                callbacks = [];
+                _removeEventListeners();
+                isAppendingInProgress = false;
+                appendQueue = [];
+                if (!buffer.getClassName || buffer.getClassName() !== 'TextSourceBuffer') {
+                    logger.debug(`Removing sourcebuffer from media source`);
+                    mediaSource.removeSourceBuffer(buffer);
+                }
+            } catch (e) {
+
             }
-            isAppendingInProgress = false;
+            buffer = null;
         }
-        appendQueue = [];
-        onAppended = null;
     }
 
     function getBuffer() {
@@ -150,135 +271,101 @@ function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer)
         }
     }
 
-    function hasDiscontinuitiesAfter(time) {
-        try {
-            const ranges = getAllBufferRanges();
-            if (ranges && ranges.length > 1) {
-                for (let i = 0, len = ranges.length; i < len; i++) {
-                    if (i > 0) {
-                        if (time < ranges.start(i) && ranges.start(i) > ranges.end(i - 1) + MAX_ALLOWED_DISCONTINUITY) {
-                            return true;
-                        }
-                    }
-                }
-            }
-        } catch (e) {
-            logger.error('hasDiscontinuities exception: ' + e.message);
-        }
-        return false;
-    }
-
     function append(chunk) {
-        if (!chunk) {
-            onAppended({
-                chunk: chunk,
-                error: new DashJSError(Errors.APPEND_ERROR_CODE, Errors.APPEND_ERROR_MESSAGE)
-            });
-            return;
-        }
-        appendQueue.push(chunk);
-        if (!isAppendingInProgress) {
+        return new Promise((resolve, reject) => {
+            if (!chunk) {
+                reject({
+                    chunk: chunk,
+                    error: new DashJSError(Errors.APPEND_ERROR_CODE, Errors.APPEND_ERROR_MESSAGE)
+                });
+                return;
+            }
+            appendQueue.push({ data: chunk, promise: { resolve, reject } });
             waitForUpdateEnd(appendNextInQueue.bind(this));
-        }
+        });
     }
 
-    function updateTimestampOffset(MSETimeOffset) {
-        if (buffer.timestampOffset !== MSETimeOffset && !isNaN(MSETimeOffset)) {
+    function _abortBeforeAppend() {
+        return new Promise((resolve) => {
             waitForUpdateEnd(() => {
-                if (MSETimeOffset < 0) {
-                    MSETimeOffset += 0.001;
-                }
-                buffer.timestampOffset = MSETimeOffset;
-            });
-        }
-    }
+                // Save the append window, which is reset on abort().
+                const appendWindowStart = buffer.appendWindowStart;
+                const appendWindowEnd = buffer.appendWindowEnd;
 
-    function updateAppendWindow(sInfo) {
-        if (!buffer) {
-            return;
-        }
-        waitForUpdateEnd(() => {
-            try {
-                let appendWindowEnd = mediaSource.duration;
-                let appendWindowStart = 0;
-                if (sInfo && !isNaN(sInfo.start) && !isNaN(sInfo.duration) && isFinite(sInfo.duration)) {
-                    appendWindowEnd = sInfo.start + sInfo.duration;
-                }
-                if (sInfo && !isNaN(sInfo.start)) {
-                    appendWindowStart = sInfo.start;
-                }
-                buffer.appendWindowStart = 0;
-                buffer.appendWindowEnd = appendWindowEnd;
+                buffer.abort();
                 buffer.appendWindowStart = appendWindowStart;
-                logger.debug(`Updated append window. Set start to ${buffer.appendWindowStart} and end to ${buffer.appendWindowEnd}`);
-            } catch (e) {
-                logger.warn(`Failed to set append window`);
-            }
+                buffer.appendWindowEnd = appendWindowEnd;
+                resolve();
+            });
         });
     }
 
-    function remove(start, end, forceRemoval) {
-        const sourceBufferSink = this;
-        // make sure that the given time range is correct. Otherwise we will get InvalidAccessError
-        waitForUpdateEnd(function () {
-            try {
-                if ((start >= 0) && (end > start) && (forceRemoval || mediaSource.readyState !== 'ended')) {
+    function remove(range) {
+        return new Promise((resolve, reject) => {
+            const start = range.start;
+            const end = range.end;
+
+            // make sure that the given time range is correct. Otherwise we will get InvalidAccessError
+            if (!((start >= 0) && (end > start))) {
+                resolve();
+                return;
+            }
+
+            waitForUpdateEnd(function () {
+                try {
                     buffer.remove(start, end);
-                }
-                // updating is in progress, we should wait for it to complete before signaling that this operation is done
-                waitForUpdateEnd(function () {
-                    eventBus.trigger(Events.SOURCEBUFFER_REMOVE_COMPLETED, {
-                        buffer: sourceBufferSink,
+                    // updating is in progress, we should wait for it to complete before signaling that this operation is done
+                    waitForUpdateEnd(function () {
+                        resolve({
+                            from: start,
+                            to: end,
+                            unintended: false
+                        });
+                        if (range.resolve) {
+                            range.resolve();
+                        }
+                    });
+                } catch (err) {
+                    reject({
                         from: start,
                         to: end,
-                        unintended: false
+                        unintended: false,
+                        error: new DashJSError(err.code, err.message)
                     });
-                });
-            } catch (err) {
-                eventBus.trigger(Events.SOURCEBUFFER_REMOVE_COMPLETED, {
-                    buffer: sourceBufferSink,
-                    from: start,
-                    to: end,
-                    unintended: false,
-                    error: new DashJSError(err.code, err.message)
-                });
-            }
+                    if (range.reject) {
+                        range.reject(err);
+                    }
+                }
+            });
         });
     }
 
     function appendNextInQueue() {
-        const sourceBufferSink = this;
+        if (isAppendingInProgress) {
+            return;
+        }
 
         if (appendQueue.length > 0) {
             isAppendingInProgress = true;
             const nextChunk = appendQueue[0];
             appendQueue.splice(0, 1);
-            let oldRanges = [];
+
             const afterSuccess = function () {
-                // Safari sometimes drops a portion of a buffer after appending. Handle these situations here
-                const newRanges = getAllBufferRanges();
-                checkBufferGapsAfterAppend(sourceBufferSink, oldRanges, newRanges, nextChunk);
+                isAppendingInProgress = false;
                 if (appendQueue.length > 0) {
                     appendNextInQueue.call(this);
-                } else {
-                    isAppendingInProgress = false;
-                    if (onAppended) {
-                        onAppended({
-                            chunk: nextChunk
-                        });
-                    }
                 }
+                nextChunk.promise.resolve({ chunk: nextChunk.data });
             };
 
             try {
-                if (nextChunk.bytes.length === 0) {
+                if (nextChunk.data.bytes.byteLength === 0) {
                     afterSuccess.call(this);
                 } else {
-                    oldRanges = getAllBufferRanges();
                     if (buffer.appendBuffer) {
-                        buffer.appendBuffer(nextChunk.bytes);
+                        buffer.appendBuffer(nextChunk.data.bytes);
                     } else {
-                        buffer.append(nextChunk.bytes, nextChunk);
+                        buffer.append(nextChunk.data.bytes, nextChunk.data);
                     }
                     // updating is in progress, we should wait for it to complete before signaling that this operation is done
                     waitForUpdateEnd(afterSuccess.bind(this));
@@ -290,60 +377,37 @@ function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer)
                 } else {
                     isAppendingInProgress = false;
                 }
-
-                if (onAppended) {
-                    onAppended({
-                        chunk: nextChunk,
-                        error: new DashJSError(err.code, err.message)
-                    });
-                }
-            }
-        }
-    }
-
-    function checkBufferGapsAfterAppend(buffer, oldRanges, newRanges, chunk) {
-        if (oldRanges && oldRanges.length > 0 && oldRanges.length < newRanges.length &&
-            isChunkAlignedWithRange(oldRanges, chunk)) {
-            // A split in the range was created while appending
-            eventBus.trigger(Events.SOURCEBUFFER_REMOVE_COMPLETED, {
-                buffer: buffer,
-                from: newRanges.end(newRanges.length - 2),
-                to: newRanges.start(newRanges.length - 1),
-                unintended: true
-            });
-        }
-    }
-
-    function isChunkAlignedWithRange(oldRanges, chunk) {
-        for (let i = 0; i < oldRanges.length; i++) {
-            const start = Math.round(oldRanges.start(i));
-            const end = Math.round(oldRanges.end(i));
-            if (end === chunk.start || start === chunk.end || (chunk.start >= start && chunk.end <= end)) {
-                return true;
+                nextChunk.promise.reject({ chunk: nextChunk.data, error: new DashJSError(err.code, err.message) });
             }
         }
-        return false;
     }
 
     function abort() {
-        try {
-            if (mediaSource.readyState === 'open') {
-                buffer.abort();
-            } else if (buffer.setTextTrack && mediaSource.readyState === 'ended') {
-                buffer.abort(); //The cues need to be removed from the TextSourceBuffer via a call to abort()
+        return new Promise((resolve) => {
+            try {
+                appendQueue = [];
+                if (mediaSource.readyState === 'open') {
+                    waitForUpdateEnd(() => {
+                        buffer.abort();
+                        resolve();
+                    });
+                } else if (buffer && buffer.setTextTrack && mediaSource.readyState === 'ended') {
+                    buffer.abort(); //The cues need to be removed from the TextSourceBuffer via a call to abort()
+                    resolve();
+                } else {
+                    resolve();
+                }
+            } catch (e) {
+                resolve();
             }
-        } catch (ex) {
-            logger.error('SourceBuffer append abort failed: "' + ex + '"');
-        }
-        appendQueue = [];
+        });
+
     }
 
     function executeCallback() {
         if (callbacks.length > 0) {
-            const cb = callbacks.shift();
-            if (buffer.updating) {
-                waitForUpdateEnd(cb);
-            } else {
+            if (!buffer.updating) {
+                const cb = callbacks.shift();
                 cb();
                 // Try to execute next callback if still not updating
                 executeCallback();
@@ -351,16 +415,13 @@ function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer)
         }
     }
 
-    function checkIsUpdateEnded() {
-        // if updating is still in progress do nothing and wait for the next check again.
-        if (buffer.updating) return;
-        // updating is completed, now we can stop checking and resolve the promise
-        executeCallback();
-    }
-
     function updateEndHandler() {
-        if (buffer.updating) return;
+        // if updating is still in progress do nothing and wait for the next check again.
+        if (buffer.updating) {
+            return;
+        }
 
+        // updating is completed, now we can stop checking and resolve the promise
         executeCallback();
     }
 
@@ -377,17 +438,19 @@ function SourceBufferSink(mediaSource, mediaInfo, onAppendedCallback, oldBuffer)
     }
 
     instance = {
-        getType: getType,
-        getAllBufferRanges: getAllBufferRanges,
-        getBuffer: getBuffer,
-        append: append,
-        remove: remove,
-        abort: abort,
-        reset: reset,
-        updateTimestampOffset: updateTimestampOffset,
-        hasDiscontinuitiesAfter: hasDiscontinuitiesAfter,
-        waitForUpdateEnd: waitForUpdateEnd,
-        updateAppendWindow
+        getType,
+        getAllBufferRanges,
+        getBuffer,
+        append,
+        remove,
+        abort,
+        reset,
+        updateTimestampOffset,
+        waitForUpdateEnd,
+        initializeForStreamSwitch,
+        initializeForFirstUse,
+        updateAppendWindow,
+        changeType
     };
 
     setup();
diff --git a/src/streaming/Stream.js b/src/streaming/Stream.js
index c07e21de03..a88b63b3cb 100644
--- a/src/streaming/Stream.js
+++ b/src/streaming/Stream.js
@@ -42,6 +42,10 @@ import DashJSError from './vo/DashJSError';
 import BoxParser from './utils/BoxParser';
 import URLUtils from './utils/URLUtils';
 
+
+const MEDIA_TYPES = [Constants.VIDEO, Constants.AUDIO, Constants.TEXT, Constants.FRAGMENTED_TEXT, Constants.EMBEDDED_TEXT, Constants.MUXED, Constants.IMAGE];
+
+
 function Stream(config) {
 
     config = config || {};
@@ -51,29 +55,29 @@ function Stream(config) {
 
     const manifestModel = config.manifestModel;
     const mediaPlayerModel = config.mediaPlayerModel;
+    const dashMetrics = config.dashMetrics;
     const manifestUpdater = config.manifestUpdater;
     const adapter = config.adapter;
+    const timelineConverter = config.timelineConverter;
     const capabilities = config.capabilities;
-    const capabilitiesFilter = config.capabilitiesFilter;
     const errHandler = config.errHandler;
-    const timelineConverter = config.timelineConverter;
-    const dashMetrics = config.dashMetrics;
     const abrController = config.abrController;
     const playbackController = config.playbackController;
     const eventController = config.eventController;
     const mediaController = config.mediaController;
-    const textController = config.textController;
     const protectionController = config.protectionController;
+    const textController = config.textController;
     const videoModel = config.videoModel;
-    const settings = config.settings;
     let streamInfo = config.streamInfo;
+    const settings = config.settings;
+
 
     let instance,
         logger,
         streamProcessors,
-        isStreamInitialized,
-        isStreamActivated,
-        isMediaInitialized,
+        isInitialized,
+        isActive,
+        hasFinishedBuffering,
         hasVideoTrack,
         hasAudioTrack,
         updateError,
@@ -82,48 +86,68 @@ function Stream(config) {
         thumbnailController,
         preloaded,
         boxParser,
-        preloadingScheduled,
         debug,
         isEndedEventSignaled,
         trackChangedEvent;
 
+    /**
+     * Setup the stream
+     */
     function setup() {
-        debug = Debug(context).getInstance();
-        logger = debug.getLogger(instance);
-        resetInitialSettings();
+        try {
+            debug = Debug(context).getInstance();
+            logger = debug.getLogger(instance);
+            resetInitialSettings();
 
-        boxParser = BoxParser(context).getInstance();
+            boxParser = BoxParser(context).getInstance();
 
-        fragmentController = FragmentController(context).create({
-            streamInfo: streamInfo,
-            mediaPlayerModel: mediaPlayerModel,
-            dashMetrics: dashMetrics,
-            errHandler: errHandler,
-            settings: settings,
-            boxParser: boxParser,
-            dashConstants: DashConstants,
-            urlUtils: urlUtils
-        });
+            fragmentController = FragmentController(context).create({
+                streamInfo: streamInfo,
+                mediaPlayerModel: mediaPlayerModel,
+                dashMetrics: dashMetrics,
+                errHandler: errHandler,
+                settings: settings,
+                boxParser: boxParser,
+                dashConstants: DashConstants,
+                urlUtils: urlUtils
+            });
+
+        } catch (e) {
+            throw e;
+        }
     }
 
+    /**
+     * Initialize the events
+     */
     function initialize() {
         registerEvents();
         registerProtectionEvents();
+        textController.initializeForStream(streamInfo);
         eventBus.trigger(Events.STREAM_UPDATED, { streamInfo: streamInfo });
     }
 
+    /**
+     * Register the streaming events
+     */
     function registerEvents() {
         eventBus.on(Events.BUFFERING_COMPLETED, onBufferingCompleted, instance);
         eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance);
         eventBus.on(Events.INBAND_EVENTS, onInbandEvents, instance);
     }
 
+    /**
+     * Unregister the streaming events
+     */
     function unRegisterEvents() {
         eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance);
         eventBus.off(Events.BUFFERING_COMPLETED, onBufferingCompleted, instance);
         eventBus.off(Events.INBAND_EVENTS, onInbandEvents, instance);
     }
 
+    /**
+     * Register the protection events
+     */
     function registerProtectionEvents() {
         if (protectionController) {
             eventBus.on(Events.KEY_ERROR, onProtectionError, instance);
@@ -135,6 +159,9 @@ function Stream(config) {
         }
     }
 
+    /**
+     * Unregister the protection events
+     */
     function unRegisterProtectionEvents() {
         if (protectionController) {
             eventBus.off(Events.KEY_ERROR, onProtectionError, instance);
@@ -146,6 +173,10 @@ function Stream(config) {
         }
     }
 
+    /**
+     * Returns the stream id
+     * @return {*|null}
+     */
     function getStreamId() {
         return streamInfo ? streamInfo.id : null;
     }
@@ -153,27 +184,303 @@ function Stream(config) {
     /**
      * Activates Stream by re-initializing some of its components
      * @param {MediaSource} mediaSource
+     * @param {array} previousBufferSinks
      * @memberof Stream#
-     * @param {SourceBuffer} previousBuffers
      */
-    function activate(mediaSource, previousBuffers) {
-        if (!isStreamActivated) {
-            let result;
-            eventBus.on(Events.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, instance);
-            if (!getPreloaded()) {
-                result = initializeMedia(mediaSource, previousBuffers);
+    function activate(mediaSource, previousBufferSinks) {
+        return new Promise((resolve, reject) => {
+            if (isActive) {
+                resolve(previousBufferSinks);
+                return;
+            }
+
+            if (getPreloaded()) {
+                isActive = true;
+                eventBus.trigger(Events.STREAM_ACTIVATED, {
+                    streamInfo
+                });
+                resolve(previousBufferSinks);
+                return;
+            }
+
+
+            _initializeMedia(mediaSource, previousBufferSinks)
+                .then((bufferSinks) => {
+                    isActive = true;
+                    eventBus.trigger(Events.STREAM_ACTIVATED, {
+                        streamInfo
+                    });
+                    resolve(bufferSinks);
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
+    }
+
+    /**
+     *
+     * @param {object} mediaSource
+     * @param {array} previousBufferSinks
+     * @return {Promise<Array>}
+     * @private
+     */
+    function _initializeMedia(mediaSource, previousBufferSinks) {
+        return _commonMediaInitialization(mediaSource, previousBufferSinks);
+    }
+
+    function startPreloading(mediaSource, previousBuffers) {
+        return new Promise((resolve, reject) => {
+
+            if (getPreloaded()) {
+                reject();
+                return;
+            }
+
+            logger.info(`[startPreloading] Preloading next stream with id ${getId()}`);
+            setPreloaded(true);
+
+            _commonMediaInitialization(mediaSource, previousBuffers)
+                .then(() => {
+                    for (let i = 0; i < streamProcessors.length && streamProcessors[i]; i++) {
+                        streamProcessors[i].setExplicitBufferingTime(getStartTime());
+                        streamProcessors[i].getScheduleController().startScheduleTimer();
+                    }
+                    resolve();
+                })
+                .catch(() => {
+                    setPreloaded(false);
+                    reject();
+                });
+        });
+    }
+
+    /**
+     *
+     * @param {object} mediaSource
+     * @param {array} previousBufferSinks
+     * @return {Promise<array>}
+     * @private
+     */
+    function _commonMediaInitialization(mediaSource, previousBufferSinks) {
+        return new Promise((resolve, reject) => {
+            checkConfig();
+
+            isUpdating = true;
+            addInlineEvents();
+
+
+            let element = videoModel.getElement();
+
+            MEDIA_TYPES.forEach((mediaType) => {
+                if (mediaType !== Constants.VIDEO || (!element || (element && (/^VIDEO$/i).test(element.nodeName)))) {
+                    _initializeMediaForType(mediaType, mediaSource);
+                }
+            });
+
+            _createBufferSinks(previousBufferSinks)
+                .then((bufferSinks) => {
+                    isUpdating = false;
+
+                    if (streamProcessors.length === 0) {
+                        const msg = 'No streams to play.';
+                        errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_NOSTREAMS_CODE, msg, manifestModel.getValue()));
+                        logger.fatal(msg);
+                    } else {
+                        _checkIfInitializationCompleted();
+                    }
+
+                    // All mediaInfos for texttracks are added to the TextSourceBuffer by now. We can start creating the tracks
+                    textController.createTracks(streamInfo);
+
+                    resolve(bufferSinks);
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
+
+    }
+
+
+    /**
+     * Initialize for a given media type. Creates a corresponding StreamProcessor
+     * @param {string} type
+     * @param {object} mediaSource
+     * @private
+     */
+    function _initializeMediaForType(type, mediaSource) {
+        const allMediaForType = adapter.getAllMediaInfoForType(streamInfo, type);
+
+        let mediaInfo = null;
+        let initialMediaInfo;
+
+        if (!allMediaForType || allMediaForType.length === 0) {
+            logger.info('No ' + type + ' data.');
+            return;
+        }
+
+        if (type === Constants.VIDEO) {
+            hasVideoTrack = true;
+        }
+
+        if (type === Constants.AUDIO) {
+            hasAudioTrack = true;
+        }
+
+        for (let i = 0, ln = allMediaForType.length; i < ln; i++) {
+            mediaInfo = allMediaForType[i];
+
+            if (type === Constants.EMBEDDED_TEXT) {
+                textController.addEmbeddedTrack(streamInfo, mediaInfo);
             } else {
-                initializeAfterPreload();
-                result = previousBuffers;
+                if (_isMediaSupported(mediaInfo)) {
+                    mediaController.addTrack(mediaInfo);
+                }
             }
-            isStreamActivated = true;
-            return result;
         }
-        return previousBuffers;
+
+        if (type === Constants.EMBEDDED_TEXT) {
+            textController.addMediaInfosToBuffer(streamInfo, allMediaForType);
+        }
+
+        if (type === Constants.EMBEDDED_TEXT || mediaController.getTracksFor(type, streamInfo.id).length === 0) {
+            return;
+        }
+
+        if (type === Constants.IMAGE) {
+            thumbnailController = ThumbnailController(context).create({
+                streamInfo: streamInfo,
+                adapter: adapter,
+                baseURLController: config.baseURLController,
+                timelineConverter: config.timelineConverter,
+                debug: debug,
+                eventBus: eventBus,
+                events: Events,
+                dashConstants: DashConstants,
+                dashMetrics: config.dashMetrics,
+                segmentBaseController: config.segmentBaseController
+            });
+            thumbnailController.initialize();
+            return;
+        }
+
+
+        mediaController.setInitialMediaSettingsForType(type, streamInfo);
+        initialMediaInfo = mediaController.getCurrentTrackFor(type, streamInfo.id);
+
+        eventBus.trigger(Events.STREAM_INITIALIZING, {
+            streamInfo: streamInfo,
+            mediaInfo: mediaInfo
+        });
+
+        _createStreamProcessor(initialMediaInfo, allMediaForType, mediaSource);
+    }
+
+    function _isMediaSupported(mediaInfo) {
+        const type = mediaInfo ? mediaInfo.type : null;
+        let msg;
+
+        if (type === Constants.MUXED) {
+            msg = 'Multiplexed representations are intentionally not supported, as they are not compliant with the DASH-AVC/264 guidelines';
+            logger.fatal(msg);
+            errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_MULTIPLEXED_CODE, msg, manifestModel.getValue()));
+            return false;
+        }
+
+        if (type === Constants.TEXT || type === Constants.FRAGMENTED_TEXT || type === Constants.EMBEDDED_TEXT || type === Constants.IMAGE) {
+            return true;
+        }
+
+        if (!!mediaInfo.contentProtection && !capabilities.supportsEncryptedMedia()) {
+            errHandler.error(new DashJSError(Errors.CAPABILITY_MEDIAKEYS_ERROR_CODE, Errors.CAPABILITY_MEDIAKEYS_ERROR_MESSAGE));
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Creates the StreamProcessor for a given media type.
+     * @param {object} initialMediaInfo
+     * @param {array} allMediaForType
+     * @param {object} mediaSource
+     * @private
+     */
+    function _createStreamProcessor(initialMediaInfo, allMediaForType, mediaSource) {
+
+        let fragmentModel = fragmentController.getModel(initialMediaInfo ? initialMediaInfo.type : null);
+        const type = initialMediaInfo ? initialMediaInfo.type : null;
+        const mimeType = initialMediaInfo ? initialMediaInfo.mimeType : null;
+
+        let streamProcessor = StreamProcessor(context).create({
+            streamInfo: streamInfo,
+            type: type,
+            mimeType: mimeType,
+            timelineConverter: timelineConverter,
+            adapter: adapter,
+            manifestModel: manifestModel,
+            mediaPlayerModel: mediaPlayerModel,
+            fragmentModel: fragmentModel,
+            dashMetrics: config.dashMetrics,
+            baseURLController: config.baseURLController,
+            segmentBaseController: config.segmentBaseController,
+            abrController: abrController,
+            playbackController: playbackController,
+            mediaController: mediaController,
+            textController: textController,
+            errHandler: errHandler,
+            settings: settings,
+            boxParser: boxParser
+        });
+
+        streamProcessor.initialize(mediaSource, hasVideoTrack);
+        abrController.updateTopQualityIndex(initialMediaInfo);
+        streamProcessors.push(streamProcessor);
+
+        for (let i = 0; i < allMediaForType.length; i++) {
+            streamProcessor.addMediaInfo(allMediaForType[i]);
+        }
+
+        if (type === Constants.TEXT || type === Constants.FRAGMENTED_TEXT) {
+            textController.addMediaInfosToBuffer(streamInfo, allMediaForType, mimeType, fragmentModel);
+        }
+
+        if (initialMediaInfo) {
+            streamProcessor.selectMediaInfo(initialMediaInfo);
+        }
+    }
+
+    /**
+     * Creates the SourceBufferSink objects for all StreamProcessors
+     * @param {array} previousBuffers
+     * @return {Promise<object>}
+     * @private
+     */
+    function _createBufferSinks(previousBuffers) {
+        return new Promise((resolve) => {
+            const buffers = {};
+            const promises = streamProcessors.map((sp) => {
+                return sp.createBufferSinks(previousBuffers);
+            });
+
+            Promise.all(promises)
+                .then((bufferSinks) => {
+                    bufferSinks.forEach((sink) => {
+                        if (sink) {
+                            buffers[sink.getType()] = sink;
+                        }
+                    });
+                    resolve(buffers);
+                })
+                .catch(() => {
+                    resolve(buffers);
+                });
+        });
     }
 
     /**
-     * Partially resets some of the Stream elements
+     * Partially resets some of the Stream elements. This function is called when preloading of streams is canceled or a stream switch occurs.
      * @memberof Stream#
      * @param {boolean} keepBuffers
      */
@@ -182,23 +489,27 @@ function Stream(config) {
         const errored = false;
         for (let i = 0; i < ln; i++) {
             let fragmentModel = streamProcessors[i].getFragmentModel();
-            fragmentModel.removeExecutedRequestsBeforeTime(getStartTime() + getDuration());
+            fragmentModel.resetInitialSettings();
             streamProcessors[i].reset(errored, keepBuffers);
         }
+        if (textController) {
+            textController.deactivateStream(streamInfo);
+        }
         streamProcessors = [];
-        isStreamActivated = false;
-        isMediaInitialized = false;
+        isActive = false;
+        hasFinishedBuffering = false;
         setPreloaded(false);
-        eventBus.off(Events.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, instance);
+        setIsEndedEventSignaled(false);
+        eventBus.trigger(Events.STREAM_DEACTIVATED, { streamInfo });
     }
 
-    function isActive() {
-        return isStreamActivated;
+    function getIsActive() {
+        return isActive;
     }
 
     function setMediaSource(mediaSource) {
         for (let i = 0; i < streamProcessors.length;) {
-            if (isMediaSupported(streamProcessors[i].getMediaInfo())) {
+            if (_isMediaSupported(streamProcessors[i].getMediaInfo())) {
                 streamProcessors[i].setMediaSource(mediaSource);
                 i++;
             } else {
@@ -207,12 +518,6 @@ function Stream(config) {
             }
         }
 
-        for (let i = 0; i < streamProcessors.length; i++) {
-            //Adding of new tracks to a stream processor isn't guaranteed by the spec after the METADATA_LOADED state
-            //so do this after the buffers are created above.
-            streamProcessors[i].dischargePreBuffer();
-        }
-
         if (streamProcessors.length === 0) {
             const msg = 'No streams to play.';
             errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_NOSTREAMS_CODE, msg + 'nostreams', manifestModel.getValue()));
@@ -220,37 +525,35 @@ function Stream(config) {
         }
     }
 
-    function resetInitialSettings() {
-        deactivate();
-        isStreamInitialized = false;
+    function resetInitialSettings(keepBuffers) {
+        deactivate(keepBuffers);
+        isInitialized = false;
         hasVideoTrack = false;
         hasAudioTrack = false;
         updateError = {};
         isUpdating = false;
-        preloadingScheduled = false;
         isEndedEventSignaled = false;
     }
 
-    function reset() {
-
-        if (playbackController) {
-            playbackController.pause();
-        }
+    function reset(keepBuffers) {
 
         if (fragmentController) {
             fragmentController.reset();
             fragmentController = null;
         }
 
-        streamInfo = null;
+        if (abrController && streamInfo) {
+            abrController.clearDataForStream(streamInfo.id);
+        }
 
-        resetInitialSettings();
+        resetInitialSettings(keepBuffers);
+
+        streamInfo = null;
 
         unRegisterEvents();
 
         unRegisterProtectionEvents();
 
-        setPreloaded(false);
     }
 
     function getDuration() {
@@ -269,27 +572,6 @@ function Stream(config) {
         return streamInfo ? streamInfo.start : NaN;
     }
 
-    function getPreloadingScheduled() {
-        return preloadingScheduled;
-    }
-
-    function setPreloadingScheduled(value) {
-        preloadingScheduled = value;
-    }
-
-    function getLiveStartTime() {
-        if (!streamInfo.manifestInfo.isDynamic) return NaN;
-        // Get live start time of the video stream (1st in array of streams)
-        // or audio if no video stream
-        for (let i = 0; i < streamProcessors.length; i++) {
-            if (streamProcessors[i].getType() === Constants.AUDIO ||
-                streamProcessors[i].getType() === Constants.VIDEO) {
-                return streamProcessors[i].getLiveStartTime();
-            }
-        }
-        return NaN;
-    }
-
     function getId() {
         return streamInfo ? streamInfo.id : null;
     }
@@ -311,7 +593,7 @@ function Stream(config) {
     }
 
     function checkConfig() {
-        if (!videoModel || !abrController || !abrController.hasOwnProperty('getBitrateList') || !adapter || !adapter.hasOwnProperty('getAllMediaInfoForType') || !adapter.hasOwnProperty('getEventsFor')) {
+        if (!videoModel || !abrController) {
             throw new Error(Constants.MISSING_CONFIG_ERROR);
         }
     }
@@ -341,37 +623,13 @@ function Stream(config) {
         }
     }
 
-    function isMediaSupported(mediaInfo) {
-        const type = mediaInfo ? mediaInfo.type : null;
-        let codec,
-            msg;
-
-        if (type === Constants.MUXED) {
-            msg = 'Multiplexed representations are intentionally not supported, as they are not compliant with the DASH-AVC/264 guidelines';
-            logger.fatal(msg);
-            errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_MULTIPLEXED_CODE, msg, manifestModel.getValue()));
-            return false;
-        }
-
-        if (type === Constants.TEXT || type === Constants.FRAGMENTED_TEXT || type === Constants.EMBEDDED_TEXT || type === Constants.IMAGE) {
-            return true;
-        }
-        codec = mediaInfo.codec;
-        logger.debug(type + ' codec: ' + codec);
-
-        if (!!mediaInfo.contentProtection && !capabilities.supportsEncryptedMedia()) {
-            errHandler.error(new DashJSError(Errors.CAPABILITY_MEDIAKEYS_ERROR_CODE, Errors.CAPABILITY_MEDIAKEYS_ERROR_MESSAGE));
-        } else if (!capabilities.supportsCodec(codec)) {
-            msg = type + 'Codec (' + codec + ') is not supported.';
-            logger.error(msg);
-            return false;
+    function prepareTrackChange(e) {
+        if (!isActive || !streamInfo) {
+            return;
         }
 
-        return true;
-    }
+        hasFinishedBuffering = false;
 
-    function onCurrentTrackChanged(e) {
-        if (!streamInfo || e.newMediaInfo.streamInfo.id !== streamInfo.id) return;
         let mediaInfo = e.newMediaInfo;
         let manifest = manifestModel.getValue();
 
@@ -383,139 +641,20 @@ function Stream(config) {
         let currentTime = playbackController.getTime();
         logger.info('Stream -  Process track changed at current time ' + currentTime);
 
-        logger.debug('Stream -  Update stream controller');
-        if (manifest.refreshManifestOnSwitchTrack) { // Applies only for MSS streams
+        // Applies only for MSS streams
+        if (manifest.refreshManifestOnSwitchTrack) {
             logger.debug('Stream -  Refreshing manifest for switch track');
             trackChangedEvent = e;
             manifestUpdater.refreshManifest();
         } else {
-            processor.selectMediaInfo(mediaInfo);
-            if (mediaInfo.type !== Constants.FRAGMENTED_TEXT) {
-                abrController.updateTopQualityIndex(mediaInfo);
-                processor.switchTrackAsked();
-                processor.getFragmentModel().abortRequests();
-            } else {
-                processor.getScheduleController().setSeekTarget(currentTime);
-                processor.setBufferingTime(currentTime);
-                processor.resetIndexHandler();
-            }
-        }
-    }
-
-    function createStreamProcessor(mediaInfo, allMediaForType, mediaSource, optionalSettings) {
-
-        let fragmentModel = fragmentController.getModel(mediaInfo ? mediaInfo.type : null);
-
-        let streamProcessor = StreamProcessor(context).create({
-            streamInfo: streamInfo,
-            type: mediaInfo ? mediaInfo.type : null,
-            mimeType: mediaInfo ? mediaInfo.mimeType : null,
-            timelineConverter: timelineConverter,
-            adapter: adapter,
-            manifestModel: manifestModel,
-            mediaPlayerModel: mediaPlayerModel,
-            fragmentModel: fragmentModel,
-            dashMetrics: config.dashMetrics,
-            baseURLController: config.baseURLController,
-            abrController: abrController,
-            playbackController: playbackController,
-            mediaController: mediaController,
-            textController: textController,
-            errHandler: errHandler,
-            settings: settings,
-            boxParser: boxParser
-        });
-
-        streamProcessor.initialize(mediaSource, hasVideoTrack);
-        abrController.updateTopQualityIndex(mediaInfo);
-
-        if (optionalSettings) {
-            streamProcessor.setBuffer(optionalSettings.buffer);
-            streamProcessor.setBufferingTime(optionalSettings.currentTime);
-            streamProcessors[optionalSettings.replaceIdx] = streamProcessor;
-        } else {
-            streamProcessors.push(streamProcessor);
-        }
-
-        if (optionalSettings && optionalSettings.ignoreMediaInfo) {
-            return;
-        }
-
-        if (mediaInfo && (mediaInfo.type === Constants.TEXT || mediaInfo.type === Constants.FRAGMENTED_TEXT)) {
-            let idx;
-            for (let i = 0; i < allMediaForType.length; i++) {
-                if (allMediaForType[i].index === mediaInfo.index) {
-                    idx = i;
-                }
-                streamProcessor.addMediaInfo(allMediaForType[i]); //creates text tracks for all adaptations in one stream processor
-            }
-            streamProcessor.selectMediaInfo(allMediaForType[idx]); //sets the initial media info
-        } else {
-            streamProcessor.addMediaInfo(mediaInfo, true);
-        }
-    }
-
-    function initializeMediaForType(type, mediaSource) {
-        const allMediaForType = adapter.getAllMediaInfoForType(streamInfo, type);
-
-        let mediaInfo = null;
-        let initialMediaInfo;
-
-        if (!allMediaForType || allMediaForType.length === 0) {
-            logger.info('No ' + type + ' data.');
-            return;
-        }
-
-        if (type === Constants.VIDEO) {
-            hasVideoTrack = true;
-        }
-
-        if (type === Constants.AUDIO) {
-            hasAudioTrack = true;
-        }
-
-        for (let i = 0, ln = allMediaForType.length; i < ln; i++) {
-            mediaInfo = allMediaForType[i];
-
-            if (type === Constants.EMBEDDED_TEXT) {
-                textController.addEmbeddedTrack(mediaInfo);
-            } else {
-                if (!isMediaSupported(mediaInfo)) continue;
-                mediaController.addTrack(mediaInfo);
-            }
-        }
-
-        if (type === Constants.EMBEDDED_TEXT || mediaController.getTracksFor(type, streamInfo).length === 0) {
-            return;
-        }
-
-        if (type === Constants.IMAGE) {
-            thumbnailController = ThumbnailController(context).create({
-                streamInfo: streamInfo,
-                adapter: adapter,
-                baseURLController: config.baseURLController,
-                timelineConverter: config.timelineConverter,
-                debug: debug,
-                eventBus: eventBus,
-                events: Events,
-                dashConstants: DashConstants
-            });
-            return;
+            processor.selectMediaInfo(mediaInfo)
+                .then(() => {
+                    if (mediaInfo.type !== Constants.FRAGMENTED_TEXT) {
+                        abrController.updateTopQualityIndex(mediaInfo);
+                    }
+                    processor.prepareTrackSwitch();
+                });
         }
-
-
-        mediaController.checkInitialMediaSettingsForType(type, streamInfo);
-        initialMediaInfo = mediaController.getCurrentTrackFor(type, streamInfo);
-
-        eventBus.trigger(Events.STREAM_INITIALIZING, {
-            streamInfo: streamInfo,
-            mediaInfo: mediaInfo
-        });
-
-        // TODO : How to tell index handler live/duration?
-        // TODO : Pass to controller and then pass to each method on handler?
-
-        createStreamProcessor(initialMediaInfo, allMediaForType, mediaSource);
     }
 
     function addInlineEvents() {
@@ -525,66 +664,7 @@ function Stream(config) {
         }
     }
 
-    function addInbandEvents(events) {
-        if (eventController) {
-            eventController.addInbandEvents(events);
-        }
-    }
-
-    function initializeMedia(mediaSource, previousBuffers) {
-        checkConfig();
-        let element = videoModel.getElement();
-
-        addInlineEvents();
-
-        isUpdating = true;
-
-        capabilitiesFilter.filterUnsupportedFeaturesOfPeriod( streamInfo);
-
-        if (!element || (element && (/^VIDEO$/i).test(element.nodeName))) {
-            initializeMediaForType(Constants.VIDEO, mediaSource);
-        }
-        initializeMediaForType(Constants.AUDIO, mediaSource);
-        initializeMediaForType(Constants.TEXT, mediaSource);
-        initializeMediaForType(Constants.FRAGMENTED_TEXT, mediaSource);
-        initializeMediaForType(Constants.EMBEDDED_TEXT, mediaSource);
-        initializeMediaForType(Constants.MUXED, mediaSource);
-        initializeMediaForType(Constants.IMAGE, mediaSource);
-
-        //TODO. Consider initialization of TextSourceBuffer here if embeddedText, but no sideloadedText.
-        const buffers = createBuffers(previousBuffers);
-
-        isMediaInitialized = true;
-        isUpdating = false;
-
-        if (streamProcessors.length === 0) {
-            const msg = 'No streams to play.';
-            errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_NOSTREAMS_CODE, msg, manifestModel.getValue()));
-            logger.fatal(msg);
-        } else {
-            checkIfInitializationCompleted();
-        }
-
-        return buffers;
-    }
-
-    function initializeAfterPreload() {
-        isUpdating = true;
-        checkConfig();
-        capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
-
-        isMediaInitialized = true;
-        isUpdating = false;
-        if (streamProcessors.length === 0) {
-            const msg = 'No streams to play.';
-            errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_NOSTREAMS_CODE, msg, manifestModel.getValue()));
-            logger.debug(msg);
-        } else {
-            checkIfInitializationCompleted();
-        }
-    }
-
-    function checkIfInitializationCompleted() {
+    function _checkIfInitializationCompleted() {
         const ln = streamProcessors.length;
         const hasError = !!updateError.audio || !!updateError.video;
         let error = hasError ? new DashJSError(Errors.DATA_UPDATE_FAILED_ERROR_CODE, Errors.DATA_UPDATE_FAILED_ERROR_MESSAGE) : null;
@@ -595,10 +675,6 @@ function Stream(config) {
             }
         }
 
-        if (!isMediaInitialized) {
-            return;
-        }
-
         if (protectionController) {
             // Need to check if streamProcessors exists because streamProcessors
             // could be cleared in case an error is detected while initializing DRM keysystem
@@ -618,21 +694,13 @@ function Stream(config) {
 
         if (error) {
             errHandler.error(error);
-        } else if (!isStreamInitialized) {
-            isStreamInitialized = true;
-
+        } else if (!isInitialized) {
+            isInitialized = true;
             eventBus.trigger(Events.STREAM_INITIALIZED, {
-                streamInfo: streamInfo,
-                liveStartTime: !preloaded ? getLiveStartTime() : NaN
+                streamInfo: streamInfo
             });
         }
 
-        // (Re)start ScheduleController:
-        // - in case stream initialization has been completed after 'play' event (case for SegmentBase streams)
-        // - in case stream is complete but a track switch has been requested
-        for (let i = 0; i < ln && streamProcessors[i]; i++) {
-            streamProcessors[i].getScheduleController().start();
-        }
     }
 
     function getMediaInfo(type) {
@@ -649,17 +717,6 @@ function Stream(config) {
         return null;
     }
 
-    function createBuffers(previousBuffers) {
-        const buffers = {};
-        for (let i = 0, ln = streamProcessors.length; i < ln; i++) {
-            const buffer = streamProcessors[i].createBuffer(previousBuffers);
-            if (buffer) {
-                buffers[streamProcessors[i].getType()] = buffer.getBuffer();
-            }
-        }
-        return buffers;
-    }
-
     function onBufferingCompleted() {
         let processors = getProcessors();
         const ln = processors.length;
@@ -673,22 +730,26 @@ function Stream(config) {
         for (let i = 0; i < ln; i++) {
             //if audio or video buffer is not buffering completed state, do not send STREAM_BUFFERING_COMPLETED
             if (!processors[i].isBufferingCompleted() && (processors[i].getType() === Constants.AUDIO || processors[i].getType() === Constants.VIDEO)) {
-                logger.warn('onBufferingCompleted - One streamProcessor has finished but', processors[i].getType(), 'one is not buffering completed');
+                logger.debug('onBufferingCompleted - One streamProcessor has finished but', processors[i].getType(), 'one is not buffering completed');
                 return;
             }
         }
 
         logger.debug('onBufferingCompleted - trigger STREAM_BUFFERING_COMPLETED');
-        eventBus.trigger(Events.STREAM_BUFFERING_COMPLETED, { streamInfo: streamInfo });
+        console.debug(`onBufferingCompleted - trigger STREAM_BUFFERING_COMPLETED for stream id ${streamInfo.id}`);
+        hasFinishedBuffering = true;
+        eventBus.trigger(Events.STREAM_BUFFERING_COMPLETED, { streamInfo: streamInfo }, { streamInfo });
     }
 
     function onDataUpdateCompleted(e) {
         updateError[e.mediaType] = e.error;
-        checkIfInitializationCompleted();
+        _checkIfInitializationCompleted();
     }
 
     function onInbandEvents(e) {
-        addInbandEvents(e.events);
+        if (eventController) {
+            eventController.addInbandEvents(e.events);
+        }
     }
 
     function getProcessorForMediaInfo(mediaInfo) {
@@ -721,10 +782,16 @@ function Stream(config) {
         return arr;
     }
 
+    function startScheduleControllers() {
+        const ln = streamProcessors.length;
+        for (let i = 0; i < ln && streamProcessors[i]; i++) {
+            streamProcessors[i].getScheduleController().startScheduleTimer();
+        }
+    }
+
     function updateData(updatedStreamInfo) {
         logger.info('Manifest updated... updating data system wide.');
 
-        isStreamActivated = false;
         isUpdating = true;
         streamInfo = updatedStreamInfo;
 
@@ -734,8 +801,6 @@ function Stream(config) {
             addInlineEvents();
         }
 
-        capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
-
         for (let i = 0, ln = streamProcessors.length; i < ln; i++) {
             let streamProcessor = streamProcessors[i];
             streamProcessor.updateStreamInfo(streamInfo);
@@ -752,32 +817,33 @@ function Stream(config) {
             if (mediaInfo.type !== Constants.FRAGMENTED_TEXT) {
                 let processor = getProcessorForMediaInfo(trackChangedEvent.oldMediaInfo);
                 if (!processor) return;
-                processor.switchTrackAsked();
+                processor.prepareTrackSwitch();
                 trackChangedEvent = undefined;
             }
         }
 
         isUpdating = false;
-        checkIfInitializationCompleted();
+        _checkIfInitializationCompleted();
+
     }
 
     function isMediaCodecCompatible(newStream, previousStream = null) {
         return compareCodecs(newStream, Constants.VIDEO, previousStream) && compareCodecs(newStream, Constants.AUDIO, previousStream);
     }
 
-    function isProtectionCompatible(stream, previousStream = null) {
-        return compareProtectionConfig(stream, Constants.VIDEO, previousStream) && compareProtectionConfig(stream, Constants.AUDIO, previousStream);
+    function isProtectionCompatible(newStream) {
+        if (!newStream) {
+            return true;
+        }
+        return _compareProtectionConfig(Constants.VIDEO, newStream) && _compareProtectionConfig(Constants.AUDIO, newStream);
     }
 
-    function compareProtectionConfig(stream, type, previousStream = null) {
-        if (!stream) {
-            return false;
-        }
-        const newStreamInfo = stream.getStreamInfo();
-        const currentStreamInfo = previousStream ? previousStream.getStreamInfo() : getStreamInfo();
+    function _compareProtectionConfig(type, newStream) {
+        const currentStreamInfo = getStreamInfo();
+        const newStreamInfo = newStream.getStreamInfo();
 
         if (!newStreamInfo || !currentStreamInfo) {
-            return false;
+            return true;
         }
 
         const newAdaptation = adapter.getAdaptationForType(newStreamInfo.index, type, newStreamInfo);
@@ -789,10 +855,10 @@ function Stream(config) {
         }
 
         // If the current period is unencrypted and the upcoming one is encrypted we need to reset sourcebuffers.
-        return !(!isAdaptationDrmProtected(currentAdaptation) && isAdaptationDrmProtected(newAdaptation));
+        return !(!_isAdaptationDrmProtected(currentAdaptation) && _isAdaptationDrmProtected(newAdaptation));
     }
 
-    function isAdaptationDrmProtected(adaptation) {
+    function _isAdaptationDrmProtected(adaptation) {
 
         if (!adaptation) {
             // If there is no adaptation for neither the old or the new stream they're compatible
@@ -847,56 +913,43 @@ function Stream(config) {
         return preloaded;
     }
 
-    function preload(mediaSource, previousBuffers) {
-        if (!getPreloaded()) {
-            addInlineEvents();
-
-            initializeMediaForType(Constants.VIDEO, mediaSource);
-            initializeMediaForType(Constants.AUDIO, mediaSource);
-            initializeMediaForType(Constants.TEXT, mediaSource);
-            initializeMediaForType(Constants.FRAGMENTED_TEXT, mediaSource);
-            initializeMediaForType(Constants.EMBEDDED_TEXT, mediaSource);
-            initializeMediaForType(Constants.MUXED, mediaSource);
-            initializeMediaForType(Constants.IMAGE, mediaSource);
-
-            createBuffers(previousBuffers);
-
-            eventBus.on(Events.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, instance);
-            for (let i = 0; i < streamProcessors.length && streamProcessors[i]; i++) {
-                streamProcessors[i].getScheduleController().start();
-            }
-
-            setPreloaded(true);
-        }
+    function getHasFinishedBuffering() {
+        return hasFinishedBuffering;
     }
 
+    function getAdapter() {
+        return adapter;
+    }
 
     instance = {
-        initialize: initialize,
-        getStreamId: getStreamId,
-        activate: activate,
-        deactivate: deactivate,
-        isActive: isActive,
-        getDuration: getDuration,
-        getStartTime: getStartTime,
-        getId: getId,
-        getStreamInfo: getStreamInfo,
-        getHasAudioTrack: getHasAudioTrack,
-        getHasVideoTrack: getHasVideoTrack,
-        preload: preload,
-        getThumbnailController: getThumbnailController,
-        getBitrateListFor: getBitrateListFor,
-        updateData: updateData,
-        reset: reset,
-        getProcessors: getProcessors,
-        setMediaSource: setMediaSource,
-        isMediaCodecCompatible: isMediaCodecCompatible,
-        isProtectionCompatible: isProtectionCompatible,
-        getPreloaded: getPreloaded,
-        getPreloadingScheduled,
-        setPreloadingScheduled,
+        initialize,
+        getStreamId,
+        activate,
+        deactivate,
+        getIsActive,
+        getDuration,
+        getStartTime,
+        getId,
+        getStreamInfo,
+        getHasAudioTrack,
+        getHasVideoTrack,
+        startPreloading,
+        getThumbnailController,
+        getBitrateListFor,
+        updateData,
+        reset,
+        getProcessors,
+        setMediaSource,
+        isMediaCodecCompatible,
+        isProtectionCompatible,
+        getPreloaded,
         getIsEndedEventSignaled,
-        setIsEndedEventSignaled
+        setIsEndedEventSignaled,
+        getAdapter,
+        getHasFinishedBuffering,
+        setPreloaded,
+        startScheduleControllers,
+        prepareTrackChange
     };
 
     setup();
diff --git a/src/streaming/StreamProcessor.js b/src/streaming/StreamProcessor.js
index 35bf7796b2..4b8d316cd9 100644
--- a/src/streaming/StreamProcessor.js
+++ b/src/streaming/StreamProcessor.js
@@ -33,10 +33,9 @@ import DashConstants from '../dash/constants/DashConstants';
 import MetricsConstants from './constants/MetricsConstants';
 import FragmentModel from './models/FragmentModel';
 import BufferController from './controllers/BufferController';
-import TextBufferController from './text/TextBufferController';
+import NotFragmentedTextBufferController from './text/NotFragmentedTextBufferController';
 import ScheduleController from './controllers/ScheduleController';
 import RepresentationController from '../dash/controllers/RepresentationController';
-import LiveEdgeFinder from './utils/LiveEdgeFinder';
 import FactoryMaker from '../core/FactoryMaker';
 import {checkInteger} from './utils/SupervisorTools';
 import EventBus from '../core/EventBus';
@@ -48,8 +47,8 @@ import Debug from '../core/Debug';
 import RequestModifier from './utils/RequestModifier';
 import URLUtils from '../streaming/utils/URLUtils';
 import BoxParser from './utils/BoxParser';
-import FragmentRequest from './vo/FragmentRequest';
 import {PlayListTrace} from './vo/metrics/PlayList';
+import SegmentsController from '../dash/controllers/SegmentsController';
 
 function StreamProcessor(config) {
 
@@ -82,40 +81,55 @@ function StreamProcessor(config) {
         bufferController,
         scheduleController,
         representationController,
-        liveEdgeFinder,
-        indexHandler,
-        bufferingTime,
-        bufferPruned;
+        shouldUseExplicitTimeForRequest,
+        dashHandler,
+        segmentsController,
+        bufferingTime;
 
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
         resetInitialSettings();
 
-        eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance, { priority: EventBus.EVENT_PRIORITY_HIGH }); // High priority to be notified before Stream
-        eventBus.on(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, instance);
-        eventBus.on(Events.INIT_FRAGMENT_NEEDED, onInitFragmentNeeded, instance);
-        eventBus.on(Events.MEDIA_FRAGMENT_NEEDED, onMediaFragmentNeeded, instance);
-        eventBus.on(Events.MEDIA_FRAGMENT_LOADED, onMediaFragmentLoaded, instance);
-        eventBus.on(Events.BUFFER_LEVEL_UPDATED, onBufferLevelUpdated, instance);
-        eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, instance);
-        eventBus.on(Events.BUFFER_CLEARED, onBufferCleared, instance);
-        eventBus.on(Events.QUOTA_EXCEEDED, onQuotaExceeded, instance);
-        eventBus.on(Events.SEEK_TARGET, onSeekTarget, instance);
+        eventBus.on(Events.DATA_UPDATE_COMPLETED, _onDataUpdateCompleted, instance, { priority: EventBus.EVENT_PRIORITY_HIGH }); // High priority to be notified before Stream
+        eventBus.on(Events.INIT_FRAGMENT_NEEDED, _onInitFragmentNeeded, instance);
+        eventBus.on(Events.MEDIA_FRAGMENT_NEEDED, _onMediaFragmentNeeded, instance);
+        eventBus.on(Events.MEDIA_FRAGMENT_LOADED, _onMediaFragmentLoaded, instance);
+        eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, _onBufferLevelStateChanged, instance);
+        eventBus.on(Events.BUFFER_CLEARED, _onBufferCleared, instance);
+        eventBus.on(Events.SEEK_TARGET, _onSeekTarget, instance);
+        eventBus.on(Events.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
+        eventBus.on(Events.FRAGMENT_LOADING_ABANDONED, _onFragmentLoadingAbandoned, instance);
+        eventBus.on(Events.FRAGMENT_LOADING_COMPLETED, _onFragmentLoadingCompleted, instance);
+        eventBus.on(Events.QUOTA_EXCEEDED, _onQuotaExceeded, instance);
+        eventBus.on(Events.SET_FRAGMENTED_TEXT_AFTER_DISABLED, _onSetFragmentedTextAfterDisabled, instance);
+        eventBus.on(Events.SET_NON_FRAGMENTED_TEXT, _onSetNonFragmentedText, instance);
     }
 
     function initialize(mediaSource, hasVideoTrack) {
-        indexHandler = DashHandler(context).create({
-            streamInfo: streamInfo,
-            type: type,
-            timelineConverter: timelineConverter,
-            dashMetrics: dashMetrics,
-            mediaPlayerModel: mediaPlayerModel,
+
+        segmentsController = SegmentsController(context).create({
+            events: Events,
+            eventBus,
+            streamInfo,
+            timelineConverter,
+            dashConstants: DashConstants,
+            segmentBaseController: config.segmentBaseController,
+            type
+        });
+
+        dashHandler = DashHandler(context).create({
+            streamInfo,
+            type,
+            timelineConverter,
+            dashMetrics,
+            mediaPlayerModel,
             baseURLController: config.baseURLController,
-            errHandler: errHandler,
-            settings: settings,
-            boxParser: boxParser,
+            errHandler,
+            segmentsController,
+            settings,
+            boxParser,
             events: Events,
-            eventBus: eventBus,
+            eventBus,
             errors: Errors,
             debug: Debug(context).getInstance(),
             requestModifier: RequestModifier(context).getInstance(),
@@ -124,56 +138,52 @@ function StreamProcessor(config) {
             urlUtils: URLUtils(context).getInstance()
         });
 
-        // Create live edge finder for dynamic streams
         isDynamic = streamInfo.manifestInfo.isDynamic;
-        if (isDynamic) {
-            liveEdgeFinder = LiveEdgeFinder(context).create({
-                timelineConverter: timelineConverter
-            });
-        }
 
         // Create/initialize controllers
-        indexHandler.initialize(isDynamic);
+        dashHandler.initialize(isDynamic);
         abrController.registerStreamType(type, instance);
 
         representationController = RepresentationController(context).create({
-            streamInfo: streamInfo,
-            type: type,
-            abrController: abrController,
-            dashMetrics: dashMetrics,
-            playbackController: playbackController,
-            timelineConverter: timelineConverter,
+            streamInfo,
+            type,
+            abrController,
+            dashMetrics,
+            playbackController,
+            timelineConverter,
             dashConstants: DashConstants,
             events: Events,
-            eventBus: eventBus,
-            errors: Errors
+            eventBus,
+            errors: Errors,
+            isDynamic,
+            segmentsController
         });
 
-        bufferController = createBufferControllerForType(type);
+        bufferController = _createBufferControllerForType(type);
         if (bufferController) {
             bufferController.initialize(mediaSource);
         }
 
         scheduleController = ScheduleController(context).create({
-            streamInfo: streamInfo,
-            type: type,
-            mimeType: mimeType,
-            adapter: adapter,
-            dashMetrics: dashMetrics,
-            mediaPlayerModel: mediaPlayerModel,
-            fragmentModel: fragmentModel,
-            abrController: abrController,
-            playbackController: playbackController,
-            textController: textController,
-            mediaController: mediaController,
-            bufferController: bufferController,
-            settings: settings
+            streamInfo,
+            type,
+            mimeType,
+            adapter,
+            dashMetrics,
+            mediaPlayerModel,
+            fragmentModel,
+            abrController,
+            playbackController,
+            textController,
+            mediaController,
+            bufferController,
+            settings
         });
 
         scheduleController.initialize(hasVideoTrack);
 
         bufferingTime = 0;
-        bufferPruned = false;
+        shouldUseExplicitTimeForRequest = false;
     }
 
     function getStreamId() {
@@ -188,11 +198,12 @@ function StreamProcessor(config) {
         mediaInfoArr = [];
         mediaInfo = null;
         bufferingTime = 0;
+        shouldUseExplicitTimeForRequest = false;
     }
 
     function reset(errored, keepBuffers) {
-        if (indexHandler) {
-            indexHandler.reset();
+        if (dashHandler) {
+            dashHandler.reset();
         }
 
         if (bufferController) {
@@ -210,24 +221,27 @@ function StreamProcessor(config) {
             representationController = null;
         }
 
-        if (liveEdgeFinder) {
-            liveEdgeFinder.reset();
-            liveEdgeFinder = null;
+        if (segmentsController) {
+            segmentsController = null;
         }
 
-        if (abrController && !keepBuffers) {
-            abrController.unRegisterStreamType(type);
+        if (abrController) {
+            abrController.unRegisterStreamType(getStreamId(), type);
         }
 
-        eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance);
-        eventBus.off(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, instance);
-        eventBus.off(Events.INIT_FRAGMENT_NEEDED, onInitFragmentNeeded, instance);
-        eventBus.off(Events.MEDIA_FRAGMENT_NEEDED, onMediaFragmentNeeded, instance);
-        eventBus.off(Events.MEDIA_FRAGMENT_LOADED, onMediaFragmentLoaded, instance);
-        eventBus.off(Events.BUFFER_LEVEL_UPDATED, onBufferLevelUpdated, instance);
-        eventBus.off(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, instance);
-        eventBus.off(Events.BUFFER_CLEARED, onBufferCleared, instance);
-        eventBus.off(Events.SEEK_TARGET, onSeekTarget, instance);
+        eventBus.off(Events.DATA_UPDATE_COMPLETED, _onDataUpdateCompleted, instance);
+        eventBus.off(Events.INIT_FRAGMENT_NEEDED, _onInitFragmentNeeded, instance);
+        eventBus.off(Events.MEDIA_FRAGMENT_NEEDED, _onMediaFragmentNeeded, instance);
+        eventBus.off(Events.MEDIA_FRAGMENT_LOADED, _onMediaFragmentLoaded, instance);
+        eventBus.off(Events.BUFFER_LEVEL_STATE_CHANGED, _onBufferLevelStateChanged, instance);
+        eventBus.off(Events.BUFFER_CLEARED, _onBufferCleared, instance);
+        eventBus.off(Events.SEEK_TARGET, _onSeekTarget, instance);
+        eventBus.off(Events.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
+        eventBus.off(Events.FRAGMENT_LOADING_ABANDONED, _onFragmentLoadingAbandoned, instance);
+        eventBus.off(Events.FRAGMENT_LOADING_COMPLETED, _onFragmentLoadingCompleted, instance);
+        eventBus.off(Events.SET_FRAGMENTED_TEXT_AFTER_DISABLED, _onSetFragmentedTextAfterDisabled, instance);
+        eventBus.off(Events.SET_NON_FRAGMENTED_TEXT, _onSetNonFragmentedText, instance);
+        eventBus.off(Events.QUOTA_EXCEEDED, _onQuotaExceeded, instance);
 
         resetInitialSettings();
         type = null;
@@ -238,67 +252,355 @@ function StreamProcessor(config) {
         return representationController ? representationController.isUpdating() : false;
     }
 
+    /**
+     * When a seek within the corresponding period occurs this function initiates the clearing of the buffer and sets the correct buffering time.
+     * @param {object} e
+     * @private
+     */
+    function prepareInnerPeriodPlaybackSeeking(e) {
+        return new Promise((resolve) => {
+            // Stop segment requests until we have figured out for which time we need to request a segment. We don't want to replace existing segments.
+            scheduleController.clearScheduleTimer();
+            fragmentModel.abortRequests();
+
+            // Abort operations to the SourceBuffer Sink and reset the BufferControllers isBufferingCompleted state.
+            bufferController.prepareForPlaybackSeek()
+                .then(() => {
+                    // Clear the buffer. We need to prune everything which is not in the target interval.
+                    const clearRanges = bufferController.getAllRangesWithSafetyFactor(e.seekTime);
+                    // When everything has been pruned go on
+                    return bufferController.clearBuffers(clearRanges);
+                })
+                .then(() => {
+                    // Figure out the correct segment request time.
+                    const targetTime = bufferController.getContinuousBufferTimeForTargetTime(e.seekTime);
+
+                    // If the buffer is continuous and exceeds the duration of the period we are still done buffering. We need to trigger the buffering completed event in order to start prebuffering upcoming periods again
+                    if (!isNaN(streamInfo.duration) && isFinite(streamInfo.duration) && targetTime >= streamInfo.start + streamInfo.duration) {
+                        bufferController.setIsBufferingCompleted(true);
+                        resolve();
+                    } else {
+                        setExplicitBufferingTime(targetTime);
+                        bufferController.setSeekTarget(targetTime);
+
+                        const promises = [];
+
+                        // append window has been reset by abort() operation. Set the correct values again
+                        promises.push(bufferController.updateAppendWindow());
+
+                        // Timestamp offset couldve been changed by preloading period
+                        const representationInfo = getRepresentationInfo();
+                        promises.push(bufferController.updateBufferTimestampOffset(representationInfo));
+
+                        Promise.all(promises)
+                            .then(() => {
+                                // We might have aborted the append operation of an init segment. Append init segment again.
+                                scheduleController.setInitSegmentRequired(true);
+
+                                // Right after a seek we should not immediately check the playback quality
+                                scheduleController.setCheckPlaybackQuality(false);
+                                scheduleController.startScheduleTimer();
+                                resolve();
+                            });
+                    }
+                })
+                .catch((e) => {
+                    logger.error(e);
+                });
+        });
 
-    function onDataUpdateCompleted(e) {
-        if (!e.error) {
-            // Update representation if no error
-            scheduleController.setCurrentRepresentation(adapter.convertDataToRepresentationInfo(e.currentRepresentation));
+    }
+
+    /**
+     * Seek outside of the current period.
+     * @return {Promise<unknown>}
+     */
+    function prepareOuterPeriodPlaybackSeeking() {
+        return new Promise((resolve, reject) => {
+            try {
+                // Stop scheduling
+                scheduleController.clearScheduleTimer();
+
+                // Abort all ongoing requests
+                fragmentModel.abortRequests();
+
+                // buffering not complete anymore and abort current append operation to SourceBuffer
+                bufferController.prepareForPlaybackSeek()
+                    .then(() => {
+                        // Clear the buffers completely.
+                        return bufferController.pruneAllSafely();
+                    })
+                    .then(() => {
+                        resolve();
+                    });
+
+            } catch (e) {
+                reject(e);
+            }
+        });
+    }
+
+    /**
+     * ScheduleController indicates that an init segment needs to be fetched.
+     * @param {object} e
+     * @private
+     */
+    function _onInitFragmentNeeded(e) {
+        // Event propagation may have been stopped (see MssHandler)
+        if (!e.sender) return;
+
+        if (adapter.getIsTextTrack(mimeType) && !textController.isTextEnabled()) return;
+
+        if (bufferController && e.representationId) {
+            if (!bufferController.appendInitSegmentFromCache(e.representationId)) {
+                // Init segment not in cache, send new request
+                const request = dashHandler ? dashHandler.getInitRequest(getMediaInfo(), representationController.getCurrentRepresentation()) : null;
+                if (request) {
+                    fragmentModel.executeRequest(request);
+                } else {
+                    _noValidRequest();
+                    scheduleController.setInitSegmentRequired(true);
+                }
+            }
         }
-        if (!e.error || e.error.code === Errors.SEGMENTS_UPDATE_FAILED_ERROR_CODE) {
-            // Update has been postponed, update nevertheless DVR info
-            const activeStreamId = playbackController.getStreamController().getActiveStreamInfo().id;
-            if (activeStreamId === streamInfo.id) {
-                addDVRMetric();
+    }
+
+    /**
+     * ScheduleController indicates that a media segment is needed
+     * @private
+     */
+    function _onMediaFragmentNeeded() {
+        let request = null;
+
+        const representation = representationController.getCurrentRepresentation();
+        const isMediaFinished = dashHandler.isMediaFinished(representation, bufferingTime);
+
+        // Check if the media is finished. If so, no need to schedule another request
+        if (isMediaFinished) {
+            const segmentIndex = dashHandler.getCurrentIndex();
+            logger.debug(`Segment requesting for stream ${streamInfo.id} has finished`);
+            eventBus.trigger(Events.STREAM_REQUESTING_COMPLETED, { segmentIndex }, {
+                streamId: streamInfo.id,
+                mediaType: type
+            });
+            scheduleController.clearScheduleTimer();
+            return;
+        }
+
+        // Don't schedule next fragments while pruning to avoid buffer inconsistencies
+        if (!bufferController.getIsPruningInProgress()) {
+            request = _getFragmentRequest();
+            if (request) {
+                shouldUseExplicitTimeForRequest = false;
+                if (!isNaN(request.startTime + request.duration)) {
+                    bufferingTime = request.startTime + request.duration;
+                }
+                request.delayLoadingTime = new Date().getTime() + scheduleController.getTimeToLoadDelay();
+                scheduleController.setTimeToLoadDelay(0);
             }
         }
+
+        if (request) {
+            logger.debug(`Next fragment request url for stream id ${streamInfo.id} and media type ${type} is ${request.url}`);
+            fragmentModel.executeRequest(request);
+        } else {
+            // Use case - Playing at the bleeding live edge and frag is not available yet. Cycle back around.
+            _noValidRequest();
+        }
     }
 
-    function onQualityChanged(e) {
-        let representationInfo = getRepresentationInfo(e.newQuality);
-        scheduleController.setCurrentRepresentation(representationInfo);
-        dashMetrics.pushPlayListTraceMetrics(new Date(), PlayListTrace.REPRESENTATION_SWITCH_STOP_REASON);
-        dashMetrics.createPlaylistTraceMetrics(representationInfo.id, playbackController.getTime() * 1000, playbackController.getPlaybackRate());
+    /**
+     * Get the init or media segment request using the DashHandler.
+     * @return {null|FragmentRequest|null}
+     * @private
+     */
+    function _getFragmentRequest() {
+        const representationInfo = getRepresentationInfo();
+        let request;
+
+        if (isNaN(bufferingTime) || (getType() === Constants.FRAGMENTED_TEXT && !textController.isTextEnabled())) {
+            return null;
+        }
+
+        // Use time just whenever is strictly needed
+        const useTime = shouldUseExplicitTimeForRequest;
+
+        if (dashHandler) {
+            const representation = representationController && representationInfo ? representationController.getRepresentationForQuality(representationInfo.quality) : null;
+
+            if (useTime) {
+                request = dashHandler.getSegmentRequestForTime(getMediaInfo(), representation, bufferingTime);
+            } else {
+                request = dashHandler.getNextSegmentRequest(getMediaInfo(), representation);
+            }
+        }
+
+        return request;
+    }
+
+    /**
+     * Whenever we can not generate a valid request we restart scheduling according to the timeouts defined in the settings.
+     * @private
+     */
+    function _noValidRequest() {
+        logger.debug(`No valid request found for ${type}`);
+        scheduleController.startScheduleTimer(settings.get().streaming.lowLatencyEnabled ? settings.get().streaming.scheduling.lowLatencyTimeout : settings.get().streaming.scheduling.defaultTimeout);
     }
 
-    function onBufferLevelUpdated(e) {
-        dashMetrics.addBufferLevel(type, new Date(), e.bufferLevel * 1000);
-        const activeStreamId = playbackController.getStreamController().getActiveStreamInfo().id;
-        if (!manifestModel.getValue().doNotUpdateDVRWindowOnBufferUpdated && streamInfo.id === activeStreamId) {
-            addDVRMetric();
+    function _onDataUpdateCompleted(e) {
+        if (!e.error) {
+            // Update representation if no error
+            scheduleController.setCurrentRepresentation(adapter.convertDataToRepresentationInfo(e.currentRepresentation));
+            if (!bufferController.getIsBufferingCompleted()) {
+                bufferController.updateBufferTimestampOffset(e.currentRepresentation);
+            }
         }
     }
 
-    function onBufferLevelStateChanged(e) {
+    function _onBufferLevelStateChanged(e) {
         dashMetrics.addBufferState(type, e.state, scheduleController.getBufferTarget());
         if (e.state === MetricsConstants.BUFFER_EMPTY && !playbackController.isSeeking()) {
-            // logger.info('Buffer is empty! Stalling!');
+            logger.info('Buffer is empty! Stalling!');
             dashMetrics.pushPlayListTraceMetrics(new Date(), PlayListTrace.REBUFFERING_REASON);
         }
     }
 
-    function onBufferCleared(e) {
+    function _onBufferCleared(e) {
         // Remove executed requests not buffered anymore
         fragmentModel.syncExecutedRequestsWithBufferedRange(
             bufferController.getBuffer().getAllBufferRanges(),
             streamInfo.duration);
 
         // If buffer removed ahead current time (QuotaExceededError or automatic buffer pruning) then adjust current index handler time
-        if (e.from > playbackController.getTime()) {
-            bufferingTime = e.from;
-            bufferPruned = true;
+        if (e.quotaExceeded && e.from > playbackController.getTime()) {
+            setExplicitBufferingTime(e.from);
+        }
+
+        // (Re)start schedule once buffer has been pruned after a QuotaExceededError
+        if (e.hasEnoughSpaceToAppend && e.quotaExceeded) {
+            scheduleController.startScheduleTimer();
         }
+
+    }
+
+    /**
+     * The quality has changed which means we have switched to a different representation.
+     * If we want to aggressively replace existing parts in the buffer we need to make sure that the new quality is higher than the already buffered one.
+     * @param {object} e
+     * @private
+     */
+    function _onQualityChanged(e) {
+        const representationInfo = getRepresentationInfo(e.newQuality);
+        scheduleController.setCurrentRepresentation(representationInfo);
+
+        // if we switch up in quality and need to replace existing parts in the buffer we need to adjust the buffer target
+        if (settings.get().streaming.buffer.fastSwitchEnabled) {
+            const time = playbackController.getTime();
+            let safeBufferLevel = 1.5;
+            const request = fragmentModel.getRequests({
+                state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
+                time: time + safeBufferLevel,
+                threshold: 0
+            })[0];
+
+            if (request && !adapter.getIsTextTrack(mimeType)) {
+                const bufferLevel = bufferController.getBufferLevel();
+                const abandonmentState = abrController.getAbandonmentStateFor(streamInfo.id, type);
+
+                if (request.quality < representationInfo.quality && bufferLevel >= safeBufferLevel && abandonmentState !== MetricsConstants.ABANDON_LOAD) {
+                    setExplicitBufferingTime(time + safeBufferLevel);
+                    scheduleController.setCheckPlaybackQuality(false);
+                }
+            }
+        }
+
+        dashMetrics.pushPlayListTraceMetrics(new Date(), PlayListTrace.REPRESENTATION_SWITCH_STOP_REASON);
+        dashMetrics.createPlaylistTraceMetrics(representationInfo.id, playbackController.getTime() * 1000, playbackController.getPlaybackRate());
+    }
+
+    /**
+     * We have canceled the download of a fragment and need to adjust the buffer time or reload an init segment
+     * @param {object} e
+     */
+    function _onFragmentLoadingAbandoned(e) {
+        logger.info('onFragmentLoadingAbandoned request: ' + e.request.url + ' has been aborted');
+
+        // we only need to handle this if we are not seeking or switching the tracks
+        if (!playbackController.isSeeking() && !scheduleController.getSwitchStrack()) {
+            logger.info('onFragmentLoadingAbandoned request: ' + e.request.url + ' has to be downloaded again, origin is not seeking process or switch track call');
+
+            // in case of an init segment we force the download of an init segment
+            if (e.request && e.request.isInitializationRequest()) {
+                scheduleController.setInitSegmentRequired(true);
+            }
+
+            // in case of a media segment we reset the buffering time
+            else {
+                setExplicitBufferingTime(e.request.startTime + (e.request.duration / 2));
+            }
+
+            // In case of a seek the schedule controller was stopped and will be started once the buffer has been pruned.
+            scheduleController.startScheduleTimer(0);
+        }
+    }
+
+    /**
+     * When a fragment has been loaded we need to start the schedule timer again in case of an error.
+     * @param {object} e
+     */
+    function _onFragmentLoadingCompleted(e) {
+        logger.info('OnFragmentLoadingCompleted for stream id ' + streamInfo.id + ' and media type ' + type + ' - Url:', e.request ? e.request.url : 'undefined', e.request.range ? ', Range:' + e.request.range : '');
+
+        if (adapter.getIsTextTrack(mimeType)) {
+            scheduleController.startScheduleTimer(0);
+        }
+
+        if (e.error && e.request.serviceLocation) {
+            setExplicitBufferingTime(e.request.startTime + (e.request.duration / 2));
+            scheduleController.startScheduleTimer(0);
+        }
+    }
+
+    /**
+     * Callback function triggered by the TextController whenever a track is changed for fragmented text. Will only be triggered if textracks have previously been disabled.
+     * @private
+     */
+    function _onSetFragmentedTextAfterDisabled() {
+        setExplicitBufferingTime(playbackController.getTime());
+        getScheduleController().startScheduleTimer();
     }
 
-    function onQuotaExceeded(e) {
-        bufferingTime = e.quotaExceededTime;
-        bufferPruned = true;
+    /**
+     * Callback function triggered by the TextController whenever a track is changed for non fragmented text
+     * @param {object} e
+     * @private
+     */
+    function _onSetNonFragmentedText(e) {
+        const currentTrackInfo = e.currentTrackInfo;
+
+        if (!currentTrackInfo) {
+            return;
+        }
+
+        const mInfo = mediaInfoArr.find((info) => {
+            return info.index === currentTrackInfo.index && info.lang === currentTrackInfo.lang;
+        });
+
+        if (mInfo) {
+            selectMediaInfo(mInfo)
+                .then(() => {
+                    bufferController.setIsBufferingCompleted(false);
+                    setExplicitBufferingTime(playbackController.getTime());
+                    scheduleController.setInitSegmentRequired(true);
+                    scheduleController.startScheduleTimer();
+                });
+        }
     }
 
-    function addDVRMetric() {
-        const manifestInfo = streamInfo.manifestInfo;
-        const isDynamic = manifestInfo.isDynamic;
-        const range = timelineConverter.calcSegmentAvailabilityRange(representationController.getCurrentRepresentation(), isDynamic);
-        dashMetrics.addDVRInfo(getType(), playbackController.getTime(), manifestInfo, range);
+    function _onQuotaExceeded(e) {
+        // Stop scheduler (will be restarted once buffer is pruned)
+        setExplicitBufferingTime(e.quotaExceededTime);
+        scheduleController.clearScheduleTimer();
     }
 
     function getRepresentationController() {
@@ -309,10 +611,6 @@ function StreamProcessor(config) {
         return bufferController ? bufferController.getBuffer() : null;
     }
 
-    function setBuffer(buffer) {
-        bufferController.setBuffer(buffer);
-    }
-
     function getBufferController() {
         return bufferController;
     }
@@ -323,7 +621,7 @@ function StreamProcessor(config) {
 
     function updateStreamInfo(newStreamInfo) {
         streamInfo = newStreamInfo;
-        if (settings.get().streaming.useAppendWindow) {
+        if (!isBufferingCompleted()) {
             bufferController.updateAppendWindow();
         }
     }
@@ -332,6 +630,10 @@ function StreamProcessor(config) {
         return streamInfo;
     }
 
+    /**
+     * Called once the StreamProcessor is initialized and when the track is switched. We only have one StreamProcessor per media type. So we need to adjust the mediaInfo once we switch/select a track.
+     * @param {object} newMediaInfo
+     */
     function selectMediaInfo(newMediaInfo) {
         if (newMediaInfo !== mediaInfo && (!newMediaInfo || !mediaInfo || (newMediaInfo.type === mediaInfo.type))) {
             mediaInfo = newMediaInfo;
@@ -343,18 +645,18 @@ function StreamProcessor(config) {
         if (representationController) {
             const realAdaptation = representationController.getData();
             const maxQuality = abrController.getTopQualityIndexFor(type, streamInfo.id);
-            const minIdx = abrController.getMinAllowedIndexFor(type);
+            const minIdx = abrController.getMinAllowedIndexFor(type, streamInfo.id);
 
             let quality,
                 averageThroughput;
             let bitrate = null;
 
-            if ((realAdaptation === null || (realAdaptation.id != newRealAdaptation.id)) && type !== Constants.FRAGMENTED_TEXT) {
+            if ((realAdaptation === null || (realAdaptation.id !== newRealAdaptation.id)) && type !== Constants.FRAGMENTED_TEXT) {
                 averageThroughput = abrController.getThroughputHistory().getAverageThroughput(type);
                 bitrate = averageThroughput || abrController.getInitialBitrateFor(type);
-                quality = abrController.getQualityForBitrate(mediaInfo, bitrate);
+                quality = abrController.getQualityForBitrate(mediaInfo, bitrate, streamInfo.id);
             } else {
-                quality = abrController.getQualityFor(type);
+                quality = abrController.getQualityFor(type, streamInfo.id);
             }
 
             if (minIdx !== undefined && quality < minIdx) {
@@ -363,8 +665,9 @@ function StreamProcessor(config) {
             if (quality > maxQuality) {
                 quality = maxQuality;
             }
-            indexHandler.setMimeType(mediaInfo ? mediaInfo.mimeType : null);
-            representationController.updateData(newRealAdaptation, voRepresentations, type, quality);
+            return representationController.updateData(newRealAdaptation, voRepresentations, type, quality);
+        } else {
+            return Promise.resolve();
         }
     }
 
@@ -374,7 +677,7 @@ function StreamProcessor(config) {
         }
 
         if (selectNewMediaInfo) {
-            this.selectMediaInfo(newMediaInfo);
+            selectMediaInfo(newMediaInfo);
         }
     }
 
@@ -391,11 +694,7 @@ function StreamProcessor(config) {
     }
 
     function setMediaSource(mediaSource) {
-        bufferController.setMediaSource(mediaSource, getMediaInfoArr());
-    }
-
-    function dischargePreBuffer() {
-        bufferController.dischargePreBuffer();
+        bufferController.setMediaSource(mediaSource);
     }
 
     function getScheduleController() {
@@ -428,42 +727,6 @@ function StreamProcessor(config) {
         return bufferController ? bufferController.getBufferLevel() : 0;
     }
 
-    function onInitFragmentNeeded(e) {
-        // Event propagation may have been stopped (see MssHandler)
-        if (!e.sender) return;
-
-        if (adapter.getIsTextTrack(mimeType) && !textController.isTextEnabled()) return;
-
-        if (bufferController && e.representationId) {
-            if (!bufferController.appendInitSegment(e.representationId)) {
-                // Init segment not in cache, send new request
-                const request = indexHandler ? indexHandler.getInitRequest(getMediaInfo(), representationController.getCurrentRepresentation()) : null;
-                scheduleController.processInitRequest(request);
-            }
-        }
-    }
-
-    function onMediaFragmentNeeded(e) {
-        let request;
-
-        // Don't schedule next fragments while pruning to avoid buffer inconsistencies
-        if (!bufferController.getIsPruningInProgress()) {
-            request = findNextRequest(e.seekTarget, e.replacement);
-            if (request) {
-                scheduleController.setSeekTarget(NaN);
-                if (!e.replacement) {
-                    if (!isNaN(request.startTime + request.duration)) {
-                        bufferingTime = request.startTime + request.duration;
-                    }
-                    request.delayLoadingTime = new Date().getTime() + scheduleController.getTimeToLoadDelay();
-                    scheduleController.setTimeToLoadDelay(0);
-                }
-            }
-        }
-
-        scheduleController.processMediaRequest(request);
-    }
-
     /**
      * Probe the next request. This is used in the CMCD model to get information about the upcoming request. Note: No actual request is performed here.
      * @return {FragmentRequest|null}
@@ -474,7 +737,7 @@ function StreamProcessor(config) {
         const representation = representationController && representationInfo ?
             representationController.getRepresentationForQuality(representationInfo.quality) : null;
 
-        let request = indexHandler.getNextSegmentRequestIdempotent(
+        let request = dashHandler.getNextSegmentRequestIdempotent(
             getMediaInfo(),
             representation
         );
@@ -482,82 +745,33 @@ function StreamProcessor(config) {
         return request;
     }
 
-    function findNextRequest(seekTarget, requestToReplace) {
-        const representationInfo = getRepresentationInfo();
-        const hasSeekTarget = !isNaN(seekTarget);
-        const currentTime = playbackController.getNormalizedTime();
-        let time = hasSeekTarget ? seekTarget : bufferingTime;
-        let bufferIsDivided = false;
-        let request;
-
-        if (isNaN(time) || (getType() === Constants.FRAGMENTED_TEXT && !textController.isTextEnabled())) {
-            return null;
-        }
-        /**
-         * This is critical for IE/Safari/EDGE
-         * */
-        if (bufferController) {
-            let range = bufferController.getRangeAt(time);
-            const playingRange = bufferController.getRangeAt(currentTime);
-            if ((range !== null || playingRange !== null) && !hasSeekTarget) {
-                if (!range || (playingRange && playingRange.start != range.start && playingRange.end != range.end)) {
-                    const hasDiscontinuities = bufferController.getBuffer().hasDiscontinuitiesAfter(currentTime);
-                    if (hasDiscontinuities && getType() !== Constants.FRAGMENTED_TEXT) {
-                        fragmentModel.removeExecutedRequestsAfterTime(playingRange.end);
-                        bufferIsDivided = true;
-                    }
-                }
-            }
-        }
-
-        if (requestToReplace) {
-            time = requestToReplace.startTime + (requestToReplace.duration / 2);
-            request = getFragmentRequest(representationInfo, time, {
-                timeThreshold: 0,
-                ignoreIsFinished: true
-            });
-        } else {
-            // Use time just whenever is strictly needed
-            const useTime = hasSeekTarget || bufferPruned || bufferIsDivided;
-            request = getFragmentRequest(representationInfo,
-                useTime ? time : undefined, {
-                    keepIdx: !useTime
-                });
-            bufferPruned = false;
-
-            // Then, check if this request was downloaded or not
-            while (request && request.action !== FragmentRequest.ACTION_COMPLETE && fragmentModel.isFragmentLoaded(request)) {
-                // loop until we found not loaded fragment, or no fragment
-                request = getFragmentRequest(representationInfo);
-            }
-        }
-
-        return request;
-    }
-
-    function onMediaFragmentLoaded(e) {
+    function _onMediaFragmentLoaded(e) {
         const chunk = e.chunk;
 
         const bytes = chunk.bytes;
         const quality = chunk.quality;
         const currentRepresentation = getRepresentationInfo(quality);
-
         const voRepresentation = representationController && currentRepresentation ? representationController.getRepresentationForQuality(currentRepresentation.quality) : null;
-        const eventStreamMedia = adapter.getEventsFor(currentRepresentation.mediaInfo);
-        const eventStreamTrack = adapter.getEventsFor(currentRepresentation, voRepresentation);
 
-        if (eventStreamMedia && eventStreamMedia.length > 0 || eventStreamTrack && eventStreamTrack.length > 0) {
-            const request = fragmentModel.getRequests({
-                state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
-                quality: quality,
-                index: chunk.index
-            })[0];
-
-            const events = handleInbandEvents(bytes, request, eventStreamMedia, eventStreamTrack);
-            eventBus.trigger(Events.INBAND_EVENTS,
-                { events: events },
-                { streamId: streamInfo.id }
-            );
+        // If we switch tracks this event might be fired after the representations in the RepresentationController have been updated according to the new MediaInfo.
+        // In this case there will be no currentRepresentation and voRepresentation matching the "old" quality
+        if (currentRepresentation && voRepresentation) {
+            const eventStreamMedia = adapter.getEventsFor(currentRepresentation.mediaInfo);
+            const eventStreamTrack = adapter.getEventsFor(currentRepresentation, voRepresentation);
+
+            if (eventStreamMedia && eventStreamMedia.length > 0 || eventStreamTrack && eventStreamTrack.length > 0) {
+                const request = fragmentModel.getRequests({
+                    state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
+                    quality: quality,
+                    index: chunk.index
+                })[0];
+
+                const events = handleInbandEvents(bytes, request, eventStreamMedia, eventStreamTrack);
+                eventBus.trigger(Events.INBAND_EVENTS,
+                    { events: events },
+                    { streamId: streamInfo.id }
+                );
+            }
         }
     }
 
@@ -598,160 +812,137 @@ function StreamProcessor(config) {
         }
     }
 
-    function createBuffer(previousBuffers) {
-        return (getBuffer() || bufferController ? bufferController.createBuffer(mediaInfoArr, previousBuffers) : null);
-    }
-
-    function switchTrackAsked() {
-        scheduleController.switchTrackAsked();
+    function createBufferSinks(previousBuffers) {
+        return (getBuffer() || bufferController ? bufferController.createBufferSink(mediaInfo, previousBuffers) : Promise.resolve(null));
     }
 
-    function createBufferControllerForType(type) {
-        let controller = null;
+    function prepareTrackSwitch() {
+        logger.debug(`Preparing track switch for type ${type}`);
+        const shouldReplace = type === Constants.FRAGMENTED_TEXT || (settings.get().streaming.trackSwitchMode[type] === Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE && playbackController.getTimeToStreamEnd(streamInfo) > settings.get().streaming.buffer.stallThreshold);
 
-        if (!type) {
-            errHandler.error(new DashJSError(Errors.MEDIASOURCE_TYPE_UNSUPPORTED_CODE, Errors.MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE + 'not properly defined'));
-            return null;
+        // when buffering is completed and we are not supposed to replace anything do nothing. Still we need to trigger preloading again
+        if (bufferController.getIsBufferingCompleted() && !shouldReplace) {
+            eventBus.trigger(Events.BUFFERING_COMPLETED, {}, { streamId: streamInfo.id, mediaType: type })
+            return;
         }
 
-        if (type === Constants.VIDEO || type === Constants.AUDIO) {
-            controller = BufferController(context).create({
-                streamInfo: streamInfo,
-                type: type,
-                mediaPlayerModel: mediaPlayerModel,
-                manifestModel: manifestModel,
-                fragmentModel: fragmentModel,
-                errHandler: errHandler,
-                mediaController: mediaController,
-                representationController: representationController,
-                adapter: adapter,
-                textController: textController,
-                abrController: abrController,
-                playbackController: playbackController,
-                settings: settings
-            });
-        } else {
-            controller = TextBufferController(context).create({
-                streamInfo: streamInfo,
-                type: type,
-                mimeType: mimeType,
-                mediaPlayerModel: mediaPlayerModel,
-                manifestModel: manifestModel,
-                fragmentModel: fragmentModel,
-                errHandler: errHandler,
-                mediaController: mediaController,
-                representationController: representationController,
-                adapter: adapter,
-                textController: textController,
-                abrController: abrController,
-                playbackController: playbackController,
-                settings: settings
-            });
-        }
+        // We stop the schedule controller and signal a track switch. That way we request a new init segment next
+        scheduleController.clearScheduleTimer();
+        scheduleController.setSwitchTrack(true);
 
-        return controller;
-    }
-
-
-    function getLiveStartTime() {
-        if (!isDynamic) return NaN;
-        if (!liveEdgeFinder) return NaN;
+        // when we are supposed to replace it does not matter if buffering is already completed
+        if (shouldReplace) {
+            // Inform other classes like the GapController that we are replacing existing stuff
+            eventBus.trigger(Events.TRACK_REPLACEMENT_STARTED, {
+                mediaType: type,
+                streamId: streamInfo.id
+            }, { mediaType: type, streamId: streamInfo.id });
 
-        let liveStartTime = NaN;
-        const currentRepresentationInfo = getRepresentationInfo();
-        const liveEdge = liveEdgeFinder.getLiveEdge(currentRepresentationInfo);
+            // Abort the current request it will be removed from the buffer anyways
+            fragmentModel.abortRequests();
 
-        if (isNaN(liveEdge)) {
-            return NaN;
+            // Abort appending segments to the buffer. Also adjust the appendWindow as we might have been in the progress of prebuffering stuff.
+            bufferController.prepareForReplacementTrackSwitch(mediaInfo.codec)
+                .then(() => {
+                    // Timestamp offset couldve been changed by preloading period
+                    const representationInfo = getRepresentationInfo();
+                    return bufferController.updateBufferTimestampOffset(representationInfo);
+                })
+                .then(() => {
+                    _bufferClearedForReplacementTrackSwitch();
+                })
+                .catch(() => {
+                    _bufferClearedForReplacementTrackSwitch();
+                });
+        } else {
+            // We do not replace anything that is already in the buffer. Still we need to prepare the buffer for the track switch
+            bufferController.prepareForNonReplacementTrackSwitch(mediaInfo.codec)
+                .then(() => {
+                    _bufferClearedForNonReplacementTrackSwitch();
+                })
+                .catch
+                (() => {
+                    _bufferClearedForNonReplacementTrackSwitch();
+                });
         }
+    }
 
-        const request = findRequestForLiveEdge(liveEdge, currentRepresentationInfo);
+    /**
+     * For an instant track switch we need to adjust the buffering time after the buffer has been pruned.
+     * @private
+     */
+    function _bufferClearedForReplacementTrackSwitch() {
+        const targetTime = playbackController.getTime();
 
-        if (request) {
-            // When low latency mode is selected but browser doesn't support fetch
-            // start at the beginning of the segment to avoid consuming the whole buffer
-            if (settings.get().streaming.lowLatencyEnabled) {
-                liveStartTime = request.duration < mediaPlayerModel.getLiveDelay() ? request.startTime : request.startTime + request.duration - mediaPlayerModel.getLiveDelay();
-            } else {
-                liveStartTime = request.startTime;
-            }
+        if (settings.get().streaming.buffer.flushBufferAtTrackSwitch) {
+            // For some devices (like chromecast) it is necessary to seek the video element to reset the internal decoding buffer,
+            // otherwise audio track switch will be effective only once after previous buffered track is consumed
+            playbackController.seek(targetTime + 0.001, false, true);
         }
 
-        return liveStartTime;
+        setExplicitBufferingTime(targetTime);
+        bufferController.setSeekTarget(targetTime);
+        scheduleController.startScheduleTimer();
     }
 
-    function findRequestForLiveEdge(liveEdge, currentRepresentationInfo) {
-        try {
-            let request = null;
-            let liveDelay = playbackController.getLiveDelay();
-            const dvrWindowSize = !isNaN(streamInfo.manifestInfo.DVRWindowSize) ? streamInfo.manifestInfo.DVRWindowSize : liveDelay;
-            const dvrWindowSafetyMargin = 0.1 * dvrWindowSize;
-            let startTime;
-
-            // Make sure that we have at least a valid request for the end of the DVR window, otherwise we might try forever
-            if (!isFinite(dvrWindowSize) || getFragmentRequest(currentRepresentationInfo, liveEdge - dvrWindowSize + dvrWindowSafetyMargin, {
-                ignoreIsFinished: true
-            })) {
-
-                // Try to find a request as close as possible to the targeted live edge
-                while (!request && liveDelay <= dvrWindowSize) {
-                    startTime = liveEdge - liveDelay;
-                    request = getFragmentRequest(currentRepresentationInfo, startTime, {
-                        ignoreIsFinished: true
-                    });
-                    if (!request) {
-                        liveDelay += 1; // Increase by one second for each iteration
-                    }
-                }
-            }
+    function _bufferClearedForNonReplacementTrackSwitch() {
+        const time = playbackController.getTime();
+        const targetTime = bufferController.getContinuousBufferTimeForTargetTime(time);
 
-            if (request) {
-                playbackController.setLiveDelay(liveDelay, true);
-            }
-            logger.debug('live edge: ' + liveEdge + ', live delay: ' + liveDelay + ', live target: ' + startTime);
-            return request;
-        } catch (e) {
-            return null;
-        }
+        setExplicitBufferingTime(targetTime);
+        scheduleController.startScheduleTimer();
     }
 
-    function onSeekTarget(e) {
-        bufferingTime = e.time;
-        scheduleController.setSeekTarget(e.time);
-    }
 
-    function setBufferingTime(value) {
-        bufferingTime = value;
-    }
+    function _createBufferControllerForType(type) {
+        let controller = null;
+
+        if (!type) {
+            errHandler.error(new DashJSError(Errors.MEDIASOURCE_TYPE_UNSUPPORTED_CODE, Errors.MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE + 'not properly defined'));
+            return null;
+        }
 
-    function resetIndexHandler() {
-        if (indexHandler) {
-            indexHandler.resetIndex();
+        if (type === Constants.TEXT) {
+            controller = NotFragmentedTextBufferController(context).create({
+                streamInfo,
+                type,
+                mimeType,
+                fragmentModel,
+                textController,
+                errHandler,
+                settings
+            });
+        } else {
+            controller = BufferController(context).create({
+                streamInfo,
+                type,
+                mediaPlayerModel,
+                manifestModel,
+                fragmentModel,
+                errHandler,
+                mediaController,
+                representationController,
+                adapter,
+                textController,
+                abrController,
+                playbackController,
+                settings
+            });
         }
-    }
 
-    function getInitRequest(quality) {
-        checkInteger(quality);
-        const representation = representationController ? representationController.getRepresentationForQuality(quality) : null;
-        return indexHandler ? indexHandler.getInitRequest(getMediaInfo(), representation) : null;
+        return controller;
     }
 
-    function getFragmentRequest(representationInfo, time, options) {
-        let fragRequest = null;
-
-        if (indexHandler) {
-            const representation = representationController && representationInfo ? representationController.getRepresentationForQuality(representationInfo.quality) : null;
-
-            // if time and options are undefined, it means the next segment is requested
-            // otherwise, the segment at this specific time is requested.
-            if (time !== undefined && options !== undefined) {
-                fragRequest = indexHandler.getSegmentRequestForTime(getMediaInfo(), representation, time, options);
-            } else {
-                fragRequest = indexHandler.getNextSegmentRequest(getMediaInfo(), representation);
-            }
+    function _onSeekTarget(e) {
+        if (e && e.time) {
+            setExplicitBufferingTime(e.time);
+            bufferController.setSeekTarget(e.time);
         }
+    }
 
-        return fragRequest;
+    function setExplicitBufferingTime(value) {
+        bufferingTime = value;
+        shouldUseExplicitTimeForRequest = true;
     }
 
     function finalisePlayList(time, reason) {
@@ -759,38 +950,34 @@ function StreamProcessor(config) {
     }
 
     instance = {
-        initialize: initialize,
-        getStreamId: getStreamId,
-        getType: getType,
-        isUpdating: isUpdating,
-        getBufferController: getBufferController,
-        getFragmentModel: getFragmentModel,
-        getScheduleController: getScheduleController,
-        getRepresentationController: getRepresentationController,
-        getRepresentationInfo: getRepresentationInfo,
-        getBufferLevel: getBufferLevel,
-        isBufferingCompleted: isBufferingCompleted,
-        createBuffer: createBuffer,
-        updateStreamInfo: updateStreamInfo,
-        getStreamInfo: getStreamInfo,
-        selectMediaInfo: selectMediaInfo,
-        addMediaInfo: addMediaInfo,
-        getLiveStartTime: getLiveStartTime,
-        switchTrackAsked: switchTrackAsked,
-        getMediaInfoArr: getMediaInfoArr,
-        getMediaInfo: getMediaInfo,
-        getMediaSource: getMediaSource,
-        setMediaSource: setMediaSource,
-        dischargePreBuffer: dischargePreBuffer,
-        getBuffer: getBuffer,
-        setBuffer: setBuffer,
-        setBufferingTime: setBufferingTime,
-        resetIndexHandler: resetIndexHandler,
-        getInitRequest: getInitRequest,
-        getFragmentRequest: getFragmentRequest,
-        finalisePlayList: finalisePlayList,
-        probeNextRequest: probeNextRequest,
-        reset: reset
+        initialize,
+        getStreamId,
+        getType,
+        isUpdating,
+        getBufferController,
+        getFragmentModel,
+        getScheduleController,
+        getRepresentationController,
+        getRepresentationInfo,
+        getBufferLevel,
+        isBufferingCompleted,
+        createBufferSinks,
+        updateStreamInfo,
+        getStreamInfo,
+        selectMediaInfo,
+        addMediaInfo,
+        prepareTrackSwitch,
+        getMediaInfoArr,
+        getMediaInfo,
+        getMediaSource,
+        setMediaSource,
+        getBuffer,
+        setExplicitBufferingTime,
+        finalisePlayList,
+        probeNextRequest,
+        prepareInnerPeriodPlaybackSeeking,
+        prepareOuterPeriodPlaybackSeeking,
+        reset
     };
 
     setup();
diff --git a/src/streaming/constants/Constants.js b/src/streaming/constants/Constants.js
index 3d346ce91d..89d81a0910 100644
--- a/src/streaming/constants/Constants.js
+++ b/src/streaming/constants/Constants.js
@@ -285,6 +285,13 @@ class Constants {
         this.ARRAY_BUFFER = 'ArrayBuffer';
         this.DVB_REPORTING_URL = 'dvb:reportingUrl';
         this.DVB_PROBABILITY = 'dvb:probability';
+        this.VIDEO_ELEMENT_READY_STATES = {
+            HAVE_NOTHING: 0,
+            HAVE_METADATA: 1,
+            HAVE_CURRENT_DATA: 2,
+            HAVE_FUTURE_DATA: 3,
+            HAVE_ENOUGH_DATA: 4
+        };
     }
 
     constructor() {
diff --git a/src/streaming/controllers/AbrController.js b/src/streaming/controllers/AbrController.js
index 71ab8a9f6d..c160f5472d 100644
--- a/src/streaming/controllers/AbrController.js
+++ b/src/streaming/controllers/AbrController.js
@@ -43,8 +43,8 @@ import SwitchRequestHistory from '../rules/SwitchRequestHistory';
 import DroppedFramesHistory from '../rules/DroppedFramesHistory';
 import ThroughputHistory from '../rules/ThroughputHistory';
 import Debug from '../../core/Debug';
-import { HTTPRequest } from '../vo/metrics/HTTPRequest';
-import { checkInteger } from '../utils/SupervisorTools';
+import {HTTPRequest} from '../vo/metrics/HTTPRequest';
+import {checkInteger} from '../utils/SupervisorTools';
 
 const DEFAULT_VIDEO_BITRATE = 1000;
 const DEFAULT_AUDIO_BITRATE = 100;
@@ -87,33 +87,15 @@ function AbrController() {
         resetInitialSettings();
     }
 
-    function registerStreamType(type, streamProcessor) {
-        switchHistoryDict[type] = switchHistoryDict[type] || SwitchRequestHistory(context).create();
-        streamProcessorDict[type] = streamProcessor;
-        abandonmentStateDict[type] = abandonmentStateDict[type] || {};
-        abandonmentStateDict[type].state = MetricsConstants.ALLOW_LOAD;
-        isUsingBufferOccupancyABRDict[type] = false;
-        isUsingL2AABRDict[type] = false;
-        isUsingLoLPBRDict[type] = false;
-        eventBus.on(Events.LOADING_PROGRESS, onFragmentLoadProgress, instance);
-        if (type === Constants.VIDEO) {
-            eventBus.on(Events.QUALITY_CHANGE_RENDERED, onQualityChangeRendered, instance);
-            droppedFramesHistory = droppedFramesHistory || DroppedFramesHistory(context).create();
-            setElementSize();
-        }
-        eventBus.on(Events.METRIC_ADDED, onMetricAdded, instance);
-        eventBus.on(Events.PERIOD_SWITCH_COMPLETED, createAbrRulesCollection, instance);
-
-        throughputHistory = throughputHistory || ThroughputHistory(context).create({
+    /**
+     * Initialize everything that is not Stream specific. We only have one instance of the ABR Controller for all periods.
+     */
+    function initialize() {
+        droppedFramesHistory = DroppedFramesHistory(context).create();
+        throughputHistory = ThroughputHistory(context).create({
             settings: settings
         });
-    }
-
-    function unRegisterStreamType(type) {
-        delete streamProcessorDict[type];
-    }
 
-    function createAbrRulesCollection() {
         abrRulesCollection = ABRRulesCollection(context).create({
             dashMetrics: dashMetrics,
             mediaPlayerModel: mediaPlayerModel,
@@ -121,6 +103,65 @@ function AbrController() {
         });
 
         abrRulesCollection.initialize();
+
+        eventBus.on(Events.QUALITY_CHANGE_RENDERED, _onQualityChangeRendered, instance);
+        eventBus.on(Events.LOADING_PROGRESS, onFragmentLoadProgress, instance);
+        eventBus.on(Events.METRIC_ADDED, _onMetricAdded, instance);
+    }
+
+    /**
+     * Whenever a StreamProcessor is created it is added to the list of streamProcessorDict
+     * In addition, the corresponding objects for this object and its stream id are created
+     * @param {object} type
+     * @param {object} streamProcessor
+     */
+    function registerStreamType(type, streamProcessor) {
+        const streamId = streamProcessor.getStreamInfo().id;
+
+        if (!streamProcessorDict[streamId]) {
+            streamProcessorDict[streamId] = {};
+        }
+
+        if (!switchHistoryDict[streamId]) {
+            switchHistoryDict[streamId] = {};
+        }
+
+        if (!abandonmentStateDict[streamId]) {
+            abandonmentStateDict[streamId] = {};
+        }
+
+        switchHistoryDict[streamId][type] = SwitchRequestHistory(context).create();
+        streamProcessorDict[streamId][type] = streamProcessor;
+
+        abandonmentStateDict[streamId][type] = {};
+        abandonmentStateDict[streamId][type].state = MetricsConstants.ALLOW_LOAD;
+
+        isUsingBufferOccupancyABRDict[type] = isUsingBufferOccupancyABRDict[type] || false;
+        isUsingL2AABRDict[type] = isUsingL2AABRDict[type] || false;
+        isUsingLoLPBRDict[type] = isUsingLoLPBRDict[type] || false;
+
+        if (type === Constants.VIDEO) {
+            setElementSize();
+        }
+    }
+
+    function unRegisterStreamType(streamId, type) {
+        try {
+            if (streamProcessorDict[streamId] && streamProcessorDict[streamId][type]) {
+                delete streamProcessorDict[streamId][type];
+            }
+
+            if (switchHistoryDict[streamId] && switchHistoryDict[streamId][type]) {
+                delete switchHistoryDict[streamId][type];
+            }
+
+            if (abandonmentStateDict[streamId] && abandonmentStateDict[streamId][type]) {
+                delete abandonmentStateDict[streamId][type];
+            }
+
+        } catch (e) {
+
+        }
     }
 
     function resetInitialSettings() {
@@ -132,9 +173,14 @@ function AbrController() {
         isUsingBufferOccupancyABRDict = {};
         isUsingL2AABRDict = {};
         isUsingLoLPBRDict = {};
+
         if (windowResizeEventCalled === undefined) {
             windowResizeEventCalled = false;
         }
+        if (droppedFramesHistory) {
+            droppedFramesHistory.reset();
+        }
+
         playbackIndex = undefined;
         droppedFramesHistory = undefined;
         throughputHistory = undefined;
@@ -147,9 +193,8 @@ function AbrController() {
         resetInitialSettings();
 
         eventBus.off(Events.LOADING_PROGRESS, onFragmentLoadProgress, instance);
-        eventBus.off(Events.QUALITY_CHANGE_RENDERED, onQualityChangeRendered, instance);
-        eventBus.off(Events.METRIC_ADDED, onMetricAdded, instance);
-        eventBus.off(Events.PERIOD_SWITCH_COMPLETED, createAbrRulesCollection, instance);
+        eventBus.off(Events.QUALITY_CHANGE_RENDERED, _onQualityChangeRendered, instance);
+        eventBus.off(Events.METRIC_ADDED, _onMetricAdded, instance);
 
         if (abrRulesCollection) {
             abrRulesCollection.reset();
@@ -188,16 +233,16 @@ function AbrController() {
         }
     }
 
-    function onQualityChangeRendered(e) {
+    function _onQualityChangeRendered(e) {
         if (e.mediaType === Constants.VIDEO) {
             if (playbackIndex !== undefined) {
-                droppedFramesHistory.push(playbackIndex, videoModel.getPlaybackQuality());
+                droppedFramesHistory.push(e.streamId, playbackIndex, videoModel.getPlaybackQuality());
             }
             playbackIndex = e.newQuality;
         }
     }
 
-    function onMetricAdded(e) {
+    function _onMetricAdded(e) {
         if (e.metric === MetricsConstants.HTTP_REQUEST && e.value && e.value.type === HTTPRequest.MEDIA_SEGMENT_TYPE && (e.mediaType === Constants.AUDIO || e.mediaType === Constants.VIDEO)) {
             throughputHistory.push(e.mediaType, e.value, settings.get().streaming.abr.useDeadTimeLatency);
         }
@@ -207,33 +252,40 @@ function AbrController() {
         }
     }
 
-    function getTopQualityIndexFor(type, id) {
+    /**
+     * Returns the highest possible index taking limitations like maxBitrate and portal size into account.
+     * @param {string} type
+     * @param {string} streamId
+     * @return {number}
+     */
+    function getTopQualityIndexFor(type, streamId) {
         let idx;
-        topQualities[id] = topQualities[id] || {};
+        topQualities[streamId] = topQualities[streamId] || {};
 
-        if (!topQualities[id].hasOwnProperty(type)) {
-            topQualities[id][type] = 0;
+        if (!topQualities[streamId].hasOwnProperty(type)) {
+            topQualities[streamId][type] = 0;
         }
 
-        idx = checkMaxBitrate(topQualities[id][type], type);
-        idx = checkMaxRepresentationRatio(idx, type, topQualities[id][type]);
-        idx = checkPortalSize(idx, type);
+        idx = checkMaxBitrate(topQualities[streamId][type], type, streamId);
+        idx = checkMaxRepresentationRatio(idx, type, topQualities[streamId][type]);
+        idx = checkPortalSize(idx, type, streamId);
         return idx;
     }
 
     /**
      * Gets top BitrateInfo for the player
      * @param {string} type - 'video' or 'audio' are the type options.
+     * @param {string} streamId - Id of the stream
      * @returns {BitrateInfo | null}
      */
-    function getTopBitrateInfoFor(type) {
-        if (type && streamProcessorDict && streamProcessorDict[type]) {
-            const streamInfo = streamProcessorDict[type].getStreamInfo();
-            if (streamInfo && streamInfo.id) {
-                const idx = getTopQualityIndexFor(type, streamInfo.id);
-                const bitrates = getBitrateList(streamProcessorDict[type].getMediaInfo());
-                return bitrates[idx] ? bitrates[idx] : null;
-            }
+    function getTopBitrateInfoFor(type, streamId = null) {
+        if (!streamId) {
+            streamId = streamController.getActiveStreamInfo().id;
+        }
+        if (type && streamProcessorDict && streamProcessorDict[streamId] && streamProcessorDict[streamId][type]) {
+            const idx = getTopQualityIndexFor(type, streamId);
+            const bitrates = getBitrateList(streamProcessorDict[streamId][type].getMediaInfo());
+            return bitrates[idx] ? bitrates[idx] : null;
         }
         return null;
     }
@@ -245,9 +297,11 @@ function AbrController() {
      */
     function getInitialBitrateFor(type) {
         checkConfig();
+
         if (type === Constants.TEXT || type === Constants.FRAGMENTED_TEXT) {
             return NaN;
         }
+
         const savedBitrate = domStorage.getSavedBitrateSettings(type);
         let configBitrate = settings.get().streaming.abr.initialBitrate[type];
         let configRatio = settings.get().streaming.abr.initialRepresentationRatio[type];
@@ -279,23 +333,23 @@ function AbrController() {
         return settings.get().streaming.abr.minBitrate[type];
     }
 
-    function getMaxAllowedIndexFor(type) {
+    function getMaxAllowedIndexFor(type, streamId) {
         const maxBitrate = getMaxAllowedBitrateFor(type);
         if (maxBitrate > -1) {
-            return getQualityForBitrate(streamProcessorDict[type].getMediaInfo(), maxBitrate);
+            return getQualityForBitrate(streamProcessorDict[streamId][type].getMediaInfo(), maxBitrate, streamId);
         } else {
             return undefined;
         }
     }
 
-    function getMinAllowedIndexFor(type) {
+    function getMinAllowedIndexFor(type, streamId) {
         const minBitrate = getMinAllowedBitrateFor(type);
 
         if (minBitrate > -1) {
-            const mediaInfo = streamProcessorDict[type].getMediaInfo();
+            const mediaInfo = streamProcessorDict[streamId][type].getMediaInfo();
             const bitrateList = getBitrateList(mediaInfo);
             // This returns the quality index <= for the given bitrate
-            let minIdx = getQualityForBitrate(mediaInfo, minBitrate);
+            let minIdx = getQualityForBitrate(mediaInfo, minBitrate, streamId);
             if (bitrateList[minIdx] && minIdx < bitrateList.length - 1 && bitrateList[minIdx].bitrate < minBitrate * 1000) {
                 minIdx++; // Go to the next bitrate
             }
@@ -305,16 +359,14 @@ function AbrController() {
         }
     }
 
-    function checkPlaybackQuality(type) {
-        if (type && streamProcessorDict && streamProcessorDict[type]) {
-            const streamInfo = streamProcessorDict[type].getStreamInfo();
-            const streamId = streamInfo ? streamInfo.id : null;
-            const oldQuality = getQualityFor(type);
+    function checkPlaybackQuality(type, streamId) {
+        if (type && streamProcessorDict && streamProcessorDict[streamId] && streamProcessorDict[streamId][type]) {
+            const oldQuality = getQualityFor(type, streamId);
             const rulesContext = RulesContext(context).create({
                 abrController: instance,
-                streamProcessor: streamProcessorDict[type],
+                streamProcessor: streamProcessorDict[streamId][type],
                 currentValue: oldQuality,
-                switchHistory: switchHistoryDict[type],
+                switchHistory: switchHistoryDict[streamId][type],
                 droppedFramesHistory: droppedFramesHistory,
                 useBufferOccupancyABR: useBufferOccupancyABR(type),
                 useL2AABR: useL2AABR(type),
@@ -325,14 +377,16 @@ function AbrController() {
             if (droppedFramesHistory) {
                 const playbackQuality = videoModel.getPlaybackQuality();
                 if (playbackQuality) {
-                    droppedFramesHistory.push(playbackIndex, playbackQuality);
+                    droppedFramesHistory.push(streamId, playbackIndex, playbackQuality);
                 }
             }
+
             if (!!settings.get().streaming.abr.autoSwitchBitrate[type]) {
-                const minIdx = getMinAllowedIndexFor(type);
+                const minIdx = getMinAllowedIndexFor(type, streamId);
                 const topQualityIdx = getTopQualityIndexFor(type, streamId);
                 const switchRequest = abrRulesCollection.getMaxQuality(rulesContext);
                 let newQuality = switchRequest.quality;
+
                 if (minIdx !== undefined && ((newQuality > SwitchRequest.NO_CHANGE) ? newQuality : oldQuality) < minIdx) {
                     newQuality = minIdx;
                 }
@@ -340,11 +394,11 @@ function AbrController() {
                     newQuality = topQualityIdx;
                 }
 
-                switchHistoryDict[type].push({ oldValue: oldQuality, newValue: newQuality });
+                switchHistoryDict[streamId][type].push({ oldValue: oldQuality, newValue: newQuality });
 
                 if (newQuality > SwitchRequest.NO_CHANGE && newQuality != oldQuality) {
-                    if (abandonmentStateDict[type].state === MetricsConstants.ALLOW_LOAD || newQuality > oldQuality) {
-                        changeQuality(type, oldQuality, newQuality, topQualityIdx, switchRequest.reason);
+                    if (abandonmentStateDict[streamId][type].state === MetricsConstants.ALLOW_LOAD || newQuality > oldQuality) {
+                        changeQuality(type, oldQuality, newQuality, topQualityIdx, switchRequest.reason, streamId);
                     }
                 } else if (settings.get().debug.logLevel === Debug.LOG_LEVEL_DEBUG) {
                     const bufferLevel = dashMetrics.getCurrentBufferLevel(type, true);
@@ -354,32 +408,40 @@ function AbrController() {
         }
     }
 
-    function setPlaybackQuality(type, streamInfo, newQuality, reason) {
-        const id = streamInfo.id;
-        const oldQuality = getQualityFor(type);
+    function setPlaybackQuality(type, streamInfo, newQuality, reason = null) {
+        const streamId = streamInfo.id;
+        const oldQuality = getQualityFor(type, streamId);
 
         checkInteger(newQuality);
 
-        const topQualityIdx = getTopQualityIndexFor(type, id);
+        const topQualityIdx = getTopQualityIndexFor(type, streamId);
+        const bitrateInfo = _getBitrateForQuality(type, streamId, newQuality);
+
+        eventBus.trigger(Events.SETTING_PLAYBACK_QUALITY, {
+            newQuality,
+            streamInfo,
+            mediaType: type,
+            bitrateInfo
+        })
+
         if (newQuality !== oldQuality && newQuality >= 0 && newQuality <= topQualityIdx) {
-            changeQuality(type, oldQuality, newQuality, topQualityIdx, reason);
+            changeQuality(type, oldQuality, newQuality, topQualityIdx, reason, streamId);
         }
     }
 
-    function changeQuality(type, oldQuality, newQuality, topQualityIdx, reason) {
-        if (type && streamProcessorDict[type]) {
-            const streamInfo = streamProcessorDict[type].getStreamInfo();
-            const id = streamInfo ? streamInfo.id : null;
-            if (settings.get().debug.logLevel === Debug.LOG_LEVEL_DEBUG) {
-                const bufferLevel = dashMetrics.getCurrentBufferLevel(type);
-                logger.info('[' + type + '] switch from ' + oldQuality + ' to ' + newQuality + '/' + topQualityIdx + ' (buffer: ' + bufferLevel + ') ' + (reason ? JSON.stringify(reason) : '.'));
-            }
-            setQualityFor(type, id, newQuality);
+    function changeQuality(type, oldQuality, newQuality, topQualityIdx, reason, streamId) {
+        if (type && streamProcessorDict[streamId] && streamProcessorDict[streamId][type]) {
+            const streamInfo = streamProcessorDict[streamId][type].getStreamInfo();
+            const bufferLevel = dashMetrics.getCurrentBufferLevel(type);
+            logger.info('[' + type + '] switch from ' + oldQuality + ' to ' + newQuality + '/' + topQualityIdx + ' (buffer: ' + bufferLevel + ') ' + (reason ? JSON.stringify(reason) : '.'));
+
+            setQualityFor(type, newQuality, streamId);
             eventBus.trigger(Events.QUALITY_CHANGE_REQUESTED,
                 {
-                    oldQuality: oldQuality,
-                    newQuality: newQuality,
-                    reason: reason
+                    oldQuality,
+                    newQuality,
+                    reason,
+                    streamInfo
                 },
                 { streamId: streamInfo.id, mediaType: type }
             );
@@ -390,23 +452,36 @@ function AbrController() {
         }
     }
 
-    function setAbandonmentStateFor(type, state) {
-        abandonmentStateDict[type].state = state;
+    function _getBitrateForQuality(type, streamId, quality) {
+        try {
+            const streamInfo = streamController.getStreamById(streamId).getStreamInfo();
+            const mediaInfo = adapter.getMediaInfoForType(streamInfo, type)
+            const bitrateList = getBitrateList(mediaInfo);
+
+            return bitrateList[quality];
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    function setAbandonmentStateFor(streamId, type, state) {
+        abandonmentStateDict[streamId][type].state = state;
     }
 
-    function getAbandonmentStateFor(type) {
-        return abandonmentStateDict[type] ? abandonmentStateDict[type].state : null;
+    function getAbandonmentStateFor(streamId, type) {
+        return abandonmentStateDict[streamId] && abandonmentStateDict[streamId][type] ? abandonmentStateDict[streamId][type].state : null;
     }
 
     /**
      * @param {MediaInfo} mediaInfo
      * @param {number} bitrate A bitrate value, kbps
-     * @param {number} latency Expected latency of connection, ms
+     * @param {String} streamId Period ID
+     * @param {number|null} latency Expected latency of connection, ms
      * @returns {number} A quality index <= for the given bitrate
      * @memberof AbrController#
      */
-    function getQualityForBitrate(mediaInfo, bitrate, latency) {
-        const voRepresentation = mediaInfo && mediaInfo.type ? streamProcessorDict[mediaInfo.type].getRepresentationInfo() : null;
+    function getQualityForBitrate(mediaInfo, bitrate, streamId, latency = null) {
+        const voRepresentation = mediaInfo && mediaInfo.type ? streamProcessorDict[streamId][mediaInfo.type].getRepresentationInfo() : null;
 
         if (settings.get().streaming.abr.useDeadTimeLatency && latency && voRepresentation && voRepresentation.fragmentDuration) {
             latency = latency / 1000;
@@ -526,15 +601,16 @@ function AbrController() {
         const streamId = mediaInfo.streamInfo.id;
         const max = mediaInfo.representationCount - 1;
 
-        setTopQualityIndex(type, streamId, max);
+        topQualities[streamId] = topQualities[streamId] || {};
+        topQualities[streamId][type] = max;
 
         return max;
     }
 
     function isPlayingAtTopQuality(streamInfo) {
         const streamId = streamInfo ? streamInfo.id : null;
-        const audioQuality = getQualityFor(Constants.AUDIO);
-        const videoQuality = getQualityFor(Constants.VIDEO);
+        const audioQuality = getQualityFor(Constants.AUDIO, streamId);
+        const videoQuality = getQualityFor(Constants.VIDEO, streamId);
 
         const isAtTop = (audioQuality === getTopQualityIndexFor(Constants.AUDIO, streamId)) &&
             (videoQuality === getTopQualityIndexFor(Constants.VIDEO, streamId));
@@ -542,49 +618,49 @@ function AbrController() {
         return isAtTop;
     }
 
-    function getQualityFor(type) {
-        if (type && streamProcessorDict[type]) {
-            const streamInfo = streamProcessorDict[type].getStreamInfo();
-            const id = streamInfo ? streamInfo.id : null;
-            let quality;
+    function getQualityFor(type, streamId = null) {
+        try {
+            if (!streamId) {
+                streamId = streamController.getActiveStreamInfo().id;
+            }
+            if (type && streamProcessorDict[streamId] && streamProcessorDict[streamId][type]) {
+                let quality;
+
+                if (streamId) {
+                    qualityDict[streamId] = qualityDict[streamId] || {};
 
-            if (id) {
-                qualityDict[id] = qualityDict[id] || {};
+                    if (!qualityDict[streamId].hasOwnProperty(type)) {
+                        qualityDict[streamId][type] = QUALITY_DEFAULT;
+                    }
 
-                if (!qualityDict[id].hasOwnProperty(type)) {
-                    qualityDict[id][type] = QUALITY_DEFAULT;
+                    quality = qualityDict[streamId][type];
+                    return quality;
                 }
-
-                quality = qualityDict[id][type];
-                return quality;
             }
+            return QUALITY_DEFAULT;
+        } catch (e) {
+            return QUALITY_DEFAULT;
         }
-        return QUALITY_DEFAULT;
     }
 
-    function setQualityFor(type, id, value) {
-        qualityDict[id] = qualityDict[id] || {};
-        qualityDict[id][type] = value;
+    function setQualityFor(type, value, streamId) {
+        qualityDict[streamId] = qualityDict[streamId] || {};
+        qualityDict[streamId][type] = value;
     }
 
-    function setTopQualityIndex(type, id, value) {
-        topQualities[id] = topQualities[id] || {};
-        topQualities[id][type] = value;
-    }
-
-    function checkMaxBitrate(idx, type) {
+    function checkMaxBitrate(idx, type, streamId) {
         let newIdx = idx;
 
-        if (!streamProcessorDict[type]) {
+        if (!streamProcessorDict[streamId] || !streamProcessorDict[streamId][type]) {
             return newIdx;
         }
 
-        const minIdx = getMinAllowedIndexFor(type);
+        const minIdx = getMinAllowedIndexFor(type, streamId);
         if (minIdx !== undefined) {
             newIdx = Math.max(idx, minIdx);
         }
 
-        const maxIdx = getMaxAllowedIndexFor(type);
+        const maxIdx = getMaxAllowedIndexFor(type, streamId);
         if (maxIdx !== undefined) {
             newIdx = Math.min(newIdx, maxIdx);
         }
@@ -613,8 +689,8 @@ function AbrController() {
         }
     }
 
-    function checkPortalSize(idx, type) {
-        if (type !== Constants.VIDEO || !settings.get().streaming.abr.limitBitrateByPortal || !streamProcessorDict[type]) {
+    function checkPortalSize(idx, type, streamId) {
+        if (type !== Constants.VIDEO || !settings.get().streaming.abr.limitBitrateByPortal || !streamProcessorDict[streamId] || !streamProcessorDict[streamId][type]) {
             return idx;
         }
 
@@ -646,8 +722,10 @@ function AbrController() {
 
     function onFragmentLoadProgress(e) {
         const type = e.request.mediaType;
+        const streamId = e.streamId;
+
         if (!!settings.get().streaming.abr.autoSwitchBitrate[type]) {
-            const streamProcessor = streamProcessorDict[type];
+            const streamProcessor = streamProcessorDict[streamId][type];
             if (!streamProcessor) return; // There may be a fragment load in progress when we switch periods and recreated some controllers.
 
             const rulesContext = RulesContext(context).create({
@@ -659,7 +737,7 @@ function AbrController() {
                 useLoLPABR: useLoLPABR(type),
                 videoModel
             });
-            const switchRequest = abrRulesCollection.shouldAbandonFragment(rulesContext);
+            const switchRequest = abrRulesCollection.shouldAbandonFragment(rulesContext, streamId);
 
             if (switchRequest.quality > SwitchRequest.NO_CHANGE) {
                 const fragmentModel = streamProcessor.getFragmentModel();
@@ -670,10 +748,10 @@ function AbrController() {
                 if (request) {
                     //TODO Check if we should abort or if better to finish download. check bytesLoaded/Total
                     fragmentModel.abortRequests();
-                    setAbandonmentStateFor(type, MetricsConstants.ABANDON_LOAD);
-                    switchHistoryDict[type].reset();
-                    switchHistoryDict[type].push({
-                        oldValue: getQualityFor(type),
+                    setAbandonmentStateFor(streamId, type, MetricsConstants.ABANDON_LOAD);
+                    switchHistoryDict[streamId][type].reset();
+                    switchHistoryDict[streamId][type].push({
+                        oldValue: getQualityFor(type, streamId),
                         newValue: switchRequest.quality,
                         confidence: 1,
                         reason: switchRequest.reason
@@ -683,7 +761,7 @@ function AbrController() {
                     clearTimeout(abandonmentTimeout);
                     abandonmentTimeout = setTimeout(
                         () => {
-                            setAbandonmentStateFor(type, MetricsConstants.ALLOW_LOAD);
+                            setAbandonmentStateFor(streamId, type, MetricsConstants.ALLOW_LOAD);
                             abandonmentTimeout = null;
                         },
                         settings.get().streaming.abandonLoadTimeout
@@ -693,28 +771,45 @@ function AbrController() {
         }
     }
 
+    function clearDataForStream(streamId) {
+        if (droppedFramesHistory) {
+            droppedFramesHistory.clearForStream(streamId);
+        }
+        if (streamProcessorDict[streamId]) {
+            delete streamProcessorDict[streamId];
+        }
+        if (switchHistoryDict[streamId]) {
+            delete switchHistoryDict[streamId];
+        }
+
+        if (abandonmentStateDict[streamId]) {
+            delete abandonmentStateDict[streamId];
+        }
+    }
+
     instance = {
-        isPlayingAtTopQuality: isPlayingAtTopQuality,
-        updateTopQualityIndex: updateTopQualityIndex,
-        getThroughputHistory: getThroughputHistory,
-        getBitrateList: getBitrateList,
-        getQualityForBitrate: getQualityForBitrate,
-        getTopBitrateInfoFor: getTopBitrateInfoFor,
-        getMaxAllowedIndexFor: getMaxAllowedIndexFor,
-        getMinAllowedIndexFor: getMinAllowedIndexFor,
-        getInitialBitrateFor: getInitialBitrateFor,
-        getQualityFor: getQualityFor,
-        getAbandonmentStateFor: getAbandonmentStateFor,
-        setPlaybackQuality: setPlaybackQuality,
-        checkPlaybackQuality: checkPlaybackQuality,
-        getTopQualityIndexFor: getTopQualityIndexFor,
-        setElementSize: setElementSize,
-        setWindowResizeEventCalled: setWindowResizeEventCalled,
-        createAbrRulesCollection: createAbrRulesCollection,
-        registerStreamType: registerStreamType,
-        unRegisterStreamType: unRegisterStreamType,
-        setConfig: setConfig,
-        reset: reset
+        initialize,
+        isPlayingAtTopQuality,
+        updateTopQualityIndex,
+        clearDataForStream,
+        getThroughputHistory,
+        getBitrateList,
+        getQualityForBitrate,
+        getTopBitrateInfoFor,
+        getMaxAllowedIndexFor,
+        getMinAllowedIndexFor,
+        getInitialBitrateFor,
+        getQualityFor,
+        getAbandonmentStateFor,
+        setPlaybackQuality,
+        checkPlaybackQuality,
+        getTopQualityIndexFor,
+        setElementSize,
+        setWindowResizeEventCalled,
+        registerStreamType,
+        unRegisterStreamType,
+        setConfig,
+        reset
     };
 
     setup();
diff --git a/src/streaming/controllers/BufferController.js b/src/streaming/controllers/BufferController.js
index d3458c9a77..a74f354227 100644
--- a/src/streaming/controllers/BufferController.js
+++ b/src/streaming/controllers/BufferController.js
@@ -32,7 +32,6 @@ import Constants from '../constants/Constants';
 import MetricsConstants from '../constants/MetricsConstants';
 import FragmentModel from '../models/FragmentModel';
 import SourceBufferSink from '../SourceBufferSink';
-import PreBufferSink from '../PreBufferSink';
 import AbrController from './AbrController';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
@@ -42,8 +41,8 @@ import InitCache from '../utils/InitCache';
 import DashJSError from '../vo/DashJSError';
 import Errors from '../../core/errors/Errors';
 import {HTTPRequest} from '../vo/metrics/HTTPRequest';
+import MediaPlayerEvents from '../../streaming/MediaPlayerEvents';
 
-const BUFFERING_COMPLETED_THRESHOLD = 0.1;
 const BUFFER_END_THRESHOLD = 0.5;
 const BUFFER_RANGE_CALCULATION_THRESHOLD = 0.01;
 const QUOTA_EXCEEDED_ERROR_CODE = 22;
@@ -58,7 +57,6 @@ function BufferController(config) {
     const errHandler = config.errHandler;
     const fragmentModel = config.fragmentModel;
     const representationController = config.representationController;
-    const mediaController = config.mediaController;
     const adapter = config.adapter;
     const textController = config.textController;
     const abrController = config.abrController;
@@ -75,21 +73,17 @@ function BufferController(config) {
         criticalBufferLevel,
         mediaSource,
         maxAppendedIndex,
-        lastIndex,
-        buffer,
-        dischargeBuffer,
-        dischargeFragments,
+        maximumIndex,
+        sourceBufferSink,
         bufferState,
         appendedBytesInfo,
         wallclockTicked,
         isPruningInProgress,
         isQuotaExceeded,
         initCache,
-        seekTarget,
-        seekClearedBufferingCompleted,
         pendingPruningRanges,
         replacingBuffer,
-        mediaChunk;
+        seekTarget;
 
 
     function setup() {
@@ -99,119 +93,130 @@ function BufferController(config) {
         resetInitialSettings();
     }
 
-    function getBufferControllerType() {
-        return BUFFER_CONTROLLER_TYPE;
-    }
-
-    function initialize(Source) {
-        setMediaSource(Source);
-
-        requiredQuality = abrController.getQualityFor(type);
-
-        eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
-        eventBus.on(Events.INIT_FRAGMENT_LOADED, onInitFragmentLoaded, this);
-        eventBus.on(Events.MEDIA_FRAGMENT_LOADED, onMediaFragmentLoaded, this);
-        eventBus.on(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, this);
-        eventBus.on(Events.STREAM_COMPLETED, onStreamCompleted, this);
-        eventBus.on(Events.PLAYBACK_PLAYING, onPlaybackPlaying, this);
-        eventBus.on(Events.PLAYBACK_PROGRESS, onPlaybackProgression, this);
-        eventBus.on(Events.PLAYBACK_TIME_UPDATED, onPlaybackProgression, this);
-        eventBus.on(Events.PLAYBACK_RATE_CHANGED, onPlaybackRateChanged, this);
-        eventBus.on(Events.PLAYBACK_SEEKING, onPlaybackSeeking, this);
-        eventBus.on(Events.PLAYBACK_SEEKED, onPlaybackSeeked, this);
-        eventBus.on(Events.PLAYBACK_STALLED, onPlaybackStalled, this);
-        eventBus.on(Events.WALLCLOCK_TIME_UPDATED, onWallclockTimeUpdated, this);
-        eventBus.on(Events.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, this, { priority: EventBus.EVENT_PRIORITY_HIGH });
-        eventBus.on(Events.SOURCEBUFFER_REMOVE_COMPLETED, onRemoved, this);
+    /**
+     * Initialize the BufferController. Sets the media source and registers the event handlers.
+     * @param {object} mediaSource
+     */
+    function initialize(mediaSource) {
+        setMediaSource(mediaSource);
+
+        requiredQuality = abrController.getQualityFor(type, streamInfo.id);
+
+        eventBus.on(Events.INIT_FRAGMENT_LOADED, _onInitFragmentLoaded, instance);
+        eventBus.on(Events.MEDIA_FRAGMENT_LOADED, _onMediaFragmentLoaded, instance);
+        eventBus.on(Events.STREAM_REQUESTING_COMPLETED, _onStreamRequestingCompleted, instance);
+        eventBus.on(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, instance);
+
+        eventBus.on(MediaPlayerEvents.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_PLAYING, _onPlaybackPlaying, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_PROGRESS, _onPlaybackProgression, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_TIME_UPDATED, _onPlaybackProgression, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_RATE_CHANGED, _onPlaybackRateChanged, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_STALLED, _onPlaybackStalled, instance);
     }
 
+    /**
+     * Returns the stream id
+     * @return {string}
+     */
     function getStreamId() {
         return streamInfo.id;
     }
 
+    /**
+     * Returns the media type
+     * @return {type}
+     */
     function getType() {
         return type;
     }
 
-
-    function getRepresentationInfo(quality) {
-        return adapter.convertDataToRepresentationInfo(representationController.getRepresentationForQuality(quality));
+    /**
+     * Returns the type of the BufferController. We distinguish between standard buffer controllers and buffer controllers related to texttracks.
+     * @return {string}
+     */
+    function getBufferControllerType() {
+        return BUFFER_CONTROLLER_TYPE;
     }
 
-    function createBuffer(mediaInfoArr, oldBuffers) {
-        if (!initCache || !mediaInfoArr) return null;
-        const mediaInfo = mediaInfoArr[0];
-        if (mediaSource) {
-            try {
-                if (oldBuffers && oldBuffers[type]) {
-                    buffer = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppended.bind(this), oldBuffers[type]);
-                } else {
-                    buffer = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppended.bind(this), null);
-                }
-                if (settings.get().streaming.useAppendWindow) {
-                    buffer.updateAppendWindow(streamInfo);
-                }
-                if (typeof buffer.getBuffer().initialize === 'function') {
-                    buffer.getBuffer().initialize(type, streamInfo, mediaInfoArr, fragmentModel);
-                }
-            } catch (e) {
-                logger.fatal('Caught error on create SourceBuffer: ' + e);
-                errHandler.error(new DashJSError(Errors.MEDIASOURCE_TYPE_UNSUPPORTED_CODE, Errors.MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE + type));
-            }
-        } else {
-            buffer = PreBufferSink(context).create(onAppended.bind(this));
-        }
-        updateBufferTimestampOffset(getRepresentationInfo(requiredQuality));
-        return buffer;
+    /**
+     * Sets the mediasource.
+     * @param {object} value
+     */
+    function setMediaSource(value) {
+        mediaSource = value;
     }
 
-    function dischargePreBuffer() {
-        if (buffer && dischargeBuffer && typeof dischargeBuffer.discharge === 'function') {
-            const ranges = dischargeBuffer.getAllBufferRanges();
+    /**
+     * Get the RepresentationInfo for a certain quality.
+     * @param {number} quality
+     * @return {object}
+     * @private
+     */
+    function _getRepresentationInfo(quality) {
+        return adapter.convertDataToRepresentationInfo(representationController.getRepresentationForQuality(quality));
+    }
 
-            if (ranges.length > 0) {
-                let rangeStr = 'Beginning ' + type + 'PreBuffer discharge, adding buffer for:';
-                for (let i = 0; i < ranges.length; i++) {
-                    rangeStr += ' start: ' + ranges.start(i) + ', end: ' + ranges.end(i) + ';';
-                }
-                logger.debug(rangeStr);
-            } else {
-                logger.debug('PreBuffer discharge requested, but there were no media segments in the PreBuffer.');
+    /**
+     * Creates a SourceBufferSink object
+     * @param {object} mediaInfo
+     * @param {array} oldBufferSinks
+     * @return {object|null} SourceBufferSink
+     */
+    function createBufferSink(mediaInfo, oldBufferSinks = []) {
+        return new Promise((resolve, reject) => {
+            if (!initCache || !mediaInfo || !mediaSource) {
+                resolve(null);
+                return;
             }
 
-            //A list of fragments to supress bytesAppended events for. This makes transferring from a prebuffer to a sourcebuffer silent.
-            dischargeFragments = [];
-            let chunks = dischargeBuffer.discharge();
-            let lastInit = null;
-            for (let j = 0; j < chunks.length; j++) {
-                const chunk = chunks[j];
-                if (chunk.segmentType !== 'InitializationSegment') {
-                    const initChunk = initCache.extract(chunk.streamId, chunk.representationId);
-                    if (initChunk) {
-                        if (lastInit !== initChunk) {
-                            dischargeFragments.push(initChunk);
-                            buffer.append(initChunk);
-                            lastInit = initChunk;
-                        }
-                    }
-                }
-                dischargeFragments.push(chunk);
-                buffer.append(chunk);
-            }
+            sourceBufferSink = SourceBufferSink(context).create({ mediaSource, textController });
+            _initializeSink(mediaInfo, oldBufferSinks)
+                .then(() => {
+                    return updateBufferTimestampOffset(_getRepresentationInfo(requiredQuality));
+                })
+                .then(() => {
+                    resolve(sourceBufferSink);
+                })
+                .catch((e) => {
+                    logger.fatal('Caught error on create SourceBuffer: ' + e);
+                    errHandler.error(new DashJSError(Errors.MEDIASOURCE_TYPE_UNSUPPORTED_CODE, Errors.MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE + type));
+                    reject(e);
+                });
+        });
+    }
+
+    function _initializeSink(mediaInfo, oldBufferSinks) {
+        const selectedRepresentation = _getRepresentationInfo(requiredQuality);
 
-            dischargeBuffer.reset();
-            dischargeBuffer = null;
+        if (oldBufferSinks && oldBufferSinks[type] && (type === Constants.VIDEO || type === Constants.AUDIO)) {
+            return sourceBufferSink.initializeForStreamSwitch(mediaInfo, selectedRepresentation, oldBufferSinks[type]);
+        } else {
+            return sourceBufferSink.initializeForFirstUse(streamInfo, mediaInfo, selectedRepresentation);
         }
     }
 
-    function onInitFragmentLoaded(e) {
-        logger.info('Init fragment finished loading saving to', type + '\'s init cache');
-        initCache.save(e.chunk);
+
+    /**
+     * Callback handler when init segment has been loaded. Based on settings, the init segment is saved to the cache, and appended to the buffer.
+     * @param {object} e
+     * @private
+     */
+    function _onInitFragmentLoaded(e) {
+        if (settings.get().streaming.cacheInitSegments) {
+            logger.info('Init fragment finished loading saving to', type + '\'s init cache');
+            initCache.save(e.chunk);
+        }
         logger.debug('Append Init fragment', type, ' with representationId:', e.chunk.representationId, ' and quality:', e.chunk.quality, ', data size:', e.chunk.bytes.byteLength);
-        appendToBuffer(e.chunk);
+        _appendToBuffer(e.chunk);
     }
 
-    function appendInitSegment(representationId) {
+    /**
+     * Append the init segment for a certain representation to the buffer. If the init segment is cached we take the one from the cache. Otherwise the function returns false and the segment has to be requested again.
+     * @param {string} representationId
+     * @return {boolean}
+     */
+    function appendInitSegmentFromCache(representationId) {
         // Get init segment from cache
         const chunk = initCache.extract(streamInfo.id, representationId);
 
@@ -222,38 +227,39 @@ function BufferController(config) {
 
         // Append init segment into buffer
         logger.info('Append Init fragment', type, ' with representationId:', chunk.representationId, ' and quality:', chunk.quality, ', data size:', chunk.bytes.byteLength);
-        appendToBuffer(chunk);
+        _appendToBuffer(chunk);
+
         return true;
     }
 
-    function onMediaFragmentLoaded(e) {
-        const chunk = e.chunk;
-
-        if (replacingBuffer) {
-            mediaChunk = chunk;
-            const ranges = buffer && buffer.getAllBufferRanges();
-            if (ranges && ranges.length > 0 && playbackController.getTimeToStreamEnd() > settings.get().streaming.stallThreshold) {
-                logger.debug('Clearing buffer because track changed - ' + (ranges.end(ranges.length - 1) + BUFFER_END_THRESHOLD));
-                clearBuffers([{
-                    start: 0,
-                    end: ranges.end(ranges.length - 1) + BUFFER_END_THRESHOLD,
-                    force: true // Force buffer removal even when buffering is completed and MediaSource is ended
-                }]);
-            }
-        } else {
-            appendToBuffer(chunk);
-        }
+    /**
+     * Calls the _appendToBuffer function to append the segment to the buffer. In case of a track switch the buffer might be cleared.
+     * @param {object} e
+     */
+    function _onMediaFragmentLoaded(e) {
+        _appendToBuffer(e.chunk);
     }
 
-    function appendToBuffer(chunk) {
-        buffer.append(chunk);
+    /**
+     * Append data to the MSE buffer using the SourceBufferSink
+     * @param {object} chunk
+     * @private
+     */
+    function _appendToBuffer(chunk) {
+        sourceBufferSink.append(chunk)
+            .then((e) => {
+                _onAppended(e);
+            })
+            .catch((e) => {
+                _onAppended({ error: e });
+            });
 
         if (chunk.mediaInfo.type === Constants.VIDEO) {
-            triggerEvent(Events.VIDEO_CHUNK_RECEIVED, {chunk: chunk});
+            triggerEvent(Events.VIDEO_CHUNK_RECEIVED, { chunk: chunk });
         }
     }
 
-    function showBufferRanges(ranges) {
+    function _showBufferRanges(ranges) {
         if (ranges && ranges.length > 0) {
             for (let i = 0, len = ranges.length; i < len; i++) {
                 logger.debug('Buffered range: ' + ranges.start(i) + ' - ' + ranges.end(i) + ', currentTime = ', playbackController.getTime());
@@ -261,32 +267,15 @@ function BufferController(config) {
         }
     }
 
-    function onAppended(e) {
+    function _onAppended(e) {
         if (e.error) {
+            // If we receive a QUOTA_EXCEEDED_ERROR_CODE we should adjust the target buffer times to avoid this error in the future.
             if (e.error.code === QUOTA_EXCEEDED_ERROR_CODE) {
-                isQuotaExceeded = true;
-                criticalBufferLevel = getTotalBufferedTime() * 0.8;
-                logger.warn('Quota exceeded, Critical Buffer: ' + criticalBufferLevel);
-
-                if (criticalBufferLevel > 0) {
-                    // recalculate buffer lengths according to criticalBufferLevel
-                    const bufferToKeep = Math.max(0.2 * criticalBufferLevel, 1);
-                    const bufferAhead = criticalBufferLevel - bufferToKeep;
-                    const bufferTimeAtTopQuality = Math.min(settings.get().streaming.bufferTimeAtTopQuality, bufferAhead * 0.9);
-                    const bufferTimeAtTopQualityLongForm = Math.min(settings.get().streaming.bufferTimeAtTopQualityLongForm, bufferAhead * 0.9);
-                    const s = {
-                        streaming: {
-                            bufferToKeep: parseFloat(bufferToKeep.toFixed(5)),
-                            bufferTimeAtTopQuality: parseFloat(bufferTimeAtTopQuality.toFixed(5)),
-                            bufferTimeAtTopQualityLongForm: parseFloat(bufferTimeAtTopQualityLongForm.toFixed(5))
-                        }
-                    };
-                    settings.update(s);
-                }
+                _handleQuotaExceededError();
             }
             if (e.error.code === QUOTA_EXCEEDED_ERROR_CODE || !hasEnoughSpaceToAppend()) {
                 logger.warn('Clearing playback buffer to overcome quota exceed situation');
-                // Notify Schedulecontroller to stop scheduling until buffer has been pruned
+                // Notify ScheduleController to stop scheduling until buffer has been pruned
                 triggerEvent(Events.QUOTA_EXCEEDED, {
                     criticalBufferLevel: criticalBufferLevel,
                     quotaExceededTime: e.chunk.start
@@ -295,207 +284,286 @@ function BufferController(config) {
             }
             return;
         }
-        isQuotaExceeded = false;
 
+        _updateBufferLevel();
+
+        isQuotaExceeded = false;
         appendedBytesInfo = e.chunk;
+
+        if (!appendedBytesInfo.endFragment) {
+            return;
+        }
+
         if (appendedBytesInfo && !isNaN(appendedBytesInfo.index)) {
             maxAppendedIndex = Math.max(appendedBytesInfo.index, maxAppendedIndex);
-            checkIfBufferingCompleted();
+            _checkIfBufferingCompleted();
         }
 
-        const ranges = buffer.getAllBufferRanges();
+        const ranges = sourceBufferSink.getAllBufferRanges();
         if (appendedBytesInfo.segmentType === HTTPRequest.MEDIA_SEGMENT_TYPE) {
-            showBufferRanges(ranges);
-            onPlaybackProgression();
-            adjustSeekTarget();
-        } else if (replacingBuffer) {
-            // When replacing buffer due to switch track, and once new initialization segment has been appended
-            // (and previous buffered data removed) then seek stream to current time
-            const currentTime = playbackController.getTime();
-            logger.debug('AppendToBuffer seek target should be ' + currentTime);
-            triggerEvent(Events.SEEK_TARGET, {time: currentTime});
+            _showBufferRanges(ranges);
+            _onPlaybackProgression();
+            _adjustSeekTarget();
         }
 
-        let suppressAppendedEvent = false;
-        if (dischargeFragments) {
-            if (dischargeFragments.indexOf(appendedBytesInfo) > 0) {
-                suppressAppendedEvent = true;
-            }
-            dischargeFragments = null;
-        }
-        if (appendedBytesInfo && !suppressAppendedEvent) {
-            triggerEvent(appendedBytesInfo.endFragment ? Events.BYTES_APPENDED_END_FRAGMENT : Events.BYTES_APPENDED, {
+        if (appendedBytesInfo) {
+            triggerEvent(Events.BYTES_APPENDED_END_FRAGMENT, {
                 quality: appendedBytesInfo.quality,
                 startTime: appendedBytesInfo.start,
                 index: appendedBytesInfo.index,
                 bufferedRanges: ranges,
+                segmentType: appendedBytesInfo.segmentType,
                 mediaType: type
             });
         }
     }
 
-    function adjustSeekTarget() {
-        // Check buffered data only for audio and video
-        if (type !== Constants.AUDIO && type !== Constants.VIDEO) return;
+    /**
+     * In some cases the segment we requested might start at a different time than we initially aimed for. segments timeline/template tolerance.
+     * We might need to do an internal seek if there is drift.
+     * @private
+     */
+    function _adjustSeekTarget() {
         if (isNaN(seekTarget)) return;
+        // Check buffered data only for audio and video
+        if (type !== Constants.AUDIO && type !== Constants.VIDEO) {
+            seekTarget = NaN;
+            return;
+        }
 
         // Check if current buffered range already contains seek target (and current video element time)
         const currentTime = playbackController.getTime();
         let range = getRangeAt(seekTarget, 0);
-        if (currentTime === seekTarget && range) return;
+        if (currentTime === seekTarget && range) {
+            seekTarget = NaN;
+            return;
+        }
 
         // Get buffered range corresponding to the seek target
         const segmentDuration = representationController.getCurrentRepresentation().segmentDuration;
         range = getRangeAt(seekTarget, segmentDuration);
         if (!range) return;
 
-        if (Math.abs(currentTime - seekTarget) > segmentDuration) {
-            // If current video model time is decorrelated from seek target (and appended buffer) then seek video element
-            // (in case of live streams on some browsers/devices for which we can't set video element time at unavalaible range)
-
-            // Check if appended segment is not anterior from seek target (segments timeline/template tolerance)
-            if (seekTarget <= range.end) {
-                // Seek video element to seek target or range start if appended buffer starts after seek target (segments timeline/template tolerance)
-                playbackController.seek(Math.max(seekTarget, range.start), false, true);
-                seekTarget = NaN;
-            }
-        } else if (currentTime < range.start) {
+        if (currentTime < range.start) {
             // If appended buffer starts after seek target (segments timeline/template tolerance) then seek to range start
             playbackController.seek(range.start, false, true);
             seekTarget = NaN;
         }
     }
 
-    function onQualityChanged(e) {
-        if (requiredQuality === e.newQuality) return;
+    function _handleQuotaExceededError() {
+        isQuotaExceeded = true;
+        criticalBufferLevel = getTotalBufferedTime() * 0.8;
+        logger.warn('Quota exceeded, Critical Buffer: ' + criticalBufferLevel);
+
+        if (criticalBufferLevel > 0) {
+            // recalculate buffer lengths according to criticalBufferLevel
+            const bufferToKeep = Math.max(0.2 * criticalBufferLevel, 1);
+            const bufferAhead = criticalBufferLevel - bufferToKeep;
+            const bufferTimeAtTopQuality = Math.min(settings.get().streaming.buffer.bufferTimeAtTopQuality, bufferAhead * 0.9);
+            const bufferTimeAtTopQualityLongForm = Math.min(settings.get().streaming.buffer.bufferTimeAtTopQualityLongForm, bufferAhead * 0.9);
+            const s = {
+                streaming: {
+                    buffer: {
+                        bufferToKeep: parseFloat(bufferToKeep.toFixed(5)),
+                        bufferTimeAtTopQuality: parseFloat(bufferTimeAtTopQuality.toFixed(5)),
+                        bufferTimeAtTopQualityLongForm: parseFloat(bufferTimeAtTopQualityLongForm.toFixed(5))
+                    }
+                }
+            };
+            settings.update(s);
+        }
+    }
+
+    function _onQualityChanged(e) {
+        if (requiredQuality === e.newQuality || isBufferingCompleted) return;
 
-        updateBufferTimestampOffset(this.getRepresentationInfo(e.newQuality));
+        const representationInfo = _getRepresentationInfo(e.newQuality);
         requiredQuality = e.newQuality;
+        updateBufferTimestampOffset(representationInfo);
     }
 
     //**********************************************************************
     // START Buffer Level, State & Sufficiency Handling.
     //**********************************************************************
-    function onPlaybackSeeking(e) {
-        if (!buffer) return;
-        seekTarget = e.seekTime;
+    function prepareForPlaybackSeek() {
         if (isBufferingCompleted) {
-            seekClearedBufferingCompleted = true;
-            isBufferingCompleted = false;
-            //a seek command has occured, reset lastIndex value, it will be set next time that onStreamCompleted will be called.
-            lastIndex = Number.POSITIVE_INFINITY;
-        }
-        if (type !== Constants.FRAGMENTED_TEXT) {
-            // remove buffer after seeking operations
-            pruneAllSafely();
-        } else {
-            onPlaybackProgression();
+            setIsBufferingCompleted(false);
         }
+
+        // Abort the current request and empty all possible segments to be appended
+        return sourceBufferSink.abort();
     }
 
-    function onPlaybackSeeked() {
-        seekTarget = NaN;
+    function prepareForReplacementTrackSwitch(codec) {
+        return new Promise((resolve, reject) => {
+            sourceBufferSink.abort()
+                .then(() => {
+                    return updateAppendWindow();
+                })
+                .then(() => {
+                    return sourceBufferSink.changeType(codec);
+                })
+                .then(() => {
+                    return pruneAllSafely();
+                })
+                .then(() => {
+                    setIsBufferingCompleted(false);
+                    resolve();
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
+    }
+
+    function prepareForNonReplacementTrackSwitch(codec) {
+        return new Promise((resolve, reject) => {
+            updateAppendWindow()
+                .then(() => {
+                    return sourceBufferSink.changeType(codec);
+                })
+                .then(() => {
+                    resolve();
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
     }
 
-    // Prune full buffer but what is around current time position
     function pruneAllSafely() {
-        if (!buffer) return;
-        buffer.waitForUpdateEnd(() => {
-            const ranges = getAllRangesWithSafetyFactor();
+        return new Promise((resolve, reject) => {
+            let ranges = getAllRangesWithSafetyFactor();
+
             if (!ranges || ranges.length === 0) {
-                onPlaybackProgression();
+                _onPlaybackProgression();
+                resolve();
+                return;
             }
-            clearBuffers(ranges);
+
+            clearBuffers(ranges)
+                .then(() => {
+                    resolve();
+                })
+                .catch((e) => {
+                    reject(e);
+                });
         });
     }
 
-    // Get all buffer ranges but a range around current time position
-    function getAllRangesWithSafetyFactor() {
-        if (!buffer) return;
+    function getAllRangesWithSafetyFactor(seekTime) {
         const clearRanges = [];
-        const ranges = buffer.getAllBufferRanges();
+        const ranges = sourceBufferSink.getAllBufferRanges();
+
+        // no valid ranges
         if (!ranges || ranges.length === 0) {
             return clearRanges;
         }
 
-        const currentTime = playbackController.getTime();
-        const endOfBuffer = ranges.end(ranges.length - 1) + BUFFER_END_THRESHOLD;
-
-        const currentTimeRequest = fragmentModel.getRequests({
-            state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
-            time: currentTime,
-            threshold: BUFFER_RANGE_CALCULATION_THRESHOLD
-        })[0];
-
-        // There is no request in current time position yet. Let's remove everything
-        if (!currentTimeRequest) {
-            logger.debug('getAllRangesWithSafetyFactor - No request found in current time position, removing full buffer 0 -', endOfBuffer);
+        // if no target time is provided we clear everyhing
+        if (!seekTime || isNaN(seekTime)) {
             clearRanges.push({
-                start: 0,
-                end: endOfBuffer
+                start: ranges.start(0),
+                end: ranges.end(ranges.length - 1) + BUFFER_END_THRESHOLD
             });
-        } else {
-            // Build buffer behind range. To avoid pruning time around current time position,
-            // we include fragment right behind the one in current time position
-            const behindRange = {
-                start: 0,
-                end: currentTimeRequest.startTime - settings.get().streaming.stallThreshold
-            };
-            const prevReq = fragmentModel.getRequests({
+        }
+
+        // otherwise we need to calculate the correct pruning range
+        else {
+
+            const behindPruningRange = _getRangeBehindForPruning(seekTime, ranges);
+            const aheadPruningRange = _getRangeAheadForPruning(seekTime, ranges);
+
+            if (behindPruningRange) {
+                clearRanges.push(behindPruningRange);
+            }
+
+            if (aheadPruningRange) {
+                clearRanges.push(aheadPruningRange);
+            }
+        }
+
+        return clearRanges;
+    }
+
+    function _getRangeBehindForPruning(targetTime, ranges) {
+        const bufferToKeepBehind = settings.get().streaming.buffer.bufferToKeep;
+        const startOfBuffer = ranges.start(0);
+
+        // if we do a seek ahead of the current play position we do need to prune behind the new play position
+        const behindDiff = targetTime - startOfBuffer;
+        if (behindDiff > bufferToKeepBehind) {
+
+            let rangeEnd = Math.max(0, targetTime - bufferToKeepBehind);
+            // Ensure we keep full range of current fragment
+            const currentTimeRequest = fragmentModel.getRequests({
                 state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
-                time: currentTimeRequest.startTime - (currentTimeRequest.duration / 2),
+                time: targetTime,
                 threshold: BUFFER_RANGE_CALCULATION_THRESHOLD
             })[0];
-            if (prevReq && prevReq.startTime != currentTimeRequest.startTime) {
-                behindRange.end = prevReq.startTime;
+
+            if (currentTimeRequest) {
+                rangeEnd = Math.min(currentTimeRequest.startTime, rangeEnd);
             }
-            if (behindRange.start < behindRange.end && behindRange.end > ranges.start(0)) {
-                clearRanges.push(behindRange);
+            if (rangeEnd > 0) {
+                return {
+                    start: startOfBuffer,
+                    end: rangeEnd
+                };
             }
+        }
 
-            // Build buffer ahead range. To avoid pruning time around current time position,
-            // we include fragment right after the one in current time position
-            const aheadRange = {
-                start: currentTimeRequest.startTime + currentTimeRequest.duration + settings.get().streaming.stallThreshold,
-                end: endOfBuffer
-            };
-            const nextReq = fragmentModel.getRequests({
+        return null;
+    }
+
+    function _getRangeAheadForPruning(targetTime, ranges) {
+        // if we do a seek behind the current play position we do need to prune ahead of the new play position
+        const endOfBuffer = ranges.end(ranges.length - 1) + BUFFER_END_THRESHOLD;
+        const bufferToKeepAhead = settings.get().streaming.buffer.bufferTimeAtTopQuality;
+        const aheadDiff = endOfBuffer - targetTime;
+
+        if (aheadDiff > bufferToKeepAhead) {
+
+            let rangeStart = targetTime + bufferToKeepAhead;
+            // Ensure we keep full range of current fragment
+            const currentTimeRequest = fragmentModel.getRequests({
                 state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
-                time: currentTimeRequest.startTime + currentTimeRequest.duration + settings.get().streaming.stallThreshold,
+                time: targetTime,
                 threshold: BUFFER_RANGE_CALCULATION_THRESHOLD
             })[0];
-            if (nextReq && nextReq.startTime !== currentTimeRequest.startTime) {
-                aheadRange.start = nextReq.startTime + nextReq.duration + settings.get().streaming.stallThreshold;
+
+            if (currentTimeRequest) {
+                rangeStart = Math.max(currentTimeRequest.startTime + currentTimeRequest.duration, rangeStart);
             }
-            if (aheadRange.start < aheadRange.end && aheadRange.start < endOfBuffer) {
-                clearRanges.push(aheadRange);
+            if (rangeStart < endOfBuffer) {
+                return {
+                    start: rangeStart,
+                    end: endOfBuffer
+                };
             }
         }
 
-        return clearRanges;
-    }
-
-    function getWorkingTime() {
-        return isNaN(seekTarget) ? playbackController.getTime() : seekTarget;
+        return null;
     }
 
-    function onPlaybackProgression() {
+    function _onPlaybackProgression() {
         if (!replacingBuffer || (type === Constants.FRAGMENTED_TEXT && textController.isTextEnabled())) {
-            updateBufferLevel();
+            _updateBufferLevel();
         }
     }
 
-    function onPlaybackStalled() {
+    function _onPlaybackStalled() {
         checkIfSufficientBuffer();
     }
 
-    function onPlaybackPlaying() {
-        seekTarget = NaN;
+    function _onPlaybackPlaying() {
         checkIfSufficientBuffer();
+        seekTarget = NaN;
     }
 
     function getRangeAt(time, tolerance) {
-        const ranges = buffer.getAllBufferRanges();
+        const ranges = sourceBufferSink.getAllBufferRanges();
         let start = 0;
         let end = 0;
         let firstStart = null;
@@ -548,8 +616,8 @@ function BufferController(config) {
             length;
 
         // Consider gap/discontinuity limit as tolerance
-        if (settings.get().streaming.jumpGaps) {
-            tolerance = settings.get().streaming.smallGapLimit;
+        if (settings.get().streaming.gaps.jumpGaps) {
+            tolerance = settings.get().streaming.gaps.smallGapLimit;
         }
 
         range = getRangeAt(time, tolerance);
@@ -563,20 +631,22 @@ function BufferController(config) {
         return length;
     }
 
-    function updateBufferLevel() {
+    function _updateBufferLevel() {
         if (playbackController) {
-            bufferLevel = getBufferLength(getWorkingTime() || 0);
-            triggerEvent(Events.BUFFER_LEVEL_UPDATED, {bufferLevel: bufferLevel});
+            const tolerance = settings.get().streaming.gaps.jumpGaps && !isNaN(settings.get().streaming.gaps.smallGapLimit) ? settings.get().streaming.gaps.smallGapLimit : NaN;
+            bufferLevel = getBufferLength(playbackController.getTime() || 0, tolerance);
+            triggerEvent(Events.BUFFER_LEVEL_UPDATED, { mediaType: type, bufferLevel: bufferLevel });
             checkIfSufficientBuffer();
         }
     }
 
-    function checkIfBufferingCompleted() {
-        const isLastIdxAppended = maxAppendedIndex >= lastIndex - 1; // Handles 0 and non 0 based request index
-        if (isLastIdxAppended && !isBufferingCompleted && buffer.discharge === undefined) {
-            isBufferingCompleted = true;
-            logger.debug('checkIfBufferingCompleted trigger BUFFERING_COMPLETED for ' + type);
-            triggerEvent(Events.BUFFERING_COMPLETED);
+    function _checkIfBufferingCompleted() {
+        const isLastIdxAppended = maxAppendedIndex >= maximumIndex - 1; // Handles 0 and non 0 based request index
+        const periodBuffered = playbackController.getTimeToStreamEnd(streamInfo) - bufferLevel <= 0;
+
+        if ((isLastIdxAppended || periodBuffered) && !isBufferingCompleted) {
+            setIsBufferingCompleted(true);
+            logger.debug(`checkIfBufferingCompleted trigger BUFFERING_COMPLETED for stream id ${streamInfo.id} and type ${type}`);
         }
     }
 
@@ -584,17 +654,10 @@ function BufferController(config) {
         // No need to check buffer if type is not audio or video (for example if several errors occur during text parsing, so that the buffer cannot be filled, no error must occur on video playback)
         if (type !== Constants.AUDIO && type !== Constants.VIDEO) return;
 
-        if (seekClearedBufferingCompleted && !isBufferingCompleted && bufferLevel > 0 && playbackController && playbackController.getTimeToStreamEnd() - bufferLevel < BUFFERING_COMPLETED_THRESHOLD) {
-            seekClearedBufferingCompleted = false;
-            isBufferingCompleted = true;
-            logger.debug('checkIfSufficientBuffer trigger BUFFERING_COMPLETED for type ' + type);
-            triggerEvent(Events.BUFFERING_COMPLETED);
-        }
-
-        // When the player is working in low latency mode, the buffer is often below settings.get().streaming.stallThreshold.
+        // When the player is working in low latency mode, the buffer is often below STALL_THRESHOLD.
         // So, when in low latency mode, change dash.js behavior so it notifies a stall just when
         // buffer reach 0 seconds
-        if (((!settings.get().streaming.lowLatencyEnabled && bufferLevel < settings.get().streaming.stallThreshold) || bufferLevel === 0) && !isBufferingCompleted) {
+        if (((!settings.get().streaming.lowLatencyEnabled && bufferLevel < settings.get().streaming.buffer.stallThreshold) || bufferLevel === 0) && !isBufferingCompleted) {
             notifyBufferStateChanged(MetricsConstants.BUFFER_EMPTY);
         } else {
             if (isBufferingCompleted || bufferLevel >= streamInfo.manifestInfo.minBufferTime) {
@@ -612,14 +675,14 @@ function BufferController(config) {
 
         bufferState = state;
 
-        triggerEvent(Events.BUFFER_LEVEL_STATE_CHANGED, {state: state});
+        triggerEvent(Events.BUFFER_LEVEL_STATE_CHANGED, { state: state });
         triggerEvent(state === MetricsConstants.BUFFER_LOADED ? Events.BUFFER_LOADED : Events.BUFFER_EMPTY);
         logger.debug(state === MetricsConstants.BUFFER_LOADED ? 'Got enough buffer to start' : 'Waiting for more buffer before starting playback');
     }
 
     /* prune buffer on our own in background to avoid browsers pruning buffer silently */
     function pruneBuffer() {
-        if (!buffer || type === Constants.FRAGMENTED_TEXT) {
+        if (!sourceBufferSink || type === Constants.FRAGMENTED_TEXT) {
             return;
         }
 
@@ -630,13 +693,13 @@ function BufferController(config) {
 
     function getClearRanges() {
         const clearRanges = [];
-        const ranges = buffer.getAllBufferRanges();
+        const ranges = sourceBufferSink.getAllBufferRanges();
         if (!ranges || ranges.length === 0) {
             return clearRanges;
         }
 
         const currentTime = playbackController.getTime();
-        let startRangeToKeep = Math.max(0, currentTime - settings.get().streaming.bufferToKeep);
+        let startRangeToKeep = Math.max(0, currentTime - settings.get().streaming.buffer.bufferToKeep);
 
         const currentTimeRequest = fragmentModel.getRequests({
             state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
@@ -669,75 +732,104 @@ function BufferController(config) {
     }
 
     function clearBuffers(ranges) {
-        if (!ranges || !buffer || ranges.length === 0) return;
+        return new Promise((resolve, reject) => {
+            if (!ranges || !sourceBufferSink || ranges.length === 0) {
+                resolve();
+                return;
+            }
 
-        pendingPruningRanges.push.apply(pendingPruningRanges, ranges);
-        if (isPruningInProgress) {
-            return;
-        }
+            const promises = [];
+            ranges.forEach((range) => {
+                promises.push(_addClearRangeWithPromise(range));
+            });
+
+
+            if (!isPruningInProgress) {
+                clearNextRange();
+            }
 
-        clearNextRange();
+            Promise.all(promises)
+                .then(() => {
+                    resolve();
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
+    }
+
+    function _addClearRangeWithPromise(range) {
+        return new Promise((resolve, reject) => {
+            range.resolve = resolve;
+            range.reject = reject;
+            pendingPruningRanges.push(range);
+        });
     }
 
     function clearNextRange() {
-        // If there's nothing to prune reset state
-        if (pendingPruningRanges.length === 0 || !buffer) {
-            logger.debug('Nothing to prune, halt pruning');
-            pendingPruningRanges = [];
-            isPruningInProgress = false;
-            return;
-        }
+        try {
+            // If there's nothing to prune reset state
+            if (pendingPruningRanges.length === 0 || !sourceBufferSink) {
+                logger.debug('Nothing to prune, halt pruning');
+                pendingPruningRanges = [];
+                isPruningInProgress = false;
+                return;
+            }
 
-        const sourceBuffer = buffer.getBuffer();
-        // If there's nothing buffered any pruning is invalid, so reset our state
-        if (!sourceBuffer || !sourceBuffer.buffered || sourceBuffer.buffered.length === 0) {
-            logger.debug('SourceBuffer is empty (or does not exist), halt pruning');
-            pendingPruningRanges = [];
-            isPruningInProgress = false;
-            return;
-        }
+            const sourceBuffer = sourceBufferSink.getBuffer();
+            // If there's nothing buffered any pruning is invalid, so reset our state
+            if (!sourceBuffer || !sourceBuffer.buffered || sourceBuffer.buffered.length === 0) {
+                logger.debug('SourceBuffer is empty (or does not exist), halt pruning');
+                pendingPruningRanges = [];
+                isPruningInProgress = false;
+                return;
+            }
 
-        const range = pendingPruningRanges.shift();
-        logger.debug('Removing buffer from:', range.start, 'to', range.end);
-        isPruningInProgress = true;
+            const range = pendingPruningRanges.shift();
+            logger.debug(`${type}: Removing buffer from: ${range.start} to ${range.end}`);
+            isPruningInProgress = true;
 
-        // If removing buffer ahead current playback position, update maxAppendedIndex
-        const currentTime = playbackController.getTime();
-        if (currentTime < range.end) {
-            isBufferingCompleted = false;
-            maxAppendedIndex = 0;
-        }
+            // If removing buffer ahead current playback position, update maxAppendedIndex
+            const currentTime = playbackController.getTime();
+            if (currentTime < range.end) {
+                setIsBufferingCompleted(false);
+            }
 
-        buffer.remove(range.start, range.end, range.force);
+            sourceBufferSink.remove(range)
+                .then((e) => {
+                    _onRemoved(e);
+                })
+                .catch((e) => {
+                    _onRemoved(e);
+                });
+        } catch (e) {
+            isPruningInProgress = false;
+        }
     }
 
-    function onRemoved(e) {
-        if (buffer !== e.buffer) return;
-
+    function _onRemoved(e) {
         logger.debug('onRemoved buffer from:', e.from, 'to', e.to);
 
-        const ranges = buffer.getAllBufferRanges();
-        showBufferRanges(ranges);
+        const ranges = sourceBufferSink.getAllBufferRanges();
+        _showBufferRanges(ranges);
 
         if (pendingPruningRanges.length === 0) {
             isPruningInProgress = false;
+            _updateBufferLevel();
         }
 
         if (e.unintended) {
-            logger.warn('Detected unintended removal from:', e.from, 'to', e.to, 'setting index handler time to', e.from);
-            triggerEvent(Events.SEEK_TARGET, {time: e.from, mediaType: type, streamId: streamInfo.id});
+            logger.warn('Detected unintended removal from:', e.from, 'to', e.to, 'setting streamprocessor time to', e.from);
+            triggerEvent(Events.SEEK_TARGET, { time: e.from });
         }
 
         if (isPruningInProgress) {
             clearNextRange();
         } else {
             if (!replacingBuffer) {
-                updateBufferLevel();
+                _updateBufferLevel();
             } else {
                 replacingBuffer = false;
-                if (mediaChunk) {
-                    appendToBuffer(mediaChunk);
-                }
             }
             triggerEvent(Events.BUFFER_CLEARED, {
                 from: e.from,
@@ -750,98 +842,87 @@ function BufferController(config) {
     }
 
     function updateBufferTimestampOffset(representationInfo) {
-        if (!representationInfo || representationInfo.MSETimeOffset === undefined) return;
-        // Each track can have its own @presentationTimeOffset, so we should set the offset
-        // if it has changed after switching the quality or updating an mpd
-        if (buffer && buffer.updateTimestampOffset) {
-            buffer.updateTimestampOffset(representationInfo.MSETimeOffset);
-        }
+        return new Promise((resolve) => {
+            if (!representationInfo || representationInfo.MSETimeOffset === undefined || !sourceBufferSink || !sourceBufferSink.updateTimestampOffset) {
+                resolve();
+                return;
+            }
+            // Each track can have its own @presentationTimeOffset, so we should set the offset
+            // if it has changed after switching the quality or updating an mpd
+            sourceBufferSink.updateTimestampOffset(representationInfo.MSETimeOffset)
+                .then(() => {
+                    resolve();
+                })
+                .catch(() => {
+                    resolve();
+                });
+        });
+
     }
 
     function updateAppendWindow() {
-        if (buffer && !isBufferingCompleted) {
-            buffer.updateAppendWindow(streamInfo);
+        if (sourceBufferSink && !isBufferingCompleted) {
+            return sourceBufferSink.updateAppendWindow(streamInfo);
         }
+        return Promise.resolve();
     }
 
-    function onDataUpdateCompleted(e) {
-        if (e.error || isBufferingCompleted) return;
-        updateBufferTimestampOffset(e.currentRepresentation);
-    }
-
-    function onStreamCompleted(e) {
-        lastIndex = e.request.index;
-        checkIfBufferingCompleted();
-    }
-
-    function onCurrentTrackChanged(e) {
-        if (e.newMediaInfo.streamInfo.id !== streamInfo.id || e.newMediaInfo.type !== type) return;
-
-        const ranges = buffer && buffer.getAllBufferRanges();
-        if (!ranges) return;
-
-        logger.info('Track change asked');
-        if (mediaController.getSwitchMode(type) === Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE) {
-            if (ranges && ranges.length > 0 && playbackController.getTimeToStreamEnd() > settings.get().streaming.stallThreshold) {
-                isBufferingCompleted = false;
-                lastIndex = Number.POSITIVE_INFINITY;
-            }
+    function _onStreamRequestingCompleted(e) {
+        if (!isNaN(e.segmentIndex)) {
+            maximumIndex = e.segmentIndex;
+            _checkIfBufferingCompleted();
         }
     }
 
-    function onWallclockTimeUpdated() {
+    function _onWallclockTimeUpdated() {
         wallclockTicked++;
         const secondsElapsed = (wallclockTicked * (settings.get().streaming.wallclockTimeUpdateInterval / 1000));
-        if ((secondsElapsed >= settings.get().streaming.bufferPruningInterval)) {
+        if ((secondsElapsed >= settings.get().streaming.buffer.bufferPruningInterval)) {
             wallclockTicked = 0;
             pruneBuffer();
         }
     }
 
-    function onPlaybackRateChanged() {
+    function _onPlaybackRateChanged() {
         checkIfSufficientBuffer();
     }
 
     function getBuffer() {
-        return buffer;
-    }
-
-    function setBuffer(newBuffer) {
-        buffer = newBuffer;
+        return sourceBufferSink;
     }
 
     function getBufferLevel() {
         return bufferLevel;
     }
 
-    function setMediaSource(value, mediaInfo) {
-        mediaSource = value;
-        if (buffer && mediaInfo) { //if we have a prebuffer, we should prepare to discharge it, and make a new sourceBuffer ready
-            if (typeof buffer.discharge === 'function') {
-                dischargeBuffer = buffer;
-                createBuffer(mediaInfo);
-            }
-        }
-    }
-
     function getMediaSource() {
         return mediaSource;
     }
 
-    function replaceBuffer() {
-        replacingBuffer = true;
-    }
-
     function getIsBufferingCompleted() {
         return isBufferingCompleted;
     }
 
+    function setIsBufferingCompleted(value) {
+        if (isBufferingCompleted === value) {
+            return;
+        }
+
+        isBufferingCompleted = value;
+
+        if (isBufferingCompleted) {
+            triggerEvent(Events.BUFFERING_COMPLETED);
+        } else {
+            maximumIndex = Number.POSITIVE_INFINITY;
+        }
+    }
+
     function getIsPruningInProgress() {
         return isPruningInProgress;
     }
 
     function getTotalBufferedTime() {
-        const ranges = buffer.getAllBufferRanges();
+        const ranges = sourceBufferSink.getAllBufferRanges();
         let totalBufferedTime = 0;
         let ln,
             i;
@@ -855,11 +936,49 @@ function BufferController(config) {
         return totalBufferedTime;
     }
 
+    /**
+     * This function returns the maximum time for which the buffer is continuous starting from a target time.
+     * As soon as there is a gap we return the time before the gap starts
+     * @param {number} targetTime
+     */
+    function getContinuousBufferTimeForTargetTime(targetTime) {
+        try {
+            let adjustedTime = targetTime;
+            const ranges = sourceBufferSink.getAllBufferRanges();
+
+            if (!ranges || ranges.length === 0) {
+                return targetTime;
+            }
+
+            let i = 0;
+
+            while (adjustedTime === targetTime && i < ranges.length) {
+                const start = ranges.start(i);
+                const end = ranges.end(i);
+
+                if (adjustedTime >= start && adjustedTime <= end) {
+                    adjustedTime = end;
+                }
+
+                i += 1;
+            }
+
+            return adjustedTime;
+
+        } catch (e) {
+
+        }
+    }
+
     function hasEnoughSpaceToAppend() {
         const totalBufferedTime = getTotalBufferedTime();
         return (totalBufferedTime < criticalBufferLevel);
     }
 
+    function setSeekTarget(value) {
+        seekTarget = value;
+    }
+
     function triggerEvent(eventType, data) {
         let payload = data || {};
         eventBus.trigger(eventType, payload, { streamId: streamInfo.id, mediaType: type });
@@ -869,45 +988,45 @@ function BufferController(config) {
         criticalBufferLevel = Number.POSITIVE_INFINITY;
         bufferState = undefined;
         requiredQuality = AbrController.QUALITY_DEFAULT;
-        lastIndex = Number.POSITIVE_INFINITY;
+        maximumIndex = Number.POSITIVE_INFINITY;
         maxAppendedIndex = 0;
         appendedBytesInfo = null;
         isBufferingCompleted = false;
         isPruningInProgress = false;
         isQuotaExceeded = false;
-        seekClearedBufferingCompleted = false;
         bufferLevel = 0;
         wallclockTicked = 0;
         pendingPruningRanges = [];
         seekTarget = NaN;
 
-        if (buffer) {
-            if (!errored) {
-                buffer.abort();
+        if (sourceBufferSink) {
+            if (!errored && !keepBuffers) {
+                sourceBufferSink.abort()
+                    .then(() => {
+                        sourceBufferSink.reset(keepBuffers);
+                        sourceBufferSink = null;
+                    });
+            } else {
+                sourceBufferSink = null;
             }
-            buffer.reset(keepBuffers);
-            buffer = null;
         }
 
         replacingBuffer = false;
     }
 
     function reset(errored, keepBuffers) {
-        eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
-        eventBus.off(Events.INIT_FRAGMENT_LOADED, onInitFragmentLoaded, this);
-        eventBus.off(Events.MEDIA_FRAGMENT_LOADED, onMediaFragmentLoaded, this);
-        eventBus.off(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, this);
-        eventBus.off(Events.STREAM_COMPLETED, onStreamCompleted, this);
-        eventBus.off(Events.PLAYBACK_PLAYING, onPlaybackPlaying, this);
-        eventBus.off(Events.PLAYBACK_PROGRESS, onPlaybackProgression, this);
-        eventBus.off(Events.PLAYBACK_TIME_UPDATED, onPlaybackProgression, this);
-        eventBus.off(Events.PLAYBACK_RATE_CHANGED, onPlaybackRateChanged, this);
-        eventBus.off(Events.PLAYBACK_SEEKING, onPlaybackSeeking, this);
-        eventBus.off(Events.PLAYBACK_SEEKED, onPlaybackSeeked, this);
-        eventBus.off(Events.PLAYBACK_STALLED, onPlaybackStalled, this);
-        eventBus.off(Events.WALLCLOCK_TIME_UPDATED, onWallclockTimeUpdated, this);
-        eventBus.off(Events.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, this);
-        eventBus.off(Events.SOURCEBUFFER_REMOVE_COMPLETED, onRemoved, this);
+        eventBus.off(Events.INIT_FRAGMENT_LOADED, _onInitFragmentLoaded, this);
+        eventBus.off(Events.MEDIA_FRAGMENT_LOADED, _onMediaFragmentLoaded, this);
+        eventBus.off(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, this);
+        eventBus.off(Events.STREAM_REQUESTING_COMPLETED, _onStreamRequestingCompleted, this);
+
+        eventBus.off(MediaPlayerEvents.QUALITY_CHANGE_REQUESTED, _onQualityChanged, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_PLAYING, _onPlaybackPlaying, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_PROGRESS, _onPlaybackProgression, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_TIME_UPDATED, _onPlaybackProgression, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_RATE_CHANGED, _onPlaybackRateChanged, this);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_STALLED, _onPlaybackStalled, this);
+
 
         resetInitialSettings(errored, keepBuffers);
     }
@@ -917,21 +1036,27 @@ function BufferController(config) {
         getStreamId,
         getType,
         getBufferControllerType,
-        getRepresentationInfo,
-        createBuffer,
-        dischargePreBuffer,
+        createBufferSink,
         getBuffer,
-        setBuffer,
         getBufferLevel,
         getRangeAt,
         setMediaSource,
         getMediaSource,
-        appendInitSegment,
-        replaceBuffer,
+        appendInitSegmentFromCache,
         getIsBufferingCompleted,
+        setIsBufferingCompleted,
         getIsPruningInProgress,
         reset,
-        updateAppendWindow
+        prepareForPlaybackSeek,
+        prepareForReplacementTrackSwitch,
+        prepareForNonReplacementTrackSwitch,
+        updateAppendWindow,
+        getAllRangesWithSafetyFactor,
+        getContinuousBufferTimeForTargetTime,
+        clearBuffers,
+        pruneAllSafely,
+        updateBufferTimestampOffset,
+        setSeekTarget
     };
 
     setup();
diff --git a/src/streaming/controllers/FragmentController.js b/src/streaming/controllers/FragmentController.js
index e7baba01a5..7a4f9c45c6 100644
--- a/src/streaming/controllers/FragmentController.js
+++ b/src/streaming/controllers/FragmentController.js
@@ -35,11 +35,12 @@ import FragmentLoader from '../FragmentLoader';
 import RequestModifier from '../utils/RequestModifier';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
+import MediaPlayerEvents from '../MediaPlayerEvents';
 import Errors from '../../core/errors/Errors';
 import FactoryMaker from '../../core/FactoryMaker';
 import Debug from '../../core/Debug';
 
-function FragmentController( config ) {
+function FragmentController(config) {
 
     config = config || {};
     const context = this.context;
@@ -58,8 +59,8 @@ function FragmentController( config ) {
     function setup() {
         logger = debug.getLogger(instance);
         resetInitialSettings();
-        eventBus.on(Events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, instance);
-        eventBus.on(Events.FRAGMENT_LOADING_PROGRESS, onFragmentLoadingCompleted, instance);
+        eventBus.on(MediaPlayerEvents.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, instance);
+        eventBus.on(MediaPlayerEvents.FRAGMENT_LOADING_PROGRESS, onFragmentLoadingCompleted, instance);
     }
 
     function getStreamId() {
@@ -84,7 +85,8 @@ function FragmentController( config ) {
                     events: Events,
                     errors: Errors,
                     dashConstants: config.dashConstants,
-                    urlUtils: config.urlUtils
+                    urlUtils: config.urlUtils,
+                    streamId: getStreamId()
                 }),
                 debug: debug,
                 eventBus: eventBus,
@@ -105,8 +107,8 @@ function FragmentController( config ) {
     }
 
     function reset() {
-        eventBus.off(Events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, this);
-        eventBus.off(Events.FRAGMENT_LOADING_PROGRESS, onFragmentLoadingCompleted, this);
+        eventBus.off(MediaPlayerEvents.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, this);
+        eventBus.off(MediaPlayerEvents.FRAGMENT_LOADING_PROGRESS, onFragmentLoadingCompleted, this);
         resetInitialSettings();
     }
 
diff --git a/src/streaming/controllers/GapController.js b/src/streaming/controllers/GapController.js
index ee05f0fd4e..b616287b38 100644
--- a/src/streaming/controllers/GapController.js
+++ b/src/streaming/controllers/GapController.js
@@ -36,6 +36,7 @@ import EventBus from '../../core/EventBus';
 const GAP_HANDLER_INTERVAL = 100;
 const THRESHOLD_TO_STALLS = 30;
 const GAP_THRESHOLD = 0.1;
+const GAP_JUMP_WAITING_TIME_OFFSET = 0.1;
 
 function GapController() {
     const context = this.context;
@@ -53,6 +54,7 @@ function GapController() {
         timelineConverter,
         adapter,
         jumpTimeoutHandler,
+        trackSwitchByMediaType,
         logger;
 
     function initialize() {
@@ -76,6 +78,7 @@ function GapController() {
         lastGapJumpPosition = NaN;
         wallclockTicked = 0;
         jumpTimeoutHandler = null;
+        trackSwitchByMediaType = {};
     }
 
     function setConfig(config) {
@@ -104,20 +107,18 @@ function GapController() {
 
     function registerEvents() {
         eventBus.on(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, this);
+        eventBus.on(Events.INITIAL_STREAM_SWITCH, _onInitialStreamSwitch, this);
         eventBus.on(Events.PLAYBACK_SEEKING, _onPlaybackSeeking, this);
-        eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, onBytesAppended, instance);
+        eventBus.on(Events.TRACK_REPLACEMENT_STARTED, _onTrackReplacementStarted, instance);
+        eventBus.on(Events.TRACK_CHANGE_RENDERED, _onTrackChangeRendered, instance);
     }
 
     function unregisterEvents() {
         eventBus.off(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, this);
+        eventBus.off(Events.INITIAL_STREAM_SWITCH, _onInitialStreamSwitch, this);
         eventBus.off(Events.PLAYBACK_SEEKING, _onPlaybackSeeking, this);
-        eventBus.off(Events.BYTES_APPENDED_END_FRAGMENT, onBytesAppended, instance);
-    }
-
-    function onBytesAppended() {
-        if (!gapHandlerInterval) {
-            startGapHandler();
-        }
+        eventBus.off(Events.TRACK_REPLACEMENT_STARTED, _onTrackReplacementStarted, instance);
+        eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, _onTrackChangeRendered, instance);
     }
 
     function _onPlaybackSeeking() {
@@ -127,6 +128,40 @@ function GapController() {
         }
     }
 
+    /**
+     *  If the track was changed in the current active period and the player might aggressively replace segments the buffer will be empty for a short period of time. Avoid gap jumping at that time.
+     *  We wait until the next media fragment of the target type has been appended before activating again
+     * @param {object} e
+     * @private
+     */
+    function _onTrackReplacementStarted(e) {
+        try {
+            if (e.streamId !== streamController.getActiveStreamInfo().id || !e.mediaType) {
+                return;
+            }
+
+            if (e.streamId === streamController.getActiveStreamInfo().id) {
+                trackSwitchByMediaType[e.mediaType] = true;
+            }
+        } catch (e) {
+            logger.error(e);
+        }
+    }
+
+    function _onTrackChangeRendered(e) {
+        if (!e || !e.mediaType) {
+            return;
+        }
+
+        trackSwitchByMediaType[e.mediaType] = false;
+    }
+
+    function _onInitialStreamSwitch() {
+        if (!gapHandlerInterval) {
+            startGapHandler();
+        }
+    }
+
     function _onWallclockTimeUpdated(/*e*/) {
         if (!_shouldCheckForGaps()) {
             return;
@@ -146,9 +181,12 @@ function GapController() {
     }
 
     function _shouldCheckForGaps() {
-        return settings.get().streaming.jumpGaps && streamController.getActiveStreamProcessors().length > 0 &&
-            (!playbackController.isSeeking() || streamController.hasStreamFinishedBuffering(streamController.getActiveStream())) && !playbackController.isPaused() && !streamController.getIsStreamSwitchInProgress() &&
-            !streamController.getHasMediaOrIntialisationError();
+        const trackSwitchInProgress = Object.keys(trackSwitchByMediaType).some((key) => {
+            return trackSwitchByMediaType[key];
+        });
+
+        return !trackSwitchInProgress && settings.get().streaming.gaps.jumpGaps && streamController.getActiveStreamProcessors().length > 0 && !playbackController.isSeeking() && !playbackController.isPaused() && !streamController.getIsStreamSwitchInProgress() &&
+            !streamController.getHasMediaOrInitialisationError();
     }
 
     function getNextRangeIndex(ranges, currentTime) {
@@ -201,8 +239,8 @@ function GapController() {
     }
 
     function jumpGap(currentTime, playbackStalled = false) {
-        const smallGapLimit = settings.get().streaming.smallGapLimit;
-        const jumpLargeGaps = settings.get().streaming.jumpLargeGaps;
+        const smallGapLimit = settings.get().streaming.gaps.smallGapLimit;
+        const jumpLargeGaps = settings.get().streaming.gaps.jumpLargeGaps;
         const ranges = videoModel.getBufferRange();
         let nextRangeIndex;
         let seekToPosition = NaN;
@@ -231,23 +269,19 @@ function GapController() {
             const timeUntilGapEnd = seekToPosition - currentTime;
 
             if (jumpToStreamEnd) {
+                const nextStream = streamController.getStreamForTime(seekToPosition);
+                const internalSeek = nextStream && !!nextStream.getPreloaded();
+
                 logger.warn(`Jumping to end of stream because of gap from ${currentTime} to ${seekToPosition}. Gap duration: ${timeUntilGapEnd}`);
-                eventBus.trigger(Events.GAP_CAUSED_SEEK_TO_PERIOD_END, {
-                    seekTime: seekToPosition,
-                    duration: timeUntilGapEnd
-                });
+                playbackController.seek(seekToPosition, true, internalSeek);
             } else {
                 const isDynamic = playbackController.getIsDynamic();
                 const start = nextRangeIndex > 0 ? ranges.end(nextRangeIndex - 1) : currentTime;
-                const timeToWait = !isDynamic ? 0 : timeUntilGapEnd * 1000;
+                const timeToWait = !isDynamic ? 0 : Math.max(0, timeUntilGapEnd - GAP_JUMP_WAITING_TIME_OFFSET) * 1000;
 
                 jumpTimeoutHandler = window.setTimeout(() => {
                     playbackController.seek(seekToPosition, true, true);
-                    logger.warn(`Jumping gap starting at ${start} and ending at ${seekToPosition}. Jumping by: ${timeUntilGapEnd}`);
-                    eventBus.trigger(Events.GAP_CAUSED_INTERNAL_SEEK, {
-                        seekTime: seekToPosition,
-                        duration: timeUntilGapEnd
-                    });
+                    logger.warn(`Jumping gap occuring in period ${streamController.getActiveStream().getStreamId()} starting at ${start} and ending at ${seekToPosition}. Jumping by: ${timeUntilGapEnd}`);
                     jumpTimeoutHandler = null;
                 }, timeToWait);
             }
diff --git a/src/streaming/controllers/MediaController.js b/src/streaming/controllers/MediaController.js
index c8fe4d7a07..2ecafc4f49 100644
--- a/src/streaming/controllers/MediaController.js
+++ b/src/streaming/controllers/MediaController.js
@@ -44,20 +44,9 @@ function MediaController() {
         tracks,
         settings,
         initialSettings,
+        lastSelectedTracks,
         domStorage;
 
-    const validTrackSwitchModes = [
-        Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE,
-        Constants.TRACK_SWITCH_MODE_NEVER_REPLACE
-    ];
-
-    const validTrackSelectionModes = [
-        Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE,
-        Constants.TRACK_SELECTION_MODE_FIRST_TRACK,
-        Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY,
-        Constants.TRACK_SELECTION_MODE_WIDEST_RANGE
-    ];
-
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
         reset();
@@ -68,9 +57,9 @@ function MediaController() {
      * @param {StreamInfo} streamInfo
      * @memberof MediaController#
      */
-    function checkInitialMediaSettingsForType(type, streamInfo) {
-        let settings = getInitialSettings(type);
-        const tracksForType = getTracksFor(type, streamInfo);
+    function setInitialMediaSettingsForType(type, streamInfo) {
+        let settings = lastSelectedTracks[type] || getInitialSettings(type);
+        const tracksForType = getTracksFor(type, streamInfo.id);
         const tracks = [];
 
         if (!settings) {
@@ -82,17 +71,17 @@ function MediaController() {
 
         if (settings) {
             tracksForType.forEach(function (track) {
-                if (matchSettings(settings, track)) {
+                if (matchSettings(settings, track, !!lastSelectedTracks[type])) {
                     tracks.push(track);
                 }
             });
         }
 
         if (tracks.length === 0) {
-            setTrack(this.selectInitialTrack(type, tracksForType), true);
+            setTrack(selectInitialTrack(type, tracksForType), true);
         } else {
             if (tracks.length > 1) {
-                setTrack(this.selectInitialTrack(type, tracks));
+                setTrack(selectInitialTrack(type, tracks, !!lastSelectedTracks[type]));
             } else {
                 setTrack(tracks[0]);
             }
@@ -107,7 +96,7 @@ function MediaController() {
         if (!track) return;
 
         const mediaType = track.type;
-        if (!isMultiTrackSupportedByType(mediaType)) return;
+        if (!_isMultiTrackSupportedByType(mediaType)) return;
 
         let streamId = track.streamInfo.id;
         if (!tracks[streamId]) {
@@ -125,36 +114,34 @@ function MediaController() {
         mediaTracks.push(track);
 
         let initSettings = getInitialSettings(mediaType);
-        if (initSettings && (matchSettings(initSettings, track)) && !getCurrentTrackFor(mediaType, track.streamInfo)) {
+        if (initSettings && (matchSettings(initSettings, track)) && !getCurrentTrackFor(mediaType, track.streamInfo.id)) {
             setTrack(track);
         }
     }
 
     /**
      * @param {string} type
-     * @param {StreamInfo} streamInfo
+     * @param {string} streamId
      * @returns {Array}
      * @memberof MediaController#
      */
-    function getTracksFor(type, streamInfo) {
-        if (!type || !streamInfo) return [];
+    function getTracksFor(type, streamId) {
+        if (!type) return [];
 
-        const id = streamInfo.id;
-
-        if (!tracks[id] || !tracks[id][type]) return [];
+        if (!tracks[streamId] || !tracks[streamId][type]) return [];
 
-        return tracks[id][type].list;
+        return tracks[streamId][type].list;
     }
 
     /**
      * @param {string} type
-     * @param {StreamInfo} streamInfo
+     * @param {string} streamId
      * @returns {Object|null}
      * @memberof MediaController#
      */
-    function getCurrentTrackFor(type, streamInfo) {
-        if (!type || !streamInfo || (streamInfo && !tracks[streamInfo.id])) return null;
-        return tracks[streamInfo.id][type].current;
+    function getCurrentTrackFor(type, streamId) {
+        if (!type || !tracks[streamId]) return null;
+        return tracks[streamId][type].current;
     }
 
     /**
@@ -177,24 +164,24 @@ function MediaController() {
      * @param {boolean} noSettingsSave specify if settings must be not be saved
      * @memberof MediaController#
      */
-    function setTrack(track, noSettingsSave) {
+    function setTrack(track, noSettingsSave = false) {
         if (!track || !track.streamInfo) return;
 
         const type = track.type;
         const streamInfo = track.streamInfo;
         const id = streamInfo.id;
-        const current = getCurrentTrackFor(type, streamInfo);
+        const current = getCurrentTrackFor(type, id);
 
         if (!tracks[id] || !tracks[id][type] || isTracksEqual(track, current)) return;
 
         tracks[id][type].current = track;
 
-        if (tracks[id][type].current && !(noSettingsSave && type === Constants.FRAGMENTED_TEXT)) {
+        if (tracks[id][type].current) {
             eventBus.trigger(Events.CURRENT_TRACK_CHANGED, {
                 oldMediaInfo: current,
                 newMediaInfo: track,
-                switchMode: getSwitchMode(type)
-            });
+                switchMode: settings.get().streaming.trackSwitchMode[type]
+            }, { streamId: id });
         }
 
         if (!noSettingsSave) {
@@ -216,6 +203,7 @@ function MediaController() {
                 settings.audioChannelConfiguration = settings.audioChannelConfiguration[0];
             }
 
+            lastSelectedTracks[type] = settings;
             domStorage.setSavedMediaSettings(type, settings);
         }
     }
@@ -249,75 +237,12 @@ function MediaController() {
         domStorage.setSavedMediaSettings(Constants.FRAGMENTED_TEXT, null);
     }
 
-    /**
-     * @param {string} type
-     * @param {string} mode
-     * @memberof MediaController#
-     * @deprecated Please use updateSettings({streaming: { trackSwitchMode: mode } }) instead
-     */
-    function setSwitchMode(type, mode) {
-        logger.warn('deprecated: Please use updateSettings({streaming: { trackSwitchMode: mode } }) instead');
-        const isModeSupported = (validTrackSwitchModes.indexOf(mode) !== -1);
-
-        if (!isModeSupported) {
-            logger.warn('Track switch mode is not supported: ' + mode);
-            return;
-        }
-
-        let switchMode = {};
-        switchMode[type] = mode;
-
-        settings.update({
-            streaming: {
-                trackSwitchMode: switchMode
-            }
-        });
-    }
-
-    /**
-     * @param {string} type
-     * @returns {string} mode
-     * @memberof MediaController#
-     */
-    function getSwitchMode(type) {
-        return settings.get().streaming.trackSwitchMode[type];
-    }
-
-    /**
-     * @param {string} mode
-     * @memberof MediaController#
-     * @deprecated Please use updateSettings({streaming: { selectionModeForInitialTrack: mode } }) instead
-     */
-    function setSelectionModeForInitialTrack(mode) {
-        logger.warn('deprecated: Please use updateSettings({streaming: { selectionModeForInitialTrack: mode } }) instead');
-        const isModeSupported = (validTrackSelectionModes.indexOf(mode) !== -1);
-
-        if (!isModeSupported) {
-            logger.warn('Track selection mode is not supported: ' + mode);
-            return;
-        }
-
-        settings.update({
-            streaming: {
-                selectionModeForInitialTrack: mode
-            }
-        });
-    }
-
-    /**
-     * @returns {string} mode
-     * @memberof MediaController#
-     */
-    function getSelectionModeForInitialTrack() {
-        return settings.get().streaming.selectionModeForInitialTrack;
-    }
-
     /**
      * @param {string} type
      * @returns {boolean}
      * @memberof MediaController#
      */
-    function isMultiTrackSupportedByType(type) {
+    function _isMultiTrackSupportedByType(type) {
         return (type === Constants.AUDIO || type === Constants.VIDEO || type === Constants.TEXT ||
             type === Constants.FRAGMENTED_TEXT || type === Constants.IMAGE);
     }
@@ -340,11 +265,12 @@ function MediaController() {
         const sameId = t1.id === t2.id;
         const sameViewpoint = t1.viewpoint === t2.viewpoint;
         const sameLang = t1.lang === t2.lang;
+        const sameCodec = t1.codec === t2.codec;
         const sameRoles = t1.roles.toString() === t2.roles.toString();
         const sameAccessibility = t1.accessibility.toString() === t2.accessibility.toString();
         const sameAudioChannelConfiguration = t1.audioChannelConfiguration.toString() === t2.audioChannelConfiguration.toString();
 
-        return (sameId && sameViewpoint && sameLang && sameRoles && sameAccessibility && sameAudioChannelConfiguration);
+        return (sameId && sameCodec && sameViewpoint && sameLang && sameRoles && sameAccessibility && sameAudioChannelConfiguration);
     }
 
     function setConfig(config) {
@@ -364,6 +290,7 @@ function MediaController() {
      */
     function reset() {
         tracks = {};
+        lastSelectedTracks = {};
         resetInitialSettings();
     }
 
@@ -376,12 +303,12 @@ function MediaController() {
             audioChannelConfiguration: mediaInfo.audioChannelConfiguration
         };
         let notEmpty = settings.lang || settings.viewpoint || (settings.role && settings.role.length > 0) ||
-        (settings.accessibility && settings.accessibility.length > 0) || (settings.audioChannelConfiguration && settings.audioChannelConfiguration.length > 0);
+            (settings.accessibility && settings.accessibility.length > 0) || (settings.audioChannelConfiguration && settings.audioChannelConfiguration.length > 0);
 
         return notEmpty ? settings : null;
     }
 
-    function matchSettings(settings, track) {
+    function matchSettings(settings, track, isTrackActive = false) {
         const matchLang = !settings.lang || (track.lang.match(settings.lang));
         const matchIndex = (settings.index === undefined) || (settings.index === null) || (track.index === settings.index);
         const matchViewPoint = !settings.viewpoint || (settings.viewpoint === track.viewpoint);
@@ -395,7 +322,8 @@ function MediaController() {
             return item === settings.audioChannelConfiguration;
         })[0];
 
-        return (matchLang && matchIndex && matchViewPoint && matchRole && matchAccessibility && matchAudioChannelConfiguration);
+
+        return (matchLang && matchIndex && matchViewPoint && (matchRole || (track.type === Constants.AUDIO && isTrackActive)) && matchAccessibility && matchAudioChannelConfiguration);
     }
 
     function resetInitialSettings() {
@@ -406,13 +334,15 @@ function MediaController() {
         };
     }
 
-    function getTracksWithHighestBitrate (trackArr) {
+    function getTracksWithHighestBitrate(trackArr) {
         let max = 0;
         let result = [];
         let tmp;
 
         trackArr.forEach(function (track) {
-            tmp = Math.max.apply(Math, track.bitrateList.map(function (obj) { return obj.bandwidth; }));
+            tmp = Math.max.apply(Math, track.bitrateList.map(function (obj) {
+                return obj.bandwidth;
+            }));
 
             if (tmp > max) {
                 max = tmp;
@@ -425,7 +355,7 @@ function MediaController() {
         return result;
     }
 
-    function getTracksWithHighestEfficiency (trackArr) {
+    function getTracksWithHighestEfficiency(trackArr) {
         let min = Infinity;
         let result = [];
         let tmp;
@@ -449,7 +379,7 @@ function MediaController() {
         return result;
     }
 
-    function getTracksWithWidestRange (trackArr) {
+    function getTracksWithWidestRange(trackArr) {
         let max = 0;
         let result = [];
         let tmp;
@@ -471,7 +401,7 @@ function MediaController() {
     function selectInitialTrack(type, tracks) {
         if (type === Constants.FRAGMENTED_TEXT) return tracks[0];
 
-        let mode = getSelectionModeForInitialTrack();
+        let mode = settings.get().streaming.selectionModeForInitialTrack;
         let tmpArr = [];
 
         switch (mode) {
@@ -538,28 +468,23 @@ function MediaController() {
     }
 
     instance = {
-        checkInitialMediaSettingsForType: checkInitialMediaSettingsForType,
-        addTrack: addTrack,
-        getTracksFor: getTracksFor,
-        getCurrentTrackFor: getCurrentTrackFor,
-        isCurrentTrack: isCurrentTrack,
-        setTrack: setTrack,
-        setInitialSettings: setInitialSettings,
-        getInitialSettings: getInitialSettings,
-        setSwitchMode: setSwitchMode,
-        getSwitchMode: getSwitchMode,
-        selectInitialTrack: selectInitialTrack,
-        getTracksWithHighestBitrate: getTracksWithHighestBitrate,
-        getTracksWithHighestEfficiency: getTracksWithHighestEfficiency,
-        getTracksWithWidestRange: getTracksWithWidestRange,
-        setSelectionModeForInitialTrack: setSelectionModeForInitialTrack,
-        getSelectionModeForInitialTrack: getSelectionModeForInitialTrack,
-        isMultiTrackSupportedByType: isMultiTrackSupportedByType,
-        isTracksEqual: isTracksEqual,
-        matchSettings: matchSettings,
-        saveTextSettingsDisabled: saveTextSettingsDisabled,
-        setConfig: setConfig,
-        reset: reset
+        setInitialMediaSettingsForType,
+        addTrack,
+        getTracksFor,
+        getCurrentTrackFor,
+        isCurrentTrack,
+        setTrack,
+        selectInitialTrack,
+        setInitialSettings,
+        getInitialSettings,
+        getTracksWithHighestBitrate,
+        getTracksWithHighestEfficiency,
+        getTracksWithWidestRange,
+        isTracksEqual,
+        matchSettings,
+        saveTextSettingsDisabled,
+        setConfig,
+        reset
     };
 
     setup();
diff --git a/src/streaming/controllers/MediaSourceController.js b/src/streaming/controllers/MediaSourceController.js
index d86de0643f..0c6e40cf3f 100644
--- a/src/streaming/controllers/MediaSourceController.js
+++ b/src/streaming/controllers/MediaSourceController.js
@@ -34,6 +34,7 @@ import Debug from '../../core/Debug';
 function MediaSourceController() {
 
     let instance,
+        mediaSource,
         logger;
 
     const context = this.context;
@@ -48,17 +49,17 @@ function MediaSourceController() {
         let hasMediaSource = ('MediaSource' in window);
 
         if (hasMediaSource) {
-            return new MediaSource();
+            mediaSource = new MediaSource();
         } else if (hasWebKit) {
-            return new WebKitMediaSource();
+            mediaSource = new WebKitMediaSource();
         }
 
-        return null;
+        return mediaSource;
     }
 
-    function attachMediaSource(source, videoModel) {
+    function attachMediaSource(videoModel) {
 
-        let objectURL = window.URL.createObjectURL(source);
+        let objectURL = window.URL.createObjectURL(mediaSource);
 
         videoModel.setSource(objectURL);
 
@@ -69,24 +70,24 @@ function MediaSourceController() {
         videoModel.setSource(null);
     }
 
-    function setDuration(source, value) {
-        if (!source || source.readyState !== 'open') return;
+    function setDuration(value) {
+        if (!mediaSource || mediaSource.readyState !== 'open') return;
         if (value === null && isNaN(value)) return;
-        if (source.duration === value) return;
+        if (mediaSource.duration === value) return;
 
-        if (!isBufferUpdating(source)) {
+        if (!isBufferUpdating(mediaSource)) {
             logger.info('Set MediaSource duration:' + value);
-            source.duration = value;
+            mediaSource.duration = value;
         } else {
-            setTimeout(setDuration.bind(null, source, value), 50);
+            setTimeout(setDuration.bind(null, mediaSource, value), 50);
         }
     }
 
-    function setSeekable(source, start, end) {
-        if (source && typeof source.setLiveSeekableRange === 'function' && typeof source.clearLiveSeekableRange === 'function' &&
-                source.readyState === 'open' && start >= 0 && start < end) {
-            source.clearLiveSeekableRange();
-            source.setLiveSeekableRange(start, end);
+    function setSeekable(start, end) {
+        if (mediaSource && typeof mediaSource.setLiveSeekableRange === 'function' && typeof mediaSource.clearLiveSeekableRange === 'function' &&
+            mediaSource.readyState === 'open' && start >= 0 && start < end) {
+            mediaSource.clearLiveSeekableRange();
+            mediaSource.setLiveSeekableRange(start, end);
         }
     }
 
@@ -120,12 +121,12 @@ function MediaSourceController() {
     }
 
     instance = {
-        createMediaSource: createMediaSource,
-        attachMediaSource: attachMediaSource,
-        detachMediaSource: detachMediaSource,
-        setDuration: setDuration,
-        setSeekable: setSeekable,
-        signalEndOfStream: signalEndOfStream
+        createMediaSource,
+        attachMediaSource,
+        detachMediaSource,
+        setDuration,
+        setSeekable,
+        signalEndOfStream
     };
 
     setup();
diff --git a/src/streaming/controllers/PlaybackController.js b/src/streaming/controllers/PlaybackController.js
index 3a501056d0..7114d5e570 100644
--- a/src/streaming/controllers/PlaybackController.js
+++ b/src/streaming/controllers/PlaybackController.js
@@ -49,8 +49,6 @@ function PlaybackController() {
         adapter,
         videoModel,
         timelineConverter,
-        streamSwitch,
-        streamSeekTime,
         wallclockTimeIntervalId,
         liveDelay,
         streamInfo,
@@ -64,7 +62,6 @@ function PlaybackController() {
         isLowLatencySeekingInProgress,
         playbackStalled,
         minPlaybackRateChange,
-        uriFragmentModel,
         settings;
 
     function setup() {
@@ -73,23 +70,37 @@ function PlaybackController() {
         reset();
     }
 
-    function initialize(sInfo, periodSwitch, seekTime) {
+    /**
+     * Initializes the PlaybackController. This function is called whenever the stream is switched.
+     * @param {object} sInfo
+     * @param {boolean} periodSwitch
+     */
+    function initialize(sInfo, periodSwitch) {
         streamInfo = sInfo;
+
+        if (periodSwitch !== true) {
+            _initializeForFirstStream();
+        } else {
+            _initializeAfterStreamSwitch();
+        }
+    }
+
+    /**
+     * Initializes the PlaybackController when the first stream is to be played.
+     * @private
+     */
+    function _initializeForFirstStream() {
         addAllListeners();
         isDynamic = streamInfo.manifestInfo.isDynamic;
         isLowLatencySeekingInProgress = false;
         playbackStalled = false;
-        streamSwitch = periodSwitch === true;
-        streamSeekTime = seekTime;
         internalSeek = false;
 
-        const ua = typeof navigator !== 'undefined' ? navigator.userAgent.toLowerCase() : '';
-
         // Detect safari browser (special behavior for low latency streams)
+        const ua = typeof navigator !== 'undefined' ? navigator.userAgent.toLowerCase() : '';
         const isSafari = /safari/.test(ua) && !/chrome/.test(ua);
         minPlaybackRateChange = isSafari ? 0.25 : 0.02;
 
-        eventBus.on(Events.STREAM_INITIALIZED, onStreamInitialized, this);
         eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
         eventBus.on(Events.LOADING_PROGRESS, onFragmentLoadProgress, this);
         eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, this);
@@ -104,56 +115,21 @@ function PlaybackController() {
         }
     }
 
-    function onStreamInitialized(e) {
-        // Seamless period switch
-        if (streamSwitch && isNaN(streamSeekTime)) return;
-
-        // Seek new stream in priority order:
-        // - at seek time (streamSeekTime) when switching period
-        // - at start time provided in URI parameters
-        // - at stream/period start time (for static streams) or live start time (for dynamic streams)
-        let startTime = streamSeekTime;
-        if (isNaN(startTime)) {
-            if (isDynamic) {
-                // For dynamic stream, start by default at (live edge - live delay)
-                startTime = e.liveStartTime;
-                // If start time in URI, take min value between live edge time and time from URI (capped by DVR window range)
-                const dvrInfo = dashMetrics.getCurrentDVRInfo();
-                const dvrWindow = dvrInfo ? dvrInfo.range : null;
-                if (dvrWindow) {
-                    // #t shall be relative to period start
-                    const startTimeFromUri = getStartTimeFromUriParameters(true);
-                    if (!isNaN(startTimeFromUri)) {
-                        logger.info('Start time from URI parameters: ' + startTimeFromUri);
-                        startTime = Math.max(Math.min(startTime, startTimeFromUri), dvrWindow.start);
-                    }
-                }
-            } else {
-                // For static stream, start by default at period start
-                startTime = streamInfo.start;
-                // If start time in URI, take max value between period start and time from URI (if in period range)
-                const startTimeFromUri = getStartTimeFromUriParameters(false);
-                if (!isNaN(startTimeFromUri) && startTimeFromUri < (startTime + streamInfo.duration)) {
-                    logger.info('Start time from URI parameters: ' + startTimeFromUri);
-                    startTime = Math.max(startTime, startTimeFromUri);
-                }
-            }
-        }
+    /**
+     * Initializes the PlaybackController after the stream is switched. This will only happen with multiperiod MPDs.
+     * @private
+     */
+    function _initializeAfterStreamSwitch() {
 
-        if (!isNaN(startTime) && startTime !== videoModel.getTime()) {
-            // Trigger PLAYBACK_SEEKING event for controllers
-            eventBus.trigger(Events.PLAYBACK_SEEKING, { seekTime: startTime });
-            // Seek video model
-            seek(startTime, false, true);
-        }
     }
 
-    function getTimeToStreamEnd() {
-        return parseFloat((getStreamEndTime() - getTime()).toFixed(5));
+    function getTimeToStreamEnd(sInfo = null) {
+        return parseFloat((getStreamEndTime(sInfo) - getTime()).toFixed(5));
     }
 
-    function getStreamEndTime() {
-        return streamInfo.start + streamInfo.duration;
+    function getStreamEndTime(sInfo) {
+        const refInfo = sInfo ? sInfo : streamInfo;
+        return refInfo.start + refInfo.duration;
     }
 
     function play() {
@@ -257,13 +233,11 @@ function PlaybackController() {
 
         let suggestedPresentationDelay = adapter.getSuggestedPresentationDelay();
 
-        if (settings.get().streaming.lowLatencyEnabled) {
-            delay = 0;
-        } else if (mediaPlayerModel.getLiveDelay()) {
+        if (mediaPlayerModel.getLiveDelay()) {
             delay = mediaPlayerModel.getLiveDelay(); // If set by user, this value takes precedence
-        } else if (settings.get().streaming.liveDelayFragmentCount !== null && !isNaN(settings.get().streaming.liveDelayFragmentCount) && !isNaN(adjustedFragmentDuration)) {
-            delay = adjustedFragmentDuration * settings.get().streaming.liveDelayFragmentCount;
-        } else if (settings.get().streaming.useSuggestedPresentationDelay === true && suggestedPresentationDelay !== null && !isNaN(suggestedPresentationDelay) && suggestedPresentationDelay > 0) {
+        } else if (settings.get().streaming.delay.liveDelayFragmentCount !== null && !isNaN(settings.get().streaming.delay.liveDelayFragmentCount) && !isNaN(adjustedFragmentDuration)) {
+            delay = adjustedFragmentDuration * settings.get().streaming.delay.liveDelayFragmentCount;
+        } else if (settings.get().streaming.delay.useSuggestedPresentationDelay === true && suggestedPresentationDelay !== null && !isNaN(suggestedPresentationDelay) && suggestedPresentationDelay > 0) {
             delay = suggestedPresentationDelay;
         } else if (!isNaN(adjustedFragmentDuration)) {
             delay = adjustedFragmentDuration * FRAGMENT_DURATION_FACTOR;
@@ -290,16 +264,12 @@ function PlaybackController() {
         return ret;
     }
 
-    function getLiveDelay() {
-        return liveDelay;
+    function getAvailabilityStartTime() {
+        return availabilityStartTime;
     }
 
-    function setLiveDelay(value, useMaxValue = false) {
-        if (useMaxValue && value < liveDelay) {
-            return;
-        }
-
-        liveDelay = value;
+    function getLiveDelay() {
+        return liveDelay;
     }
 
     function getCurrentLiveLatency() {
@@ -316,14 +286,12 @@ function PlaybackController() {
     }
 
     function reset() {
+        pause();
         playOnceInitialized = false;
-        streamSwitch = false;
-        streamSeekTime = NaN;
         liveDelay = 0;
         availabilityStartTime = 0;
         seekTarget = NaN;
         if (videoModel) {
-            eventBus.off(Events.STREAM_INITIALIZED, onStreamInitialized, this);
             eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
             eventBus.off(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, this);
             eventBus.off(Events.LOADING_PROGRESS, onFragmentLoadProgress, this);
@@ -361,31 +329,11 @@ function PlaybackController() {
         if (config.timelineConverter) {
             timelineConverter = config.timelineConverter;
         }
-        if (config.uriFragmentModel) {
-            uriFragmentModel = config.uriFragmentModel;
-        }
         if (config.settings) {
             settings = config.settings;
         }
     }
 
-    function getStartTimeFromUriParameters(isDynamic) {
-        const fragData = uriFragmentModel.getURIFragmentData();
-        if (!fragData || !fragData.t) {
-            return NaN;
-        }
-        const refStream = streamController.getStreams()[0];
-        const refStreamStartTime = refStream.getStreamInfo().start;
-        // Consider only start time of MediaRange
-        // TODO: consider end time of MediaRange to stop playback at provided end time
-        fragData.t = fragData.t.split(',')[0];
-        // "t=<time>" : time is relative to 1st period start
-        // "t=posix:<time>" : time is absolute start time as number of seconds since 01-01-1970
-        const posix = fragData.t.indexOf('posix:') !== -1 ? fragData.t.substring(6) === 'now' ? Date.now() / 1000 : parseInt(fragData.t.substring(6)) : NaN;
-        let startTime = (isDynamic && !isNaN(posix)) ? posix - availabilityStartTime / 1000 : parseInt(fragData.t) + refStreamStartTime;
-        return startTime;
-    }
-
     function getActualPresentationTime(currentTime, mediatype) {
         const DVRMetrics = dashMetrics.getCurrentDVRInfo(mediatype);
         const DVRWindow = DVRMetrics ? DVRMetrics.range : null;
@@ -395,7 +343,6 @@ function PlaybackController() {
             return NaN;
         }
 
-        logger.debug(`Checking DVR window for at ${currentTime} with DVR window range ${DVRWindow.start} - ${DVRWindow.end}`);
         if (currentTime > DVRWindow.end) {
             actualTime = Math.max(DVRWindow.end - liveDelay, DVRWindow.start);
 
@@ -406,8 +353,7 @@ function PlaybackController() {
             // http://w3c.github.io/html/single-page.html#offsets-into-the-media-resource
             // Checking also duration of the DVR makes sense. We detected temporary situations in which currentTime
             // is bad reported by the browser which causes playback to jump to start (315360000 = 1 year)
-            //actualTime = DVRWindow.start;
-            actualTime = DVRWindow.start;
+            actualTime = Math.max(DVRWindow.end - liveDelay, DVRWindow.start);
         } else {
             actualTime = currentTime;
         }
@@ -430,8 +376,19 @@ function PlaybackController() {
         wallclockTimeIntervalId = null;
     }
 
-    function updateCurrentTime(mediaType) {
-        if (isPaused() || !isDynamic || videoModel.getReadyState() === 0) return;
+    /**
+     * Compare the current time of the video against the DVR window. If we are out of the DVR window we need to seek.
+     * @param {object} mediaType
+     */
+    function updateCurrentTime(mediaType = null) {
+        if (isPaused() || !isDynamic || videoModel.getReadyState() === 0 || isSeeking()) return;
+
+        // Note: In some cases we filter certain media types completely (for instance due to an unsupported video codec). This happens after the first entry to the DVR metric has been added.
+        // Now the DVR window for the filtered media type is not updated anymore. Consequently, always use a mediaType that is available to get a valid DVR window.
+        if (!mediaType) {
+            mediaType = streamController.hasVideoTrack() ? Constants.VIDEO : Constants.AUDIO;
+        }
+        // Compare the current time of the video element against the range defined in the DVR window.
         const currentTime = getNormalizedTime();
         const actualTime = getActualPresentationTime(currentTime, mediaType);
         const timeChanged = (!isNaN(actualTime) && actualTime !== currentTime);
@@ -442,21 +399,21 @@ function PlaybackController() {
     }
 
     function onDataUpdateCompleted(e) {
-        if (e.error) return;
-
         const representationInfo = adapter.convertDataToRepresentationInfo(e.currentRepresentation);
         const info = representationInfo ? representationInfo.mediaInfo.streamInfo : null;
 
         if (info === null || streamInfo.id !== info.id) return;
         streamInfo = info;
-
-        updateCurrentTime();
     }
 
     function onCanPlay() {
         eventBus.trigger(Events.CAN_PLAY);
     }
 
+    function onCanPlayThrough() {
+        eventBus.trigger(Events.CAN_PLAY_THROUGH);
+    }
+
     function onPlaybackStart() {
         logger.info('Native video element event: play');
         updateCurrentTime();
@@ -496,7 +453,10 @@ function PlaybackController() {
 
         logger.info('Seeking to: ' + seekTime);
         startUpdatingWallclockTime();
-        eventBus.trigger(Events.PLAYBACK_SEEKING, { seekTime: seekTime });
+        eventBus.trigger(Events.PLAYBACK_SEEKING, {
+            seekTime: seekTime,
+            streamId: streamInfo.id
+        });
     }
 
     function onPlaybackSeeked() {
@@ -508,7 +468,8 @@ function PlaybackController() {
         if (streamInfo) {
             eventBus.trigger(Events.PLAYBACK_TIME_UPDATED, {
                 timeToEnd: getTimeToStreamEnd(),
-                time: getTime()
+                time: getTime(),
+                streamId: streamInfo.id
             });
         }
     }
@@ -522,7 +483,7 @@ function PlaybackController() {
     }
 
     function onPlaybackProgress() {
-        eventBus.trigger(Events.PLAYBACK_PROGRESS);
+        eventBus.trigger(Events.PLAYBACK_PROGRESS, { streamId: streamInfo.id });
     }
 
     function onPlaybackRateChanged() {
@@ -537,6 +498,11 @@ function PlaybackController() {
         startUpdatingWallclockTime();
     }
 
+    function onPlaybackLoadedData() {
+        logger.info('Native video element event: loadeddata');
+        eventBus.trigger(Events.PLAYBACK_LOADED_DATA);
+    }
+
     // Event to handle the native video element ended event
     function onNativePlaybackEnded() {
         logger.info('Native video element event: ended');
@@ -572,9 +538,14 @@ function PlaybackController() {
 
         // Updates playback time for paused dynamic streams
         // (video element doesn't call timeupdate when the playback is paused)
-        if (getIsDynamic() && isPaused()) {
-            updateLivePlaybackTime();
+        if (getIsDynamic()) {
+            if (isPaused()) {
+                updateLivePlaybackTime();
+            } else {
+                updateCurrentTime();
+            }
         }
+
     }
 
     function onPlaybackProgression() {
@@ -876,10 +847,10 @@ function PlaybackController() {
     }
 
     function onStreamInitializing(e) {
-        applyServiceDescription(e.streamInfo, e.mediaInfo);
+        _applyServiceDescription(e.streamInfo, e.mediaInfo);
     }
 
-    function applyServiceDescription(streamInfo, mediaInfo) {
+    function _applyServiceDescription(streamInfo, mediaInfo) {
         if (streamInfo && streamInfo.manifestInfo && streamInfo.manifestInfo.serviceDescriptions) {
             // is there a service description for low latency defined?
             let llsd;
@@ -925,6 +896,7 @@ function PlaybackController() {
 
     function addAllListeners() {
         videoModel.addEventListener('canplay', onCanPlay);
+        videoModel.addEventListener('canplaythrough', onCanPlayThrough);
         videoModel.addEventListener('play', onPlaybackStart);
         videoModel.addEventListener('waiting', onPlaybackWaiting);
         videoModel.addEventListener('playing', onPlaybackPlaying);
@@ -936,12 +908,14 @@ function PlaybackController() {
         videoModel.addEventListener('progress', onPlaybackProgress);
         videoModel.addEventListener('ratechange', onPlaybackRateChanged);
         videoModel.addEventListener('loadedmetadata', onPlaybackMetaDataLoaded);
+        videoModel.addEventListener('loadeddata', onPlaybackLoadedData);
         videoModel.addEventListener('stalled', onPlaybackStalled);
         videoModel.addEventListener('ended', onNativePlaybackEnded);
     }
 
     function removeAllListeners() {
         videoModel.removeEventListener('canplay', onCanPlay);
+        videoModel.removeEventListener('canplaythrough', onCanPlayThrough);
         videoModel.removeEventListener('play', onPlaybackStart);
         videoModel.removeEventListener('waiting', onPlaybackWaiting);
         videoModel.removeEventListener('playing', onPlaybackPlaying);
@@ -953,34 +927,35 @@ function PlaybackController() {
         videoModel.removeEventListener('progress', onPlaybackProgress);
         videoModel.removeEventListener('ratechange', onPlaybackRateChanged);
         videoModel.removeEventListener('loadedmetadata', onPlaybackMetaDataLoaded);
+        videoModel.removeEventListener('loadeddata', onPlaybackLoadedData);
         videoModel.removeEventListener('stalled', onPlaybackStalled);
         videoModel.removeEventListener('ended', onNativePlaybackEnded);
     }
 
     instance = {
-        initialize: initialize,
-        setConfig: setConfig,
-        getStartTimeFromUriParameters: getStartTimeFromUriParameters,
-        getTimeToStreamEnd: getTimeToStreamEnd,
-        getTime: getTime,
-        getNormalizedTime: getNormalizedTime,
-        getPlaybackRate: getPlaybackRate,
-        getPlayedRanges: getPlayedRanges,
-        getEnded: getEnded,
-        getIsDynamic: getIsDynamic,
-        getStreamController: getStreamController,
-        computeAndSetLiveDelay: computeAndSetLiveDelay,
-        getLiveDelay: getLiveDelay,
-        setLiveDelay: setLiveDelay,
-        getCurrentLiveLatency: getCurrentLiveLatency,
-        play: play,
-        isPaused: isPaused,
-        pause: pause,
-        isSeeking: isSeeking,
+        initialize,
+        setConfig,
+        getTimeToStreamEnd,
+        getBufferLevel,
+        getTime,
+        getNormalizedTime,
+        getPlaybackRate,
+        getPlayedRanges,
+        getEnded,
+        getIsDynamic,
+        getStreamController,
+        computeAndSetLiveDelay,
+        getLiveDelay,
+        getCurrentLiveLatency,
+        play,
+        isPaused,
+        pause,
+        isSeeking,
         getStreamEndTime,
-        seek: seek,
-        updateCurrentTime: updateCurrentTime,
-        reset: reset
+        seek,
+        reset,
+        updateCurrentTime,
+        getAvailabilityStartTime
     };
 
     setup();
diff --git a/src/streaming/controllers/ScheduleController.js b/src/streaming/controllers/ScheduleController.js
index 229f556669..15dafb3841 100644
--- a/src/streaming/controllers/ScheduleController.js
+++ b/src/streaming/controllers/ScheduleController.js
@@ -29,7 +29,6 @@
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 import Constants from '../constants/Constants';
-import MetricsConstants from '../constants/MetricsConstants';
 import BufferLevelRule from '../rules/scheduling/BufferLevelRule';
 import FragmentModel from '../models/FragmentModel';
 import EventBus from '../../core/EventBus';
@@ -42,7 +41,6 @@ function ScheduleController(config) {
     config = config || {};
     const context = this.context;
     const eventBus = EventBus(context).getInstance();
-    const adapter = config.adapter;
     const dashMetrics = config.dashMetrics;
     const mediaPlayerModel = config.mediaPlayerModel;
     const fragmentModel = config.fragmentModel;
@@ -50,8 +48,6 @@ function ScheduleController(config) {
     const playbackController = config.playbackController;
     const textController = config.textController;
     const type = config.type;
-    const mimeType = config.mimeType;
-    const mediaController = config.mediaController;
     const bufferController = config.bufferController;
     const settings = config.settings;
 
@@ -59,23 +55,17 @@ function ScheduleController(config) {
         streamInfo,
         logger,
         currentRepresentationInfo,
-        initialRequest,
-        isStopped,
-        isFragmentProcessingInProgress,
         timeToLoadDelay,
         scheduleTimeout,
-        seekTarget,
         hasVideoTrack,
         bufferLevelRule,
         lastFragmentRequest,
         topQualityIndex,
-        lastInitializedRepresentationInfo,
-        replaceRequestArray,
+        lastInitializedQuality,
         switchTrack,
-        replacingBuffer,
+        initSegmentRequired,
         mediaRequest,
-        checkPlaybackQuality,
-        isReplacementRequest;
+        checkPlaybackQuality;
 
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
@@ -94,20 +84,12 @@ function ScheduleController(config) {
             settings: settings
         });
 
-        //eventBus.on(Events.LIVE_EDGE_SEARCH_COMPLETED, onLiveEdgeSearchCompleted, this);
-        eventBus.on(Events.DATA_UPDATE_STARTED, onDataUpdateStarted, this);
-        eventBus.on(Events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, this);
-        eventBus.on(Events.STREAM_COMPLETED, onStreamCompleted, this);
-        eventBus.on(Events.BUFFER_CLEARED, onBufferCleared, this);
-        eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, onBytesAppended, this);
-        eventBus.on(Events.QUOTA_EXCEEDED, onQuotaExceeded, this);
-        eventBus.on(Events.PLAYBACK_SEEKING, onPlaybackSeeking, this);
-        eventBus.on(Events.PLAYBACK_STARTED, onPlaybackStarted, this);
-        eventBus.on(Events.PLAYBACK_RATE_CHANGED, onPlaybackRateChanged, this);
-        eventBus.on(Events.PLAYBACK_TIME_UPDATED, onPlaybackTimeUpdated, this);
-        eventBus.on(Events.URL_RESOLUTION_FAILED, onURLResolutionFailed, this);
-        eventBus.on(Events.FRAGMENT_LOADING_ABANDONED, onFragmentLoadingAbandoned, this);
-        eventBus.on(Events.BUFFERING_COMPLETED, onBufferingCompleted, this);
+
+        eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, _onBytesAppended, instance);
+        eventBus.on(Events.PLAYBACK_STARTED, _onPlaybackStarted, instance);
+        eventBus.on(Events.PLAYBACK_RATE_CHANGED, _onPlaybackRateChanged, instance);
+        eventBus.on(Events.PLAYBACK_TIME_UPDATED, _onPlaybackTimeUpdated, instance);
+        eventBus.on(Events.URL_RESOLUTION_FAILED, _onURLResolutionFailed, instance);
     }
 
     function getType() {
@@ -122,216 +104,155 @@ function ScheduleController(config) {
         currentRepresentationInfo = representationInfo;
     }
 
-    function isStarted() {
-        return (isStopped === false);
-    }
-
-    function start() {
-        if (!streamInfo) return;
-        if (isStarted()) return;
-        if (!currentRepresentationInfo || bufferController.getIsBufferingCompleted()) return;
-
-        logger.debug('Schedule Controller starts');
-        isStopped = false;
-        dashMetrics.createPlaylistTraceMetrics(currentRepresentationInfo.id, playbackController.getTime() * 1000, playbackController.getPlaybackRate());
-
-        if (initialRequest) {
-            initialRequest = false;
-        }
+    function startScheduleTimer(value) {
+        if (bufferController.getIsBufferingCompleted()) return;
 
-        startScheduleTimer(0);
+        clearScheduleTimer();
+        const timeoutValue = !isNaN(value) ? value : 0;
+        scheduleTimeout = setTimeout(schedule, timeoutValue);
     }
 
-    function stop() {
-        if (isStopped) return;
-
-        logger.debug('Schedule Controller stops');
-        logger.debug(type + ' Schedule Controller stops');
-        isStopped = true;
-        clearTimeout(scheduleTimeout);
+    function clearScheduleTimer() {
+        if (scheduleTimeout) {
+            clearTimeout(scheduleTimeout);
+            scheduleTimeout = null;
+        }
     }
 
-    function hasTopQualityChanged(type, id) {
-        topQualityIndex[id] = topQualityIndex[id] || {};
-        const newTopQualityIndex = abrController.getTopQualityIndexFor(type, id);
+    function hasTopQualityChanged() {
+        const streamId = streamInfo.id;
+        const newTopQualityIndex = abrController.getTopQualityIndexFor(type, streamId);
 
-        if (topQualityIndex[id][type] != newTopQualityIndex) {
-            logger.info('Top quality ' + type + ' index has changed from ' + topQualityIndex[id][type] + ' to ' + newTopQualityIndex);
-            topQualityIndex[id][type] = newTopQualityIndex;
+        if (isNaN(topQualityIndex) || topQualityIndex != newTopQualityIndex) {
+            logger.info('Top quality ' + type + ' index has changed from ' + topQualityIndex + ' to ' + newTopQualityIndex);
+            topQualityIndex = newTopQualityIndex;
             return true;
         }
         return false;
 
     }
 
+    /**
+     * Schedule the request for an init or a media segment
+     */
     function schedule() {
-        if (!streamInfo) return;
-        if (isStopped || isFragmentProcessingInProgress ||
-            (playbackController.isPaused() && !settings.get().streaming.scheduleWhilePaused) ||
-            ((type === Constants.FRAGMENTED_TEXT || type === Constants.TEXT) && !textController.isTextEnabled()) ||
-            bufferController.getIsBufferingCompleted()) {
-            stop();
-            return;
-        }
+        try {
+            // Check if we are supposed to stop scheduling
+            if (_shouldClearScheduleTimer()) {
+                clearScheduleTimer();
+                return;
+            }
 
-        validateExecutedFragmentRequest();
-
-        const isReplacement = replaceRequestArray.length > 0;
-        const lastInitializedQuality = lastInitializedRepresentationInfo ? lastInitializedRepresentationInfo.quality : NaN;
-        if (replacingBuffer || isNaN(lastInitializedQuality) || switchTrack || isReplacement ||
-            hasTopQualityChanged(type, streamInfo.id) ||
-            bufferLevelRule.execute(type, currentRepresentationInfo, hasVideoTrack)) {
-            const getNextFragment = function () {
-                if ((currentRepresentationInfo.quality !== lastInitializedQuality || switchTrack) && (!replacingBuffer)) {
-                    if (switchTrack) {
-                        logger.debug('Switch track for ' + type + ', representation id = ' + currentRepresentationInfo.id);
-                        replacingBuffer = mediaController.getSwitchMode(type) === Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE;
-                        if (replacingBuffer && bufferController.replaceBuffer) {
-                            bufferController.replaceBuffer();
-                        }
-                        switchTrack = false;
-                    } else {
-                        logger.debug('Quality has changed, get init request for representationid = ' + currentRepresentationInfo.id);
-                    }
-                    eventBus.trigger(Events.INIT_FRAGMENT_NEEDED,
-                        { representationId: currentRepresentationInfo.id, sender: instance },
-                        { streamId: streamInfo.id, mediaType: type }
-                    );
-                    checkPlaybackQuality = false;
-                } else {
-                    const replacement = replaceRequestArray.shift();
-
-                    if (replacement && replacement.isInitializationRequest()) {
-                        // To be sure the specific init segment had not already been loaded
-                        eventBus.trigger(Events.INIT_FRAGMENT_NEEDED,
-                            { representationId: replacement.representationId, sender: instance },
-                            { streamId: streamInfo.id, mediaType: type }
-                        );
-                        checkPlaybackQuality = false;
-                    } else {
-                        eventBus.trigger(Events.MEDIA_FRAGMENT_NEEDED,
-                            { seekTarget: seekTarget, replacement: replacement },
-                            { streamId: streamInfo.id, mediaType: type }
-                        );
-                        checkPlaybackQuality = true;
-                    }
+            if (_shouldScheduleNextRequest()) {
+                if (checkPlaybackQuality) {
+                    // in case the playback quality is supposed to be changed, the corresponding StreamProcessor will update the currentRepresentation
+                    abrController.checkPlaybackQuality(type, streamInfo.id);
                 }
-            };
+                _getNextFragment();
 
-            setFragmentProcessState(true);
-            if (!isReplacement && checkPlaybackQuality) {
-                abrController.checkPlaybackQuality(type);
+            } else {
+                startScheduleTimer(settings.get().streaming.lowLatencyEnabled ? settings.get().streaming.scheduling.lowLatencyTimeout : settings.get().streaming.scheduling.defaultTimeout);
             }
-
-            getNextFragment();
-
-        } else {
-            startScheduleTimer(500);
+        } catch (e) {
+            startScheduleTimer(settings.get().streaming.lowLatencyEnabled ? settings.get().streaming.scheduling.lowLatencyTimeout : settings.get().streaming.scheduling.defaultTimeout);
         }
     }
 
-    function validateExecutedFragmentRequest() {
-        if (!isNaN(seekTarget)) return;
-        if (!lastInitializedRepresentationInfo) return;
-        // Validate that the fragment request executed and appended into the source buffer is as
-        // good of quality as the current quality and is the correct media track.
-        const time = playbackController.getTime();
-        let safeBufferLevel = 1.5;
-
-        if (isNaN(lastInitializedRepresentationInfo.fragmentDuration)) { //fragmentDuration of representationInfo is not defined,
-            // call metrics function to have data in the latest scheduling info...
-            // if no metric, returns 0. In this case, rule will return false.
-            const schedulingInfo = dashMetrics.getCurrentSchedulingInfo(currentRepresentationInfo.mediaInfo.type);
-            safeBufferLevel = schedulingInfo ? schedulingInfo.duration * 1.5 : 1.5;
-        }
-        const request = fragmentModel.getRequests({
-            state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
-            time: time + safeBufferLevel,
-            threshold: 0
-        })[0];
-
-        if (request && replaceRequestArray.indexOf(request) === -1 && !adapter.getIsTextTrack(mimeType)) {
-            const fastSwitchModeEnabled = settings.get().streaming.fastSwitchEnabled;
-            const bufferLevel = bufferController.getBufferLevel();
-            const abandonmentState = abrController.getAbandonmentStateFor(type);
-
-            // Only replace on track switch when NEVER_REPLACE
-            const trackChanged = !mediaController.isCurrentTrack(request.mediaInfo) && mediaController.getSwitchMode(request.mediaInfo.type) === Constants.TRACK_SWITCH_MODE_NEVER_REPLACE;
-            const qualityChanged = request.quality < lastInitializedRepresentationInfo.quality;
-
-            if (fastSwitchModeEnabled && (trackChanged || qualityChanged) && bufferLevel >= safeBufferLevel && abandonmentState !== MetricsConstants.ABANDON_LOAD) {
-                replaceRequest(request);
-                isReplacementRequest = true;
-                logger.debug('Reloading outdated fragment at index: ', request.index);
-            } else if (request.quality > lastInitializedRepresentationInfo.quality && !replacingBuffer) {
-                // The buffer has better quality it in then what we would request so set append point to end of buffer!!
-                setSeekTarget(playbackController.getTime() + bufferLevel);
+    /**
+     * Triggers the events to start requesting an init or a media segment. This will be picked up by the corresponding StreamProcessor.
+     * @private
+     */
+    function _getNextFragment() {
+        // A quality changed occured or we are switching the AdaptationSet. In that case we need to load a new init segment
+        if (initSegmentRequired || currentRepresentationInfo.quality !== lastInitializedQuality || switchTrack) {
+            if (switchTrack) {
+                logger.debug('Switch track for ' + type + ', representation id = ' + currentRepresentationInfo.id);
+                switchTrack = false;
+            } else {
+                logger.debug('Quality has changed, get init request for representationid = ' + currentRepresentationInfo.id);
             }
+            eventBus.trigger(Events.INIT_FRAGMENT_NEEDED,
+                { representationId: currentRepresentationInfo.id, sender: instance },
+                { streamId: streamInfo.id, mediaType: type }
+            );
+            checkPlaybackQuality = false;
+            initSegmentRequired = false;
         }
-    }
 
-    function startScheduleTimer(value) {
-        clearTimeout(scheduleTimeout);
+        // Request a media segment instead
+        else {
+            logger.debug(`Media segment needed for ${type} and stream id ${streamInfo.id}`);
+            eventBus.trigger(Events.MEDIA_FRAGMENT_NEEDED,
+                {},
+                { streamId: streamInfo.id, mediaType: type }
+            );
+            checkPlaybackQuality = true;
+        }
 
-        scheduleTimeout = setTimeout(schedule, value);
     }
 
-    function setFragmentProcessState (state) {
-        if (isFragmentProcessingInProgress !== state ) {
-            isFragmentProcessingInProgress = state;
-        } else {
-            logger.debug('isFragmentProcessingInProgress is already equal to', state);
+    /**
+     * Check if we need to stop scheduling for now.
+     * @return {boolean}
+     * @private
+     */
+    function _shouldClearScheduleTimer() {
+        try {
+            return (((type === Constants.FRAGMENTED_TEXT || type === Constants.TEXT) && !textController.isTextEnabled()));
+        } catch (e) {
+            return false;
         }
     }
 
-    function processInitRequest(request) {
-        if (request) {
-            setFragmentProcessState(true);
-            fragmentModel.executeRequest(request);
+    /**
+     * Check if we can start scheduling the next request
+     * @return {boolean}
+     * @private
+     */
+    function _shouldScheduleNextRequest() {
+        try {
+            return currentRepresentationInfo && (isNaN(lastInitializedQuality) || switchTrack || hasTopQualityChanged() || bufferLevelRule.execute(type, currentRepresentationInfo, hasVideoTrack));
+        } catch (e) {
+            return false;
         }
     }
 
-    function processMediaRequest(request) {
-        if (request) {
-            logger.debug('Next fragment request url is ' + request.url);
-            fragmentModel.executeRequest(request);
-        } else { // Use case - Playing at the bleeding live edge and frag is not available yet. Cycle back around.
-            if (playbackController.getIsDynamic()) {
-                logger.debug('Next fragment seems to be at the bleeding live edge and is not available yet. Rescheduling.');
-            }
-            setFragmentProcessState(false);
-            startScheduleTimer(settings.get().streaming.lowLatencyEnabled ? 100 : 500);
-        }
+    function setSwitchTrack(value) {
+        switchTrack = value;
     }
 
-    function switchTrackAsked() {
-        switchTrack = true;
+    function getSwitchStrack() {
+        return switchTrack;
     }
 
-    function replaceRequest(request) {
-        replaceRequestArray.push(request);
+    function _onPlaybackTimeUpdated() {
+        _completeQualityChange(true);
     }
 
-    function completeQualityChange(trigger) {
+    function _completeQualityChange(trigger) {
         if (playbackController && fragmentModel) {
             const item = fragmentModel.getRequests({
                 state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
                 time: playbackController.getTime(),
                 threshold: 0
             })[0];
+
             if (item && playbackController.getTime() >= item.startTime) {
                 if ((!lastFragmentRequest.mediaInfo || (item.mediaInfo.type === lastFragmentRequest.mediaInfo.type && item.mediaInfo.id !== lastFragmentRequest.mediaInfo.id)) && trigger) {
                     eventBus.trigger(Events.TRACK_CHANGE_RENDERED, {
                         mediaType: type,
                         oldMediaInfo: lastFragmentRequest.mediaInfo,
-                        newMediaInfo: item.mediaInfo
+                        newMediaInfo: item.mediaInfo,
+                        streamId: streamInfo.id
                     });
                 }
                 if ((item.quality !== lastFragmentRequest.quality || item.adaptationIndex !== lastFragmentRequest.adaptationIndex) && trigger) {
+                    logger.debug(`Quality change rendered for streamId ${streamInfo.id} and type ${type}`);
                     eventBus.trigger(Events.QUALITY_CHANGE_RENDERED, {
                         mediaType: type,
                         oldQuality: lastFragmentRequest.quality,
-                        newQuality: item.quality
+                        newQuality: item.quality,
+                        streamId: streamInfo.id
                     });
                 }
                 lastFragmentRequest = {
@@ -343,142 +264,31 @@ function ScheduleController(config) {
         }
     }
 
-    function onStreamCompleted() {
-        stop();
-        setFragmentProcessState(false);
-        logger.info(`Stream ${streamInfo.id} is complete`);
-    }
-
-    function onFragmentLoadingCompleted(e) {
-        if (e.request.mediaInfo.streamInfo.id !== streamInfo.id || e.request.mediaType !== type) return;
-
-        logger.info('OnFragmentLoadingCompleted - Url:', e.request ? e.request.url : 'undefined', e.request.range ? ', Range:' + e.request.range : '');
+    function _onBytesAppended(e) {
+        logger.debug(`Appended bytes for ${e.mediaType}`);
 
-        if (adapter.getIsTextTrack(mimeType)) {
-            setFragmentProcessState(false);
-        }
-
-        if (e.error && e.request.serviceLocation && !isStopped) {
-            replaceRequest(e.request);
-            setFragmentProcessState(false);
-            startScheduleTimer(0);
-        }
-
-        if (replacingBuffer) {
-            mediaRequest = e.request;
-        }
-    }
-
-    function onPlaybackTimeUpdated() {
-        completeQualityChange(true);
-    }
-
-    function onBytesAppended(e) {
-        if (replacingBuffer && !isNaN(e.startTime)) {
-            replacingBuffer = false;
-            fragmentModel.addExecutedRequest(mediaRequest);
-        }
-
-        setFragmentProcessState(false);
+        // we save the last initialized quality. That way we make sure that the media fragments we are about to append match the init segment
         if (isNaN(e.index)) {
-            lastInitializedRepresentationInfo = bufferController.getRepresentationInfo(e.quality);
+            lastInitializedQuality = e.quality;
             logger.info('[' + type + '] ' + 'lastInitializedRepresentationInfo changed to ' + e.quality);
         }
-        if (isReplacementRequest && !isNaN(e.startTime)) {
-            //replace requests process is in progress, call schedule in n seconds.
-            //it is done in order to not add a fragment at the new quality at the end of the buffer before replace process is over.
-            //Indeed, if schedule is called too early, the executed request tested is the same that the one tested during previous schedule (at the new quality).
-            const currentTime = playbackController.getTime();
-            const fragEndTime = e.startTime + currentRepresentationInfo.fragmentDuration;
-            const safeBufferLevel = currentRepresentationInfo.fragmentDuration * 1.5;
-            if ((currentTime + safeBufferLevel) >= fragEndTime) {
-                startScheduleTimer(0);
-            } else {
-                startScheduleTimer((fragEndTime - (currentTime + safeBufferLevel)) * 1000);
-            }
-            isReplacementRequest = false;
-        } else {
-            startScheduleTimer(0);
-        }
-    }
 
-    function onFragmentLoadingAbandoned(e) {
-        logger.info('onFragmentLoadingAbandoned request: ' + e.request.url + ' has been aborted');
-        if (!playbackController.isSeeking() && !switchTrack) {
-            logger.info('onFragmentLoadingAbandoned request: ' + e.request.url + ' has to be downloaded again, origin is not seeking process or switch track call');
-            replaceRequest(e.request);
-        }
-        setFragmentProcessState(false);
         startScheduleTimer(0);
     }
 
-    function onDataUpdateStarted(/*e*/) {
-        // stop();
-    }
-
-    function onBufferingCompleted(/*e*/) {
-        stop();
-    }
-
-    function onBufferCleared(e) {
-        if (replacingBuffer && settings.get().streaming.flushBufferAtTrackSwitch) {
-            // For some devices (like chromecast) it is necessary to seek the video element to reset the internal decoding buffer,
-            // otherwise audio track switch will be effective only once after previous buffered track is consumed
-            playbackController.seek(playbackController.getTime() + 0.001, false, true);
-        }
-
-        // (Re)start schedule once buffer has been pruned after a QuotaExceededError
-        if (e.hasEnoughSpaceToAppend && e.quotaExceeded) {
-            start();
-        }
-    }
-
-    function onQuotaExceeded(/*e*/) {
-        // Stop scheduler (will be restarted once buffer is pruned)
-        stop();
-        setFragmentProcessState(false);
-    }
-
-    function onURLResolutionFailed() {
+    function _onURLResolutionFailed() {
         fragmentModel.abortRequests();
-        stop();
-    }
-
-    function onPlaybackStarted() {
-        if (isStopped || !settings.get().streaming.scheduleWhilePaused) {
-            start();
-        }
+        clearScheduleTimer();
     }
 
-    function onPlaybackSeeking(e) {
-        if (!streamInfo) return;
-        setSeekTarget(e.seekTime);
-        setTimeToLoadDelay(0);
-
-        if (isStopped) {
-            start();
-        }
-
-        const latency = currentRepresentationInfo && currentRepresentationInfo.DVRWindow && playbackController ? currentRepresentationInfo.DVRWindow.end - playbackController.getTime() : NaN;
-        dashMetrics.updateManifestUpdateInfo({
-            latency: latency
-        });
-
-        if (!isFragmentProcessingInProgress) {
-            // No pending request, request next segment at seek target
-            startScheduleTimer(0);
-        } else {
-            // Abort current request
-            fragmentModel.abortRequests();
+    function _onPlaybackStarted() {
+        if (!settings.get().streaming.scheduling.scheduleWhilePaused) {
+            startScheduleTimer();
         }
     }
 
-    function onPlaybackRateChanged(e) {
-        dashMetrics.updatePlayListTraceMetrics({playbackspeed: e.playbackRate.toString()});
-    }
-
-    function setSeekTarget(value) {
-        seekTarget = value;
+    function _onPlaybackRateChanged(e) {
+        dashMetrics.updatePlayListTraceMetrics({ playbackspeed: e.playbackRate.toString() });
     }
 
     function setTimeToLoadDelay(value) {
@@ -493,45 +303,38 @@ function ScheduleController(config) {
         return bufferLevelRule.getBufferTarget(type, currentRepresentationInfo, hasVideoTrack);
     }
 
+    function setCheckPlaybackQuality(value) {
+        checkPlaybackQuality = value;
+    }
+
+    function setInitSegmentRequired(value) {
+        initSegmentRequired = value;
+    }
+
     function resetInitialSettings() {
         checkPlaybackQuality = true;
-        isFragmentProcessingInProgress = false;
         timeToLoadDelay = 0;
-        seekTarget = NaN;
-        initialRequest = true;
-        lastInitializedRepresentationInfo = undefined;
+        lastInitializedQuality = NaN;
         lastFragmentRequest = {
             mediaInfo: undefined,
             quality: NaN,
             adaptationIndex: NaN
         };
-        topQualityIndex = {};
-        replaceRequestArray = [];
-        isStopped = true;
+        topQualityIndex = NaN;
         switchTrack = false;
-        replacingBuffer = false;
         mediaRequest = null;
-        isReplacementRequest = false;
+        initSegmentRequired = false;
     }
 
     function reset() {
-        //eventBus.off(Events.LIVE_EDGE_SEARCH_COMPLETED, onLiveEdgeSearchCompleted, this);
-        eventBus.off(Events.DATA_UPDATE_STARTED, onDataUpdateStarted, this);
-        eventBus.off(Events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, this);
-        eventBus.off(Events.STREAM_COMPLETED, onStreamCompleted, this);
-        eventBus.off(Events.BUFFER_CLEARED, onBufferCleared, this);
-        eventBus.off(Events.BYTES_APPENDED_END_FRAGMENT, onBytesAppended, this);
-        eventBus.off(Events.QUOTA_EXCEEDED, onQuotaExceeded, this);
-        eventBus.off(Events.PLAYBACK_SEEKING, onPlaybackSeeking, this);
-        eventBus.off(Events.PLAYBACK_STARTED, onPlaybackStarted, this);
-        eventBus.off(Events.PLAYBACK_RATE_CHANGED, onPlaybackRateChanged, this);
-        eventBus.off(Events.PLAYBACK_TIME_UPDATED, onPlaybackTimeUpdated, this);
-        eventBus.off(Events.URL_RESOLUTION_FAILED, onURLResolutionFailed, this);
-        eventBus.off(Events.FRAGMENT_LOADING_ABANDONED, onFragmentLoadingAbandoned, this);
-        eventBus.off(Events.BUFFERING_COMPLETED, onBufferingCompleted, this);
-
-        stop();
-        completeQualityChange(false);
+        eventBus.off(Events.BYTES_APPENDED_END_FRAGMENT, _onBytesAppended, instance);
+        eventBus.off(Events.PLAYBACK_STARTED, _onPlaybackStarted, instance);
+        eventBus.off(Events.PLAYBACK_RATE_CHANGED, _onPlaybackRateChanged, instance);
+        eventBus.off(Events.PLAYBACK_TIME_UPDATED, _onPlaybackTimeUpdated, instance);
+        eventBus.off(Events.URL_RESOLUTION_FAILED, _onURLResolutionFailed, instance);
+
+        clearScheduleTimer();
+        _completeQualityChange(false);
         resetInitialSettings();
         streamInfo = null;
     }
@@ -541,22 +344,21 @@ function ScheduleController(config) {
     }
 
     instance = {
-        initialize: initialize,
-        getType: getType,
-        getStreamId: getStreamId,
-        setCurrentRepresentation: setCurrentRepresentation,
-        setSeekTarget: setSeekTarget,
-        setTimeToLoadDelay: setTimeToLoadDelay,
-        getTimeToLoadDelay: getTimeToLoadDelay,
-        switchTrackAsked: switchTrackAsked,
-        isStarted: isStarted,
-        start: start,
-        stop: stop,
-        reset: reset,
-        getBufferTarget: getBufferTarget,
-        processInitRequest: processInitRequest,
-        processMediaRequest: processMediaRequest,
-        getPlaybackController
+        initialize,
+        getType,
+        getStreamId,
+        setCurrentRepresentation,
+        setTimeToLoadDelay,
+        getTimeToLoadDelay,
+        setSwitchTrack,
+        getSwitchStrack,
+        startScheduleTimer,
+        clearScheduleTimer,
+        reset,
+        getBufferTarget,
+        getPlaybackController,
+        setCheckPlaybackQuality,
+        setInitSegmentRequired
     };
 
     setup();
diff --git a/src/streaming/controllers/StreamController.js b/src/streaming/controllers/StreamController.js
index 97dbd4f17e..7fc3e4c650 100644
--- a/src/streaming/controllers/StreamController.js
+++ b/src/streaming/controllers/StreamController.js
@@ -51,7 +51,7 @@ import EventController from './EventController';
 import ConformanceViolationConstants from '../constants/ConformanceViolationConstants';
 
 const PLAYBACK_ENDED_TIMER_INTERVAL = 200;
-const PREBUFFERING_CAN_START_INTERVAL = 500;
+const DVR_WAITING_OFFSET = 2;
 
 function StreamController() {
 
@@ -70,10 +70,11 @@ function StreamController() {
         mediaSourceController,
         timeSyncController,
         baseURLController,
+        segmentBaseController,
+        uriFragmentModel,
         abrController,
         mediaController,
         eventController,
-        textController,
         initCache,
         urlUtils,
         errHandler,
@@ -81,6 +82,7 @@ function StreamController() {
         streams,
         activeStream,
         protectionController,
+        textController,
         protectionData,
         autoPlay,
         isStreamSwitchingInProgress,
@@ -92,14 +94,15 @@ function StreamController() {
         mediaPlayerModel,
         isPaused,
         initialPlayback,
-        isPeriodSwitchInProgress,
         playbackEndedTimerInterval,
-        prebufferingCanStartInterval,
-        buffers,
+        bufferSinks,
         preloadingStreams,
         supportsChangeType,
         settings,
-        preBufferingCheckInProgress;
+        firstLicenseIsFetched,
+        preBufferingCheckInProgress,
+        dataForStreamSwitchAfterSeek,
+        waitForPlaybackStartTimeout;
 
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
@@ -143,250 +146,483 @@ function StreamController() {
             settings
         });
         timeSyncController.initialize();
+
+        if (protectionController) {
+            eventBus.trigger(Events.PROTECTION_CREATED, {
+                controller: protectionController
+            });
+            protectionController.setMediaElement(videoModel.getElement());
+            if (protectionData) {
+                protectionController.setProtectionData(protectionData);
+            }
+        }
+
         registerEvents();
     }
 
     function registerEvents() {
-        eventBus.on(Events.PLAYBACK_TIME_UPDATED, onPlaybackTimeUpdated, instance);
-        eventBus.on(Events.PLAYBACK_SEEKING, onPlaybackSeeking, instance);
-        eventBus.on(Events.GAP_CAUSED_SEEK_TO_PERIOD_END, onGapCausedPlaybackSeek, instance);
-        eventBus.on(Events.PLAYBACK_ERROR, onPlaybackError, instance);
-        eventBus.on(Events.PLAYBACK_STARTED, onPlaybackStarted, instance);
-        eventBus.on(Events.PLAYBACK_PAUSED, onPlaybackPaused, instance);
-        eventBus.on(Events.PLAYBACK_ENDED, onEnded, instance, { priority: EventBus.EVENT_PRIORITY_HIGH });
-        eventBus.on(Events.MANIFEST_UPDATED, onManifestUpdated, instance);
-        eventBus.on(Events.STREAM_BUFFERING_COMPLETED, onStreamBufferingCompleted, instance);
-        eventBus.on(Events.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
-        eventBus.on(Events.TIME_SYNCHRONIZATION_COMPLETED, onTimeSyncCompleted, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_TIME_UPDATED, _onPlaybackTimeUpdated, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_SEEKING, _onPlaybackSeeking, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_ERROR, onPlaybackError, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_STARTED, _onPlaybackStarted, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_PAUSED, _onPlaybackPaused, instance);
+        eventBus.on(MediaPlayerEvents.PLAYBACK_ENDED, _onPlaybackEnded, instance);
         eventBus.on(MediaPlayerEvents.METRIC_ADDED, onMetricAdded, instance);
+        eventBus.on(MediaPlayerEvents.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
+        eventBus.on(MediaPlayerEvents.BUFFER_LEVEL_UPDATED, _onBufferLevelUpdated, instance);
+
+        eventBus.on(Events.KEY_SESSION_UPDATED, _onKeySessionUpdated, instance);
+        eventBus.on(Events.MANIFEST_UPDATED, _onManifestUpdated, instance);
+        eventBus.on(Events.STREAM_BUFFERING_COMPLETED, _onStreamBufferingCompleted, instance);
+        eventBus.on(Events.TIME_SYNCHRONIZATION_COMPLETED, _onTimeSyncCompleted, instance);
+        eventBus.on(Events.KEY_SESSION_UPDATED, _onKeySessionUpdated, instance);
+        eventBus.on(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, instance);
+        eventBus.on(Events.CURRENT_TRACK_CHANGED, _onCurrentTrackChanged, instance);
     }
 
     function unRegisterEvents() {
-        eventBus.off(Events.PLAYBACK_TIME_UPDATED, onPlaybackTimeUpdated, instance);
-        eventBus.off(Events.PLAYBACK_SEEKING, onPlaybackSeeking, instance);
-        eventBus.off(Events.GAP_CAUSED_SEEK_TO_PERIOD_END, onGapCausedPlaybackSeek, instance);
-        eventBus.off(Events.PLAYBACK_ERROR, onPlaybackError, instance);
-        eventBus.off(Events.PLAYBACK_STARTED, onPlaybackStarted, instance);
-        eventBus.off(Events.PLAYBACK_PAUSED, onPlaybackPaused, instance);
-        eventBus.off(Events.PLAYBACK_ENDED, onEnded, instance);
-        eventBus.off(Events.MANIFEST_UPDATED, onManifestUpdated, instance);
-        eventBus.off(Events.STREAM_BUFFERING_COMPLETED, onStreamBufferingCompleted, instance);
-        eventBus.off(Events.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
-        eventBus.off(Events.TIME_SYNCHRONIZATION_COMPLETED, onTimeSyncCompleted, instance);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_TIME_UPDATED, _onPlaybackTimeUpdated, instance);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_SEEKING, _onPlaybackSeeking, instance);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_ERROR, onPlaybackError, instance);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_STARTED, _onPlaybackStarted, instance);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_PAUSED, _onPlaybackPaused, instance);
+        eventBus.off(MediaPlayerEvents.PLAYBACK_ENDED, _onPlaybackEnded, instance);
         eventBus.off(MediaPlayerEvents.METRIC_ADDED, onMetricAdded, instance);
+        eventBus.off(MediaPlayerEvents.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
+        eventBus.off(MediaPlayerEvents.BUFFER_LEVEL_UPDATED, _onBufferLevelUpdated, instance);
+
+        eventBus.off(Events.KEY_SESSION_UPDATED, _onKeySessionUpdated, instance);
+        eventBus.off(Events.MANIFEST_UPDATED, _onManifestUpdated, instance);
+        eventBus.off(Events.STREAM_BUFFERING_COMPLETED, _onStreamBufferingCompleted, instance);
+        eventBus.off(Events.TIME_SYNCHRONIZATION_COMPLETED, _onTimeSyncCompleted, instance);
+        eventBus.off(Events.KEY_SESSION_UPDATED, _onKeySessionUpdated, instance);
+        eventBus.off(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, instance);
+        eventBus.off(Events.CURRENT_TRACK_CHANGED, _onCurrentTrackChanged, instance);
     }
 
-    /*
-     * Called when current playback position is changed.
-     * Used to determine the time current stream is finished and we should switch to the next stream.
+    /**
+     * When the UTC snychronization is completed we can compose the streams
+     * @private
      */
-    function onPlaybackTimeUpdated(/*e*/) {
-        if (hasVideoTrack()) {
-            const playbackQuality = videoModel.getPlaybackQuality();
-            if (playbackQuality) {
-                dashMetrics.addDroppedFrames(playbackQuality);
-            }
-        }
+    function _onTimeSyncCompleted( /*e*/) {
+        _composeStreams();
     }
 
-    function onPlaybackSeeking(e) {
-        const seekingStream = getStreamForTime(e.seekTime);
+    /**
+     *
+     * @private
+     */
+    function _onKeySessionUpdated() {
+        firstLicenseIsFetched = true;
+    }
 
-        if (seekingStream === activeStream && preloadingStreams && preloadingStreams.length > 0) {
-            // Seeking to the current period was requested while preloading the next one, deactivate preloading one
-            preloadingStreams.forEach((s) => {
-                s.deactivate(true);
-            });
+    /**
+     * Setup the stream objects after the stream start and each MPD reload. This function is called after the UTC sync has been done (TIME_SYNCHRONIZATION_COMPLETED)
+     * @private
+     */
+    function _composeStreams() {
+        try {
+            const streamsInfo = adapter.getStreamsInfo();
+
+            if (!activeStream && streamsInfo.length === 0) {
+                throw new Error('There are no streams');
+            }
+
+            if (activeStream) {
+                dashMetrics.updateManifestUpdateInfo({
+                    currentTime: playbackController.getTime(),
+                    buffered: videoModel.getBufferRange(),
+                    presentationStartTime: streamsInfo[0].start,
+                    clientTimeOffset: timelineConverter.getClientTimeOffset()
+                });
+            }
+
+            // Filter streams that are outdated and not included in the MPD anymore
+            if (streams.length > 0) {
+                _filterOutdatedStreams(streamsInfo);
+            }
+
+            for (let i = 0, ln = streamsInfo.length; i < ln; i++) {
+                const streamInfo = streamsInfo[i];
+                _initializeOrUpdateStream(streamInfo);
+            }
+
+            if (!activeStream) {
+                _initializeForFirstStream(streamsInfo);
+            }
+
+            eventBus.trigger(Events.STREAMS_COMPOSED);
+
+        } catch (e) {
+            errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_NOSTREAMS_CODE, e.message + 'nostreamscomposed', manifestModel.getValue()));
+            hasInitialisationError = true;
+            reset();
         }
+    }
 
-        if (seekingStream && seekingStream !== activeStream) {
-            // If we're preloading other stream, the active one was deactivated and we need to switch back
-            flushPlaylistMetrics(PlayListTrace.END_OF_PERIOD_STOP_REASON);
-            switchStream(seekingStream, activeStream, e.seekTime);
+    /**
+     * Called for each stream when composition is performed. Either a new instance of Stream is created or the existing one is updated.
+     * @param {object} streamInfo
+     * @private
+     */
+    function _initializeOrUpdateStream(streamInfo) {
+        let stream = getStreamById(streamInfo.id);
+
+        // If the Stream object does not exist we probably loaded the manifest the first time or it was
+        // introduced in the updated manifest, so we need to create a new Stream and perform all the initialization operations
+        if (!stream) {
+            stream = Stream(context).create({
+                manifestModel,
+                mediaPlayerModel,
+                dashMetrics,
+                manifestUpdater,
+                adapter,
+                timelineConverter,
+                capabilities,
+                capabilitiesFilter,
+                errHandler,
+                baseURLController,
+                segmentBaseController,
+                textController,
+                abrController,
+                playbackController,
+                eventController,
+                mediaController,
+                protectionController,
+                videoModel,
+                streamInfo,
+                settings
+            });
+            streams.push(stream);
+            stream.initialize();
         } else {
-            flushPlaylistMetrics(PlayListTrace.USER_REQUEST_STOP_REASON);
+            stream.updateData(streamInfo);
         }
 
-        createPlaylistMetrics(PlayList.SEEK_START_REASON);
+        dashMetrics.addManifestUpdateStreamInfo(streamInfo);
     }
 
-    function onGapCausedPlaybackSeek(e) {
-        const nextStream = getNextStream();
-        flushPlaylistMetrics(PlayListTrace.END_OF_PERIOD_STOP_REASON);
-        switchStream(nextStream, activeStream, e.seekTime);
-        createPlaylistMetrics(PlayList.SEEK_START_REASON);
-    }
+    /**
+     * Initialize playback for the first period.
+     * @param {object} streamsInfo
+     * @private
+     */
+    function _initializeForFirstStream(streamsInfo) {
 
-    function onPlaybackStarted( /*e*/) {
-        logger.debug('[onPlaybackStarted]');
-        if (initialPlayback) {
-            initialPlayback = false;
-            createPlaylistMetrics(PlayList.INITIAL_PLAYOUT_START_REASON);
-        } else {
-            if (isPaused) {
-                isPaused = false;
-                createPlaylistMetrics(PlayList.RESUME_FROM_PAUSE_START_REASON);
+        // Add the DVR window so we can calculate the right starting point
+        _addDVRMetric();
+
+        // If the start is in the future we need to wait
+        const dvrRange = dashMetrics.getCurrentDVRInfo().range;
+        if (dvrRange.end < dvrRange.start) {
+            if (waitForPlaybackStartTimeout) {
+                clearTimeout(waitForPlaybackStartTimeout);
             }
+            const waitingTime = Math.min((((dvrRange.end - dvrRange.start) * -1) + DVR_WAITING_OFFSET) * 1000, 2147483647);
+            logger.debug(`Waiting for ${waitingTime} ms before playback can start`);
+            eventBus.trigger(Events.AST_IN_FUTURE, { delay: waitingTime });
+            waitForPlaybackStartTimeout = setTimeout(() => {
+                _initializeForFirstStream(streamsInfo);
+            }, waitingTime);
+            return;
         }
-    }
 
-    function onPlaybackPaused(e) {
-        logger.debug('[onPlaybackPaused]');
-        if (!e.ended) {
-            isPaused = true;
-            flushPlaylistMetrics(PlayListTrace.USER_REQUEST_STOP_REASON);
+        // Compute and set the live delay
+        if (adapter.getIsDynamic() && streams.length) {
+            const manifestInfo = streamsInfo[0].manifestInfo;
+            const fragmentDuration = _getFragmentDurationForLiveDelayCalculation(streamsInfo, manifestInfo);
+            playbackController.computeAndSetLiveDelay(fragmentDuration, manifestInfo.DVRWindowSize, manifestInfo.minBufferTime);
         }
+
+        // Figure out the correct start time and the correct start period
+        const startTime = _getInitialStartTime();
+        let initialStream = getStreamForTime(startTime);
+        const startStream = initialStream !== null ? initialStream : streams[0];
+
+        eventBus.trigger(Events.INITIAL_STREAM_SWITCH, { startTime });
+        _switchStream(startStream, null, startTime);
+        _startPlaybackEndedTimerInterval();
     }
 
-    function startPlaybackEndedTimerInterval() {
-        if (!playbackEndedTimerInterval) {
-            playbackEndedTimerInterval = setInterval(function () {
-                if (!isStreamSwitchingInProgress && playbackController.getTimeToStreamEnd() <= 0) {
-                    eventBus.trigger(Events.PLAYBACK_ENDED, { 'isLast': getActiveStreamInfo().isLast });
-                }
-            }, PLAYBACK_ENDED_TIMER_INTERVAL);
+    /**
+     * Switch from the current stream (period) to the next stream (period).
+     * @param {object} stream
+     * @param {object} previousStream
+     * @param {number} seekTime
+     * @private
+     */
+    function _switchStream(stream, previousStream, seekTime) {
+        try {
+            if (isStreamSwitchingInProgress || !stream || (previousStream === stream && stream.getIsActive())) {
+                return;
+            }
+
+            isStreamSwitchingInProgress = true;
+            eventBus.trigger(Events.STREAM_SWITCH_STARTED, {
+                fromStreamInfo: previousStream ? previousStream.getStreamInfo() : null,
+                toStreamInfo: stream.getStreamInfo()
+            });
+
+            let keepBuffers = false;
+            activeStream = stream;
+
+            if (previousStream) {
+                keepBuffers = _canSourceBuffersBeReused(stream, previousStream);
+                previousStream.deactivate(keepBuffers);
+            }
+
+            // Determine seek time when switching to new period
+            // - seek at given seek time
+            // - or seek at period start if upcoming period is not prebuffered
+            seekTime = !isNaN(seekTime) ? seekTime : (!keepBuffers && previousStream ? stream.getStreamInfo().start : NaN);
+            logger.info(`Switch to stream ${stream.getId()}. Seektime is ${seekTime}, current playback time is ${playbackController.getTime()}. Seamless period switch is set to ${keepBuffers}`);
+
+            preloadingStreams = preloadingStreams.filter((s) => {
+                return s.getId() !== activeStream.getId();
+            });
+            playbackController.initialize(getActiveStreamInfo(), !!previousStream);
+
+            if (videoModel.getElement()) {
+                _openMediaSource(seekTime, keepBuffers);
+            }
+        } catch (e) {
+            isStreamSwitchingInProgress = false;
         }
     }
 
-    function stopPlaybackEndedTimerInterval() {
-        if (playbackEndedTimerInterval) {
-            clearInterval(playbackEndedTimerInterval);
-            playbackEndedTimerInterval = null;
+    /**
+     * Setup the Media Source. Open MSE and attach event listeners
+     * @param {number} seekTime
+     * @param {boolean} keepBuffers
+     * @private
+     */
+    function _openMediaSource(seekTime, keepBuffers) {
+        let sourceUrl;
+
+        function _onMediaSourceOpen() {
+            // Manage situations in which a call to reset happens while MediaSource is being opened
+            if (!mediaSource || mediaSource.readyState !== 'open') return;
+
+            logger.debug('MediaSource is open!');
+            window.URL.revokeObjectURL(sourceUrl);
+            mediaSource.removeEventListener('sourceopen', _onMediaSourceOpen);
+            mediaSource.removeEventListener('webkitsourceopen', _onMediaSourceOpen);
+
+            _setMediaDuration();
+            const dvrInfo = dashMetrics.getCurrentDVRInfo();
+            mediaSourceController.setSeekable(dvrInfo.range.start, dvrInfo.range.end);
+            _activateStream(seekTime, keepBuffers);
         }
-    }
 
-    function startCheckIfPrebufferingCanStartInterval() {
-        if (!prebufferingCanStartInterval) {
-            prebufferingCanStartInterval = setInterval(function () {
-                checkIfPrebufferingCanStart();
-            }, PREBUFFERING_CAN_START_INTERVAL);
+        function _open() {
+            mediaSource.addEventListener('sourceopen', _onMediaSourceOpen, false);
+            mediaSource.addEventListener('webkitsourceopen', _onMediaSourceOpen, false);
+            sourceUrl = mediaSourceController.attachMediaSource(videoModel);
+            logger.debug('MediaSource attached to element.  Waiting on open...');
+        }
+
+        if (!mediaSource) {
+            mediaSource = mediaSourceController.createMediaSource();
+            _open();
+        } else {
+            if (keepBuffers) {
+                _activateStream(seekTime, keepBuffers);
+            } else {
+                mediaSourceController.detachMediaSource(videoModel);
+                _open();
+            }
         }
     }
 
-    function stopCheckIfPrebufferingCanStartInterval() {
-        clearInterval(prebufferingCanStartInterval);
-        prebufferingCanStartInterval = null;
+    /**
+     * Activates a new stream.
+     * @param {number} seekTime
+     * @param {boolean} keepBuffers
+     */
+    function _activateStream(seekTime, keepBuffers) {
+        activeStream.activate(mediaSource, keepBuffers ? bufferSinks : undefined, seekTime)
+            .then((sinks) => {
+                // check if change type is supported by the browser
+                if (sinks) {
+                    const keys = Object.keys(sinks);
+                    if (keys.length > 0 && sinks[keys[0]].getBuffer().changeType) {
+                        supportsChangeType = true;
+                    }
+                    bufferSinks = sinks;
+                }
+
+                // Set the initial time for this stream in the StreamProcessor
+                if (!isNaN(seekTime)) {
+                    eventBus.trigger(Events.SEEK_TARGET, { time: seekTime }, { streamId: activeStream.getId() });
+                    playbackController.seek(seekTime, false, true);
+                    activeStream.startScheduleControllers();
+                }
+
+                isStreamSwitchingInProgress = false;
+                eventBus.trigger(Events.PERIOD_SWITCH_COMPLETED, { toStreamInfo: getActiveStreamInfo() });
+            });
     }
 
-    function checkIfPrebufferingCanStart() {
-        // In multiperiod situations, we constantly check if the streams have finished buffering so we can immediately start buffering the next stream
-        if (!activeStream || !hasStreamFinishedBuffering(activeStream)) {
-            return;
+    /**
+     * A playback seeking event was triggered. We need to disable the preloading streams and call the respective seeking handler.
+     * We distinguish between inner period seeks and outer period seeks
+     * @param {object} e
+     * @private
+     */
+    function _onPlaybackSeeking(e) {
+        const oldTime = playbackController.getTime();
+        const newTime = e.seekTime;
+        const seekToStream = getStreamForTime(newTime);
+
+        if (!seekToStream || seekToStream === activeStream) {
+            _cancelPreloading(oldTime, newTime);
+            _handleInnerPeriodSeek(e);
+        } else if (seekToStream && seekToStream !== activeStream) {
+            _cancelPreloading(oldTime, newTime, seekToStream);
+            _handleOuterPeriodSeek(e, seekToStream);
         }
-        const upcomingStreams = getNextStreams(activeStream);
-        let i = 0;
 
-        while (i < upcomingStreams.length) {
-            const stream = upcomingStreams[i];
-            const previousStream = i === 0 ? activeStream : upcomingStreams[i - 1];
-            // If the preloading for the current stream is not scheduled, but its predecessor has finished buffering we can start prebuffering this stream
-            if (!stream.getPreloadingScheduled() && (hasStreamFinishedBuffering(previousStream))) {
+        createPlaylistMetrics(PlayList.SEEK_START_REASON);
+    }
 
-                if (mediaSource) {
-                    // We can not start prebuffering if the start of the next period is in the future. This will cause problems when calculating the segmentAvailabilityRange and updating the representations in the RepresentationController
-                    // As long as the timeline converter returns an invalid range we do not start the prebuffering
-                    const mediaTypes = [Constants.VIDEO, Constants.AUDIO];
-                    let segmentAvailabilityRangeIsOk = true;
+    /**
+     * Cancels the preloading of certain streams based on the position we are seeking to.
+     * @param {number} oldTime
+     * @param {number} newTime
+     * @param {boolean} isInnerPeriodSeek
+     * @private
+     */
+    function _cancelPreloading(oldTime, newTime, seekToStream = null) {
+        // Inner period seek forward
+        if (oldTime <= newTime && !seekToStream) {
+            _deactivateAllPreloadingStreams();
+        }
 
-                    mediaTypes.forEach((mediaType) => {
-                        const mediaInfo = adapter.getMediaInfoForType(stream.getStreamInfo(), mediaType);
-                        const voRepresentations = adapter.getVoRepresentations(mediaInfo);
-                        voRepresentations.forEach((voRep) => {
-                            const isDynamic = adapter.getIsDynamic();
-                            const range = timelineConverter.calcSegmentAvailabilityRange(voRep, isDynamic);
-
-                            if (range.end < range.start) {
-                                segmentAvailabilityRangeIsOk = false;
-                            }
-                        });
-                    });
+        // Inner period seek: If we seek backwards we might need to prune the period(s) that are currently being prebuffered. For now deactivate everything
+        else if (oldTime > newTime && !seekToStream) {
+            _deactivateAllPreloadingStreams();
+        }
 
-                    if (segmentAvailabilityRangeIsOk) {
-                        onStreamCanLoadNext(stream, previousStream);
-                    }
-                }
-            }
-            i += 1;
+        // Outer period seek: Deactivate everything for now
+        else {
+            _deactivateAllPreloadingStreams();
         }
+
     }
 
-    function hasStreamFinishedBuffering(stream) {
-        try {
-            if (!stream) {
-                return false;
-            }
-            const streamProcessors = stream.getProcessors().filter((sp) => {
-                return sp.getType() === Constants.AUDIO || sp.getType() === Constants.VIDEO;
+    /**
+     * Deactivates all preloading streams
+     * @private
+     */
+    function _deactivateAllPreloadingStreams() {
+        if (preloadingStreams && preloadingStreams.length > 0) {
+            preloadingStreams.forEach((s) => {
+                s.deactivate(true);
             });
+            preloadingStreams = [];
+        }
+    }
 
-            if (!streamProcessors || streamProcessors.length === 0) {
-                return false;
-            }
+    /**
+     * Handle an inner period seek. Prepare all StreamProcessors for the seek.
+     * @param {object} e
+     * @private
+     */
+    function _handleInnerPeriodSeek(e) {
+        const streamProcessors = activeStream.getProcessors();
 
-            const unfinishedStreamProcessors = streamProcessors.filter((sp) => {
-                return !sp.isBufferingCompleted();
-            });
+        streamProcessors.forEach((sp) => {
+            return sp.prepareInnerPeriodPlaybackSeeking(e);
+        });
 
-            return unfinishedStreamProcessors && unfinishedStreamProcessors.length === 0;
+        _flushPlaylistMetrics(PlayListTrace.USER_REQUEST_STOP_REASON);
+    }
 
-        } catch (e) {
-            return false;
-        }
+    /**
+     * Handle an outer period seek. Dispatch the corresponding event to be handled in the BufferControllers and the ScheduleControllers
+     * @param {object} e
+     * @param {object} seekToStream
+     * @private
+     */
+    function _handleOuterPeriodSeek(e, seekToStream) {
+        // Stop segment requests
+        const seekTime = e && e.seekTime && !isNaN(e.seekTime) ? e.seekTime : NaN;
+        const streamProcessors = activeStream.getProcessors();
+
+        const promises = streamProcessors.map((sp) => {
+            // Cancel everything in case the active stream is still buffering
+            return sp.prepareOuterPeriodPlaybackSeeking(e);
+        });
+
+        Promise.all(promises)
+            .then(() => {
+                _switchStream(seekToStream, activeStream, seekTime);
+            })
+            .catch((e) => {
+                errHandler.error(e);
+            });
     }
 
-    function onStreamBufferingCompleted() {
-        const isLast = getActiveStreamInfo().isLast;
-        if (mediaSource && isLast) {
-            logger.info('[onStreamBufferingCompleted] calls signalEndOfStream of mediaSourceController.');
-            mediaSourceController.signalEndOfStream(mediaSource);
+    /**
+     * A track change occured. We deactivate the preloading streams
+     * @param {object} e
+     * @private
+     */
+    function _onCurrentTrackChanged(e) {
+        // Track was changed in non active stream. No need to do anything, this only happens when a stream starts preloading
+        if (e.newMediaInfo.streamInfo.id !== activeStream.getId()) {
+            return;
         }
+
+        // If the track was changed in the active stream we need to stop preloading and remove the already prebuffered stuff. Since we do not support preloading specific handling of specific AdaptationSets yet.
+        _deactivateAllPreloadingStreams();
+
+        activeStream.prepareTrackChange(e);
     }
 
-    function canSourceBuffersBeReused(nextStream, previousStream) {
+    /**
+     * If the source buffer can be reused we can potentially start buffering the next period
+     * @param {object} nextStream
+     * @param {object} previousStream
+     * @return {boolean}
+     * @private
+     */
+    function _canSourceBuffersBeReused(nextStream, previousStream) {
         try {
-            return (settings.get().streaming.reuseExistingSourceBuffers && previousStream.isProtectionCompatible(nextStream, previousStream) &&
-                (supportsChangeType || previousStream.isMediaCodecCompatible(nextStream, previousStream)) && !hasCriticalTexttracks(nextStream));
+            // Seamless period switch allowed only if:
+            // - none of the periods uses contentProtection.
+            // - AND changeType method implemented by browser or periods use the same codec.
+            return (settings.get().streaming.buffer.reuseExistingSourceBuffers && (previousStream.isProtectionCompatible(nextStream) || firstLicenseIsFetched) && (supportsChangeType || previousStream.isMediaCodecCompatible(nextStream, previousStream)));
         } catch (e) {
             return false;
         }
     }
 
-    function onStreamCanLoadNext(nextStream, previousStream = null) {
+    /**
+     * Initiate the preloading of the next stream
+     * @param {object} nextStream
+     * @param {object} previousStream
+     * @private
+     */
+    function _onStreamCanLoadNext(nextStream, previousStream = null) {
 
         if (mediaSource && !nextStream.getPreloaded()) {
-            // Seamless period switch allowed only if:
-            // - none of the periods uses contentProtection.
-            // - AND changeType method implemented by browser or periods use the same codec.
-            let seamlessPeriodSwitch = canSourceBuffersBeReused(nextStream, previousStream);
+            let seamlessPeriodSwitch = _canSourceBuffersBeReused(nextStream, previousStream);
 
             if (seamlessPeriodSwitch) {
-                nextStream.setPreloadingScheduled(true);
-                logger.info(`[onStreamCanLoadNext] Preloading next stream with id ${nextStream.getId()}`);
-                isPeriodSwitchInProgress = true;
-                nextStream.preload(mediaSource, buffers);
-                preloadingStreams.push(nextStream);
-                nextStream.getProcessors().forEach(p => {
-                    p.setBufferingTime(nextStream.getStartTime());
-                });
-            }
-        }
-    }
-
-    function hasCriticalTexttracks(stream) {
-        try {
-            // if the upcoming stream has stpp or wvtt texttracks we need to reset the sourcebuffers and can not prebuffer
-            const streamInfo = stream.getStreamInfo();
-            const as = adapter.getAdaptationForType(streamInfo.index, Constants.FRAGMENTED_TEXT, streamInfo);
-            if (!as) {
-                return false;
+                nextStream.startPreloading(mediaSource, bufferSinks)
+                    .then(() => {
+                        preloadingStreams.push(nextStream);
+                    });
             }
-
-            return (as.codecs.indexOf('stpp') !== -1) || (as.codecs.indexOf('wvtt') !== -1);
-        } catch (e) {
-            return false;
         }
     }
 
+    /**
+     * Returns the corresponding stream object for a specific presentation time.
+     * @param {number} time
+     * @return {null|object}
+     */
     function getStreamForTime(time) {
 
         if (isNaN(time)) {
@@ -414,6 +650,172 @@ function StreamController() {
         return null;
     }
 
+    /**
+     * Add the DVR window to the metric list. We need the DVR window to restrict the seeking and calculate the right start time.
+     */
+    function _addDVRMetric() {
+        try {
+            const isDynamic = adapter.getIsDynamic();
+            const streamsInfo = adapter.getStreamsInfo();
+            const manifestInfo = streamsInfo[0].manifestInfo;
+            const time = playbackController.getTime();
+            const range = timelineConverter.calcTimeShiftBufferWindow(streams, isDynamic);
+            const activeStreamProcessors = getActiveStreamProcessors();
+
+            if (typeof range.start === 'undefined' || typeof range.end === 'undefined') {
+                return;
+            }
+
+            if (!activeStreamProcessors || activeStreamProcessors.length === 0) {
+                dashMetrics.addDVRInfo(Constants.VIDEO, time, manifestInfo, range);
+            } else {
+                activeStreamProcessors.forEach((sp) => {
+                    dashMetrics.addDVRInfo(sp.getType(), time, manifestInfo, range);
+                });
+            }
+        } catch (e) {
+        }
+    }
+
+    /**
+     * The buffer level for a certain media type has been updated. If this is the initial playback and we want to autoplay the content we check if we can start playback now.
+     * For livestreams we might have a drift of the target live delay compared to the current live delay because reaching the initial buffer level took time.
+     * @param {object} e
+     * @private
+     */
+    function _onBufferLevelUpdated(e) {
+
+        // check if this is the initial playback and we reached the buffer target. If autoplay is true we start playback
+        if (initialPlayback && autoPlay) {
+            const initialBufferLevel = mediaPlayerModel.getInitialBufferLevel();
+
+            if (isNaN(initialBufferLevel) || initialBufferLevel <= playbackController.getBufferLevel() || initialBufferLevel > playbackController.getLiveDelay()) {
+                initialPlayback = false;
+                createPlaylistMetrics(PlayList.INITIAL_PLAYOUT_START_REASON);
+                playbackController.play();
+            }
+        }
+
+        if (e && e.mediaType) {
+            dashMetrics.addBufferLevel(e.mediaType, new Date(), e.bufferLevel * 1000);
+        }
+    }
+
+    /**
+     * Update the DVR window when the wallclock time has updated
+     * @private
+     */
+    function _onWallclockTimeUpdated() {
+        if (adapter.getIsDynamic()) {
+            _addDVRMetric();
+        }
+    }
+
+    /**
+     * When the playback time is updated we add the droppedFrames metric to the dash metric object
+     * @private
+     */
+    function _onPlaybackTimeUpdated(/*e*/) {
+        if (hasVideoTrack()) {
+            const playbackQuality = videoModel.getPlaybackQuality();
+            if (playbackQuality) {
+                dashMetrics.addDroppedFrames(playbackQuality);
+            }
+        }
+    }
+
+    /**
+     * Once playback starts add playlist metrics depending on whether this was the first playback or playback resumed after pause
+     * @private
+     */
+    function _onPlaybackStarted( /*e*/) {
+        logger.debug('[onPlaybackStarted]');
+        if (!initialPlayback && isPaused) {
+            isPaused = false;
+            createPlaylistMetrics(PlayList.RESUME_FROM_PAUSE_START_REASON);
+        }
+    }
+
+    /**
+     * Once playback is paused flush metrics
+     * @param {object} e
+     * @private
+     */
+    function _onPlaybackPaused(e) {
+        logger.debug('[onPlaybackPaused]');
+        if (!e.ended) {
+            isPaused = true;
+            _flushPlaylistMetrics(PlayListTrace.USER_REQUEST_STOP_REASON);
+        }
+    }
+
+    /**
+     * Callback once a stream/period is completely buffered. We can either signal the end of the stream or start prebuffering the next period.
+     * @param {object} e
+     * @private
+     */
+    function _onStreamBufferingCompleted(e) {
+        logger.debug(`Stream with id ${e.streamInfo.id} finished buffering`);
+        const isLast = getActiveStreamInfo().isLast;
+        if (mediaSource && isLast) {
+            logger.info('[onStreamBufferingCompleted] calls signalEndOfStream of mediaSourceController.');
+            mediaSourceController.signalEndOfStream(mediaSource);
+        } else {
+            _checkIfPrebufferingCanStart();
+        }
+    }
+
+    /**
+     * Check if we can start prebuffering the next period.
+     * @private
+     */
+    function _checkIfPrebufferingCanStart() {
+        // In multiperiod situations, we can start buffering the next stream
+        if (!activeStream || !activeStream.getHasFinishedBuffering()) {
+            return;
+        }
+        const upcomingStreams = getNextStreams(activeStream);
+        let i = 0;
+
+        while (i < upcomingStreams.length) {
+            const stream = upcomingStreams[i];
+            const previousStream = i === 0 ? activeStream : upcomingStreams[i - 1];
+
+            // If the preloading for the current stream is not scheduled, but its predecessor has finished buffering we can start prebuffering this stream
+            if (!stream.getPreloaded() && previousStream.getHasFinishedBuffering()) {
+                if (mediaSource) {
+                    _onStreamCanLoadNext(stream, previousStream);
+                }
+            }
+            i += 1;
+        }
+    }
+
+    /**
+     * In some cases we need to fire the playback ended event manually
+     * @private
+     */
+    function _startPlaybackEndedTimerInterval() {
+        if (!playbackEndedTimerInterval) {
+            playbackEndedTimerInterval = setInterval(function () {
+                if (!isStreamSwitchingInProgress && playbackController.getTimeToStreamEnd() <= 0 && !playbackController.isSeeking()) {
+                    eventBus.trigger(Events.PLAYBACK_ENDED, { 'isLast': getActiveStreamInfo().isLast });
+                }
+            }, PLAYBACK_ENDED_TIMER_INTERVAL);
+        }
+    }
+
+    /**
+     * Stop the check if the playback has ended
+     * @private
+     */
+    function _stopPlaybackEndedTimerInterval() {
+        if (playbackEndedTimerInterval) {
+            clearInterval(playbackEndedTimerInterval);
+            playbackEndedTimerInterval = null;
+        }
+    }
+
     /**
      * Returns a playhead time, in seconds, converted to be relative
      * to the start of an identified stream/period or null if no such stream
@@ -450,29 +852,41 @@ function StreamController() {
         return null;
     }
 
+    /**
+     * Returns the streamProcessors of the active stream.
+     * @return {array}
+     */
     function getActiveStreamProcessors() {
         return activeStream ? activeStream.getProcessors() : [];
     }
 
-    function onEnded(e) {
-        if (!activeStream.getIsEndedEventSignaled()) {
+    /**
+     * Once playback has ended we switch to the next stream
+     * @param {object} e
+     */
+    function _onPlaybackEnded(e) {
+        if (activeStream && !activeStream.getIsEndedEventSignaled()) {
             activeStream.setIsEndedEventSignaled(true);
             const nextStream = getNextStream();
             if (nextStream) {
                 logger.debug(`StreamController onEnded, found next stream with id ${nextStream.getStreamInfo().id}`);
-                switchStream(nextStream, activeStream, NaN);
+                _switchStream(nextStream, activeStream, NaN);
             } else {
                 logger.debug('StreamController no next stream found');
                 activeStream.setIsEndedEventSignaled(false);
             }
-            flushPlaylistMetrics(nextStream ? PlayListTrace.END_OF_PERIOD_STOP_REASON : PlayListTrace.END_OF_CONTENT_STOP_REASON);
-            isPeriodSwitchInProgress = false;
+            _flushPlaylistMetrics(nextStream ? PlayListTrace.END_OF_PERIOD_STOP_REASON : PlayListTrace.END_OF_CONTENT_STOP_REASON);
         }
         if (e && e.isLast) {
-            stopPlaybackEndedTimerInterval();
+            _stopPlaybackEndedTimerInterval();
         }
     }
 
+    /**
+     * Returns the next stream to be played relative to the stream provided. If no stream is provided we use the active stream.
+     * @param {object} stream
+     * @return {null|object}
+     */
     function getNextStream(stream = null) {
         const refStream = stream ? stream : activeStream ? activeStream : null;
         if (refStream) {
@@ -505,7 +919,12 @@ function StreamController() {
         return null;
     }
 
-    function getNextStreams(stream) {
+    /**
+     * Returns all upcoming streams relative to the provided stream. If no stream is provided we use the active stream.
+     * @param {object} stream
+     * @return {array}
+     */
+    function getNextStreams(stream = null) {
         try {
             const refStream = stream ? stream : activeStream ? activeStream : null;
 
@@ -521,259 +940,119 @@ function StreamController() {
         }
     }
 
-    function switchStream(stream, previousStream, seekTime) {
-
-        if (isStreamSwitchingInProgress || !stream || (previousStream === stream && stream.isActive())) return;
-        isStreamSwitchingInProgress = true;
-
-        eventBus.trigger(Events.PERIOD_SWITCH_STARTED, {
-            fromStreamInfo: previousStream ? previousStream.getStreamInfo() : null,
-            toStreamInfo: stream.getStreamInfo()
-        });
-
-        let seamlessPeriodSwitch = false;
-        if (previousStream) {
-            seamlessPeriodSwitch = canSourceBuffersBeReused(stream, previousStream);
-            previousStream.deactivate(seamlessPeriodSwitch);
-        }
-
-        // Determine seek time when switching to new period
-        // - seek at given seek time
-        // - or seek at period start if upcoming period is not prebuffered
-        seekTime = !isNaN(seekTime) ? seekTime : (!seamlessPeriodSwitch && previousStream ? stream.getStreamInfo().start : NaN);
-        logger.info(`Switch to stream ${stream.getId()}. Seektime is ${seekTime}, current playback time is ${playbackController.getTime()}`);
-        logger.info(`Seamless period switch is set to ${seamlessPeriodSwitch}`);
-
-        activeStream = stream;
-        preloadingStreams = preloadingStreams.filter((s) => {
-            return s.getId() !== activeStream.getId();
-        });
-        playbackController.initialize(getActiveStreamInfo(), !!previousStream, seekTime);
-        if (videoModel.getElement()) {
-            openMediaSource(seekTime, (previousStream === null), false, seamlessPeriodSwitch);
-        } else {
-            activateStream(seekTime, seamlessPeriodSwitch);
-        }
-        isPeriodSwitchInProgress = false;
-    }
-
-    function switchToVideoElement(seekTime) {
-        if (activeStream) {
-            playbackController.initialize(getActiveStreamInfo());
-            openMediaSource(seekTime, false, true, false);
-        }
-    }
-
-    function openMediaSource(seekTime, sourceInitialized, streamActivated, keepBuffers) {
-        let sourceUrl;
-
-        function onMediaSourceOpen() {
-            // Manage situations in which a call to reset happens while MediaSource is being opened
-            if (!mediaSource || mediaSource.readyState !== 'open') return;
-
-            logger.debug('MediaSource is open!');
-            window.URL.revokeObjectURL(sourceUrl);
-            mediaSource.removeEventListener('sourceopen', onMediaSourceOpen);
-            mediaSource.removeEventListener('webkitsourceopen', onMediaSourceOpen);
-            setMediaDuration();
-
-            if (!sourceInitialized) {
-                eventBus.trigger(Events.SOURCE_INITIALIZED);
-            }
-
-            if (streamActivated) {
-                activeStream.setMediaSource(mediaSource);
-            } else {
-                activateStream(seekTime, keepBuffers);
-            }
-        }
-
-        if (!mediaSource) {
-            mediaSource = mediaSourceController.createMediaSource();
-            mediaSource.addEventListener('sourceopen', onMediaSourceOpen, false);
-            mediaSource.addEventListener('webkitsourceopen', onMediaSourceOpen, false);
-            sourceUrl = mediaSourceController.attachMediaSource(mediaSource, videoModel);
-            logger.debug('MediaSource attached to element.  Waiting on open...');
-        } else {
-            if (keepBuffers) {
-                activateStream(seekTime, keepBuffers);
-                if (!sourceInitialized) {
-                    eventBus.trigger(Events.SOURCE_INITIALIZED);
-                }
-            } else {
-                mediaSourceController.detachMediaSource(videoModel);
-                mediaSource.addEventListener('sourceopen', onMediaSourceOpen, false);
-                mediaSource.addEventListener('webkitsourceopen', onMediaSourceOpen, false);
-                sourceUrl = mediaSourceController.attachMediaSource(mediaSource, videoModel);
-                logger.debug('MediaSource attached to element.  Waiting on open...');
-            }
-        }
+    /**
+     * Sets the duration attribute of the MediaSource using the MediaSourceController.
+     * @param {number} duration
+     * @private
+     */
+    function _setMediaDuration(duration) {
+        const manifestDuration = duration ? duration : getActiveStreamInfo().manifestInfo.duration;
+        mediaSourceController.setDuration(manifestDuration);
     }
 
+    /**
+     * Returns the active stream
+     * @return {object}
+     */
     function getActiveStream() {
         return activeStream;
     }
 
-    function activateStream(seekTime, keepBuffers) {
-        buffers = activeStream.activate(mediaSource, keepBuffers ? buffers : undefined);
-
-        // check if change type is supported by the browser
-        if (buffers) {
-            const keys = Object.keys(buffers);
-            if (keys.length > 0 && buffers[keys[0]].changeType) {
-                supportsChangeType = true;
-            }
-        }
-
-        if (!initialPlayback) {
-            if (!isNaN(seekTime)) {
-                // If the streamswitch has been triggered by a seek command there is no need to seek again. Still we need to trigger the seeking event in order for the controllers to adjust the new time
-                if (seekTime === playbackController.getTime()) {
-                    eventBus.trigger(Events.SEEK_TARGET, { time: seekTime }, { streamId: activeStream.getId() });
-                } else {
-                    playbackController.seek(seekTime);
+    /**
+     * Called once the first stream has been initialized. We only use this function to seek to the right start time.
+     * @return {number}
+     * @private
+     */
+    function _getInitialStartTime() {
+        // Seek new stream in priority order:
+        // - at start time provided in URI parameters
+        // - at stream/period start time (for static streams) or live start time (for dynamic streams)
+        let startTime;
+        if (adapter.getIsDynamic()) {
+            // For dynamic stream, start by default at (live edge - live delay)
+            const dvrInfo = dashMetrics.getCurrentDVRInfo();
+            const liveEdge = dvrInfo && dvrInfo.range ? dvrInfo.range.end : 0;
+            // we are already in the right start period. so time should not be smaller than period@start and should not be larger than period@end
+            startTime = liveEdge - playbackController.getLiveDelay();
+            // If start time in URI, take min value between live edge time and time from URI (capped by DVR window range)
+            const dvrWindow = dvrInfo ? dvrInfo.range : null;
+            if (dvrWindow) {
+                // #t shall be relative to period start
+                const startTimeFromUri = _getStartTimeFromUriParameters(true);
+                if (!isNaN(startTimeFromUri)) {
+                    logger.info('Start time from URI parameters: ' + startTimeFromUri);
+                    startTime = Math.max(Math.min(startTime, startTimeFromUri), dvrWindow.start);
                 }
             }
+        } else {
+            // For static stream, start by default at period start
+            const streams = getStreams();
+            const streamInfo = streams[0].getStreamInfo();
+            startTime = streamInfo.start;
+            // If start time in URI, take max value between period start and time from URI (if in period range)
+            const startTimeFromUri = _getStartTimeFromUriParameters(false);
+            if (!isNaN(startTimeFromUri) && startTimeFromUri < (streamInfo.start + streamInfo.duration)) {
+                logger.info('Start time from URI parameters: ' + startTimeFromUri);
+                startTime = Math.max(startTime, startTimeFromUri);
+            }
         }
 
-        if (autoPlay || !initialPlayback) {
-            playbackController.play();
-        }
-
-        isStreamSwitchingInProgress = false;
-        eventBus.trigger(Events.PERIOD_SWITCH_COMPLETED, { toStreamInfo: getActiveStreamInfo() });
-    }
-
-    function setMediaDuration(duration) {
-        const manifestDuration = duration ? duration : getActiveStreamInfo().manifestInfo.duration;
-        mediaSourceController.setDuration(mediaSource, manifestDuration);
+        return startTime;
     }
 
-    function getComposedStream(streamInfo) {
-        for (let i = 0, ln = streams.length; i < ln; i++) {
-            if (streams[i].getId() === streamInfo.id) {
-                return streams[i];
-            }
+    /**
+     * 23009-1 Annex C.4 defines MPD anchors to use URI fragment syntax to start a presentation at a given time and a given state
+     * @param {boolean} isDynamic
+     * @return {number}
+     * @private
+     */
+    function _getStartTimeFromUriParameters(isDynamic) {
+        const fragData = uriFragmentModel.getURIFragmentData();
+        if (!fragData || !fragData.t) {
+            return NaN;
         }
-        return null;
+        const refStream = getStreams()[0];
+        const refStreamStartTime = refStream.getStreamInfo().start;
+        // Consider only start time of MediaRange
+        // TODO: consider end time of MediaRange to stop playback at provided end time
+        fragData.t = fragData.t.split(',')[0];
+        // "t=<time>" : time is relative to 1st period start
+        // "t=posix:<time>" : time is absolute start time as number of seconds since 01-01-1970
+        const posix = fragData.t.indexOf('posix:') !== -1 ? fragData.t.substring(6) === 'now' ? Date.now() / 1000 : parseInt(fragData.t.substring(6)) : NaN;
+        let startTime = (isDynamic && !isNaN(posix)) ? posix - playbackController.getAvailabilityStartTime() / 1000 : parseInt(fragData.t) + refStreamStartTime;
+        return startTime;
     }
 
-    function composeStreams() {
-        try {
-            const streamsInfo = adapter.getStreamsInfo();
-            if (streamsInfo.length === 0) {
-                throw new Error('There are no streams');
-            }
-
-            dashMetrics.updateManifestUpdateInfo({
-                currentTime: playbackController.getTime(),
-                buffered: videoModel.getBufferRange(),
-                presentationStartTime: streamsInfo[0].start,
-                clientTimeOffset: timelineConverter.getClientTimeOffset()
-            });
-
-            // Filter streams that are outdated and not included in the MPD anymore
-            if (streams.length > 0) {
-                streams = streams.filter((stream) => {
-
-                    const isStillIncluded = streamsInfo.filter((sInfo) => {
-                        return sInfo.id === stream.getId();
-                    }).length > 0;
-
-                    const shouldKeepStream = isStillIncluded || stream.getId() === activeStream.getId();
-
-                    if (!shouldKeepStream) {
-                        logger.debug(`Removing stream ${stream.getId()}`);
-                    }
-
-                    return shouldKeepStream;
-                });
-            }
-
-            for (let i = 0, ln = streamsInfo.length; i < ln; i++) {
-                // If the Stream object does not exist we probably loaded the manifest the first time or it was
-                // introduced in the updated manifest, so we need to create a new Stream and perform all the initialization operations
-                const streamInfo = streamsInfo[i];
-                let stream = getComposedStream(streamInfo);
-
-                if (!stream) {
-                    stream = Stream(context).create({
-                        manifestModel: manifestModel,
-                        mediaPlayerModel: mediaPlayerModel,
-                        dashMetrics: dashMetrics,
-                        manifestUpdater: manifestUpdater,
-                        adapter: adapter,
-                        timelineConverter: timelineConverter,
-                        capabilities: capabilities,
-                        capabilitiesFilter,
-                        errHandler: errHandler,
-                        baseURLController: baseURLController,
-                        abrController: abrController,
-                        playbackController: playbackController,
-                        eventController: eventController,
-                        mediaController: mediaController,
-                        textController: textController,
-                        protectionController: protectionController,
-                        videoModel: videoModel,
-                        streamInfo: streamInfo,
-                        settings: settings
-                    });
-                    streams.push(stream);
-                    stream.initialize();
-                } else {
-                    stream.updateData(streamInfo);
-                }
-
-                dashMetrics.addManifestUpdateStreamInfo(streamInfo);
-            }
-
-            if (!activeStream) {
-                if (adapter.getIsDynamic() && streams.length) {
-                    // Compute and set live delay
-                    const manifestInfo = streamsInfo[0].manifestInfo;
-                    const fragmentDuration = getFragmentDurationForLiveDelayCalculation(streamsInfo, manifestInfo);
-                    playbackController.computeAndSetLiveDelay(fragmentDuration, manifestInfo.DVRWindowSize, manifestInfo.minBufferTime);
-                }
-
-                // we need to figure out what the correct starting period is
-                let initialStream = null;
-                const startTimeFromUri = playbackController.getStartTimeFromUriParameters(adapter.getIsDynamic());
+    /**
+     * Streams that are no longer in the manifest can be filtered
+     * @param {object} streamsInfo
+     * @private
+     */
+    function _filterOutdatedStreams(streamsInfo) {
+        streams = streams.filter((stream) => {
+            const isStillIncluded = streamsInfo.filter((sInfo) => {
+                return sInfo.id === stream.getId();
+            }).length > 0;
 
-                initialStream = getStreamForTime(startTimeFromUri);
+            const shouldKeepStream = isStillIncluded || stream.getId() === activeStream.getId();
 
-                // For multiperiod streams we should avoid a switch of streams after the seek to the live edge. So we do a calculation of the expected seek time to find the right stream object.
-                if (!initialStream && adapter.getIsDynamic() && streams.length) {
-                    logger.debug('Dynamic stream: Trying to find the correct starting period');
-                    initialStream = getInitialStream();
-                }
-                const startStream = initialStream !== null ? initialStream : streams[0];
-                switchStream(startStream, null, NaN);
-                startPlaybackEndedTimerInterval();
-                startCheckIfPrebufferingCanStartInterval();
+            if (!shouldKeepStream) {
+                logger.debug(`Removing stream ${stream.getId()}`);
+                stream.reset(true);
             }
 
-            eventBus.trigger(Events.STREAMS_COMPOSED);
-
-        } catch (e) {
-            errHandler.error(new DashJSError(Errors.MANIFEST_ERROR_ID_NOSTREAMS_CODE, e.message + 'nostreamscomposed', manifestModel.getValue()));
-            hasInitialisationError = true;
-            reset();
-        }
-    }
-
-    function getInitialStream() {
-        try {
-            const liveEdge = timelineConverter.calcPresentationTimeFromWallTime(new Date(), adapter.getRegularPeriods()[0]);
-            const targetDelay = playbackController.getLiveDelay();
-            const targetTime = liveEdge - targetDelay;
-
-            return getStreamForTime(targetTime);
-        } catch (e) {
-            return null;
-        }
+            return shouldKeepStream;
+        });
     }
 
-    function getFragmentDurationForLiveDelayCalculation(streamInfos, manifestInfo) {
+    /**
+     * In order to calculate the initial live delay we might required the duration of the segments.
+     * @param {array} streamInfos
+     * @param {object} manifestInfo
+     * @return {number}
+     * @private
+     */
+    function _getFragmentDurationForLiveDelayCalculation(streamInfos, manifestInfo) {
         try {
             let fragmentDuration = NaN;
 
@@ -830,24 +1109,13 @@ function StreamController() {
         }
     }
 
-    function onTimeSyncCompleted( /*e*/) {
-        const manifest = manifestModel.getValue();
-        //TODO check if we can move this to initialize??
-        if (protectionController) {
-            eventBus.trigger(Events.PROTECTION_CREATED, {
-                controller: protectionController,
-                manifest: manifest
-            });
-            protectionController.setMediaElement(videoModel.getElement());
-            if (protectionData) {
-                protectionController.setProtectionData(protectionData);
-            }
-        }
-
-        composeStreams();
-    }
-
-    function onManifestUpdated(e) {
+    /**
+     * Callback handler after the manifest has been updated. Trigger an update in the adapter and filter unsupported stuff.
+     * Finally attempt UTC sync
+     * @param {object} e
+     * @private
+     */
+    function _onManifestUpdated(e) {
         if (!e.error) {
             //Since streams are not composed yet , need to manually look up useCalculatedLiveEdgeTime to detect if stream
             //is SegmentTimeline to avoid using time source
@@ -874,23 +1142,43 @@ function StreamController() {
                 }
             });
 
-            baseURLController.initialize(manifest);
-            timeSyncController.attemptSync(allUTCTimingSources);
+            // It is important to filter before initializing the baseUrlController. Otherwise we might end up with wrong references in case we remove AdaptationSets.
+            capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                .then(() => {
+                    baseURLController.initialize(manifest);
+                    timeSyncController.attemptSync(allUTCTimingSources);
+                });
         } else {
             hasInitialisationError = true;
             reset();
         }
     }
 
+    /**
+     * Check if the stream has a video track
+     * @return {boolean}
+     */
     function hasVideoTrack() {
         return activeStream ? activeStream.getHasVideoTrack() : false;
     }
 
+    /**
+     * Check if the stream has an audio track
+     * @return {boolean}
+     */
     function hasAudioTrack() {
         return activeStream ? activeStream.getHasAudioTrack() : false;
     }
 
-    function flushPlaylistMetrics(reason, time) {
+
+    function switchToVideoElement(seekTime) {
+        if (activeStream) {
+            playbackController.initialize(getActiveStreamInfo());
+            _openMediaSource(seekTime, false);
+        }
+    }
+
+    function _flushPlaylistMetrics(reason, time) {
         time = time || new Date();
 
         getActiveStreamProcessors().forEach(p => {
@@ -955,14 +1243,17 @@ function StreamController() {
         return isStreamSwitchingInProgress;
     }
 
-    function getHasMediaOrIntialisationError() {
+    function getHasMediaOrInitialisationError() {
         return hasMediaError || hasInitialisationError;
     }
 
     function getStreamById(id) {
-        return streams.filter(function (item) {
-            return item.getId() === id;
-        })[0];
+        for (let i = 0, ln = streams.length; i < ln; i++) {
+            if (streams[i].getId() === id) {
+                return streams[i];
+            }
+        }
+        return null;
     }
 
     function checkConfig() {
@@ -991,7 +1282,7 @@ function StreamController() {
 
     function onManifestValidityChanged(e) {
         if (!isNaN(e.newDuration)) {
-            setMediaDuration(e.newDuration);
+            _setMediaDuration(e.newDuration);
         }
     }
 
@@ -1034,25 +1325,34 @@ function StreamController() {
         if (config.playbackController) {
             playbackController = config.playbackController;
         }
+        if (config.textController) {
+            textController = config.textController;
+        }
         if (config.abrController) {
             abrController = config.abrController;
         }
         if (config.mediaController) {
             mediaController = config.mediaController;
         }
-        if (config.textController) {
-            textController = config.textController;
-        }
         if (config.settings) {
             settings = config.settings;
         }
         if (config.baseURLController) {
             baseURLController = config.baseURLController;
         }
+        if (config.uriFragmentModel) {
+            uriFragmentModel = config.uriFragmentModel;
+        }
+        if (config.segmentBaseController) {
+            segmentBaseController = config.segmentBaseController;
+        }
     }
 
     function setProtectionData(protData) {
         protectionData = protData;
+        if (protectionController) {
+            protectionController.setProtectionData(protectionData);
+        }
     }
 
     function resetInitialSettings() {
@@ -1066,10 +1366,11 @@ function StreamController() {
         isPaused = false;
         autoPlay = true;
         playbackEndedTimerInterval = null;
-        isPeriodSwitchInProgress = false;
-        prebufferingCanStartInterval = null;
         preBufferingCheckInProgress = false;
+        firstLicenseIsFetched = false;
         preloadingStreams = [];
+        dataForStreamSwitchAfterSeek = null;
+        waitForPlaybackStartTimeout = null;
     }
 
     function reset() {
@@ -1077,7 +1378,7 @@ function StreamController() {
 
         timeSyncController.reset();
 
-        flushPlaylistMetrics(
+        _flushPlaylistMetrics(
             hasMediaError || hasInitialisationError ?
                 PlayListTrace.FAILURE_STOP_REASON :
                 PlayListTrace.USER_REQUEST_STOP_REASON
@@ -1113,8 +1414,7 @@ function StreamController() {
             }
         }
 
-        stopPlaybackEndedTimerInterval();
-        stopCheckIfPrebufferingCanStartInterval();
+        _stopPlaybackEndedTimerInterval();
         eventBus.trigger(Events.STREAM_TEARDOWN_COMPLETE);
         resetInitialSettings();
     }
@@ -1125,7 +1425,7 @@ function StreamController() {
             //Should we normalize and union the two?
             const targetMediaType = hasAudioTrack() ? Constants.AUDIO : Constants.VIDEO;
             if (e.mediaType === targetMediaType) {
-                mediaSourceController.setSeekable(mediaSource, e.value.range.start, e.value.range.end);
+                mediaSourceController.setSeekable(e.value.range.start, e.value.range.end);
             }
         }
     }
@@ -1139,7 +1439,6 @@ function StreamController() {
         getActiveStreamInfo,
         hasVideoTrack,
         hasAudioTrack,
-        switchToVideoElement,
         getStreamById,
         getStreamForTime,
         getTimeRelativeToStreamId,
@@ -1149,9 +1448,10 @@ function StreamController() {
         setConfig,
         setProtectionData,
         getIsStreamSwitchInProgress,
-        getHasMediaOrIntialisationError,
-        hasStreamFinishedBuffering,
+        switchToVideoElement,
+        getHasMediaOrInitialisationError,
         getStreams,
+        getNextStream,
         getActiveStream,
         reset
     };
diff --git a/src/streaming/models/FragmentModel.js b/src/streaming/models/FragmentModel.js
index 8771982a14..7b9a517509 100644
--- a/src/streaming/models/FragmentModel.js
+++ b/src/streaming/models/FragmentModel.js
@@ -201,15 +201,6 @@ function FragmentModel(config) {
 
     function executeRequest(request) {
         switch (request.action) {
-            case FragmentRequest.ACTION_COMPLETE:
-                executedRequests.push(request);
-                addSchedulingInfoMetrics(request, FRAGMENT_MODEL_EXECUTED);
-                logger.debug('STREAM_COMPLETED');
-                eventBus.trigger(events.STREAM_COMPLETED,
-                    { request: request },
-                    { streamId: request.mediaInfo.streamInfo.id, mediaType: request.mediaType }
-                );
-                break;
             case FragmentRequest.ACTION_DOWNLOAD:
                 addSchedulingInfoMetrics(request, FRAGMENT_MODEL_LOADING);
                 loadingRequests.push(request);
@@ -345,18 +336,19 @@ function FragmentModel(config) {
     }
 
     instance = {
-        getStreamId: getStreamId,
-        getType: getType,
-        getRequests: getRequests,
-        isFragmentLoaded: isFragmentLoaded,
-        isFragmentLoadedOrPending: isFragmentLoadedOrPending,
-        removeExecutedRequestsBeforeTime: removeExecutedRequestsBeforeTime,
-        removeExecutedRequestsAfterTime: removeExecutedRequestsAfterTime,
-        syncExecutedRequestsWithBufferedRange: syncExecutedRequestsWithBufferedRange,
-        abortRequests: abortRequests,
-        executeRequest: executeRequest,
-        reset: reset,
-        addExecutedRequest: addExecutedRequest
+        getStreamId,
+        getType,
+        getRequests,
+        isFragmentLoaded,
+        isFragmentLoadedOrPending,
+        removeExecutedRequestsBeforeTime,
+        removeExecutedRequestsAfterTime,
+        syncExecutedRequestsWithBufferedRange,
+        abortRequests,
+        executeRequest,
+        reset,
+        resetInitialSettings,
+        addExecutedRequest
     };
 
     setup();
diff --git a/src/streaming/models/MediaPlayerModel.js b/src/streaming/models/MediaPlayerModel.js
index 8bc5fff324..05f3b1ac83 100644
--- a/src/streaming/models/MediaPlayerModel.js
+++ b/src/streaming/models/MediaPlayerModel.js
@@ -114,13 +114,23 @@ function MediaPlayerModel() {
         }
     }
 
+    function getInitialBufferLevel() {
+        const initialBufferLevel = settings.get().streaming.buffer.initialBufferLevel;
+
+        if (isNaN(initialBufferLevel) || initialBufferLevel < 0) {
+            return 0;
+        }
+
+        return Math.min(getStableBufferTime(), initialBufferLevel);
+    }
+
     function getStableBufferTime() {
         if (settings.get().streaming.lowLatencyEnabled) {
             return getLiveDelay() * 0.6;
         }
 
-        const stableBufferTime = settings.get().streaming.stableBufferTime;
-        return stableBufferTime > -1 ? stableBufferTime : settings.get().streaming.fastSwitchEnabled ? DEFAULT_MIN_BUFFER_TIME_FAST_SWITCH : DEFAULT_MIN_BUFFER_TIME;
+        const stableBufferTime = settings.get().streaming.buffer.stableBufferTime;
+        return stableBufferTime > -1 ? stableBufferTime : settings.get().streaming.buffer.fastSwitchEnabled ? DEFAULT_MIN_BUFFER_TIME_FAST_SWITCH : DEFAULT_MIN_BUFFER_TIME;
     }
 
     function getRetryAttemptsForType(type) {
@@ -137,9 +147,9 @@ function MediaPlayerModel() {
 
     function getLiveDelay() {
         if (settings.get().streaming.lowLatencyEnabled) {
-            return settings.get().streaming.liveDelay || DEFAULT_LOW_LATENCY_LIVE_DELAY;
+            return settings.get().streaming.delay.liveDelay || DEFAULT_LOW_LATENCY_LIVE_DELAY;
         }
-        return settings.get().streaming.liveDelay;
+        return settings.get().streaming.delay.liveDelay;
     }
 
     function getLiveCatchupLatencyThreshold() {
@@ -227,6 +237,7 @@ function MediaPlayerModel() {
         addABRCustomRule,
         removeABRCustomRule,
         getStableBufferTime,
+        getInitialBufferLevel,
         getRetryAttemptsForType,
         getRetryIntervalsForType,
         getLiveDelay,
diff --git a/src/streaming/models/MetricsModel.js b/src/streaming/models/MetricsModel.js
index e5035722ec..40c58a937e 100644
--- a/src/streaming/models/MetricsModel.js
+++ b/src/streaming/models/MetricsModel.js
@@ -31,13 +31,13 @@
 import Constants from '../constants/Constants';
 import MetricsConstants from '../constants/MetricsConstants';
 import MetricsList from '../vo/MetricsList';
-import { HTTPRequest, HTTPRequestTrace } from '../vo/metrics/HTTPRequest';
+import {HTTPRequest, HTTPRequestTrace} from '../vo/metrics/HTTPRequest';
 import TrackSwitch from '../vo/metrics/RepresentationSwitch';
 import BufferLevel from '../vo/metrics/BufferLevel';
 import BufferState from '../vo/metrics/BufferState';
 import DVRInfo from '../vo/metrics/DVRInfo';
 import DroppedFrames from '../vo/metrics/DroppedFrames';
-import { ManifestUpdate, ManifestUpdateStreamInfo, ManifestUpdateRepresentationInfo } from '../vo/metrics/ManifestUpdate';
+import {ManifestUpdate, ManifestUpdateStreamInfo, ManifestUpdateRepresentationInfo} from '../vo/metrics/ManifestUpdate';
 import SchedulingInfo from '../vo/metrics/SchedulingInfo';
 import EventBus from '../../core/EventBus';
 import RequestsQueue from '../vo/metrics/RequestsQueue';
@@ -110,7 +110,7 @@ function MetricsModel(config) {
         let metrics = getMetricsFor(type);
         if (metrics !== null) {
             metrics[list].push(value);
-            if ( metrics[list].length > settings.get().streaming.metricsMaxListDepth ) {
+            if (metrics[list].length > settings.get().streaming.metricsMaxListDepth) {
                 metrics[list].shift();
             }
         }
@@ -235,7 +235,7 @@ function MetricsModel(config) {
 
     function addDVRInfo(mediaType, currentTime, mpd, range) {
         let vo = new DVRInfo();
-        vo.time = currentTime ;
+        vo.time = currentTime;
         vo.range = range;
         vo.manifestInfo = mpd;
 
diff --git a/src/streaming/models/VideoModel.js b/src/streaming/models/VideoModel.js
index aca0639683..12fa8835c1 100644
--- a/src/streaming/models/VideoModel.js
+++ b/src/streaming/models/VideoModel.js
@@ -33,6 +33,15 @@ import FactoryMaker from '../../core/FactoryMaker';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
 import Debug from '../../core/Debug';
+import Constants from '../constants/Constants';
+
+
+const READY_STATES_TO_EVENT_NAMES = new Map([
+    [Constants.VIDEO_ELEMENT_READY_STATES.HAVE_METADATA, 'loadedmetadata'],
+    [Constants.VIDEO_ELEMENT_READY_STATES.HAVE_CURRENT_DATA, 'loadeddata'],
+    [Constants.VIDEO_ELEMENT_READY_STATES.HAVE_FUTURE_DATA, 'canplay'],
+    [Constants.VIDEO_ELEMENT_READY_STATES.HAVE_ENOUGH_DATA, 'canplaythrough']
+]);
 
 function VideoModel() {
 
@@ -79,29 +88,33 @@ function VideoModel() {
 
     //TODO Move the DVR window calculations from MediaPlayer to Here.
     function setCurrentTime(currentTime, stickToBuffered) {
-        if (element) {
-            //_currentTime = currentTime;
-
-            // We don't set the same currentTime because it can cause firing unexpected Pause event in IE11
-            // providing playbackRate property equals to zero.
-            if (element.currentTime == currentTime) return;
-
-            // TODO Despite the fact that MediaSource 'open' event has been fired IE11 cannot set videoElement.currentTime
-            // immediately (it throws InvalidStateError). It seems that this is related to videoElement.readyState property
-            // Initially it is 0, but soon after 'open' event it goes to 1 and setting currentTime is allowed. Chrome allows to
-            // set currentTime even if readyState = 0.
-            // setTimeout is used to workaround InvalidStateError in IE11
-            try {
-                currentTime = stickToBuffered ? stickTimeToBuffered(currentTime) : currentTime;
-                element.currentTime = currentTime;
-            } catch (e) {
-                if (element.readyState === 0 && e.code === e.INVALID_STATE_ERR) {
-                    setTimeout(function () {
-                        element.currentTime = currentTime;
-                    }, 400);
+        waitForReadyState(Constants.VIDEO_ELEMENT_READY_STATES.HAVE_METADATA, () => {
+            if (element) {
+                //_currentTime = currentTime;
+
+                // We don't set the same currentTime because it can cause firing unexpected Pause event in IE11
+                // providing playbackRate property equals to zero.
+                if (element.currentTime === currentTime) {
+                    return;
+                }
+
+                // TODO Despite the fact that MediaSource 'open' event has been fired IE11 cannot set videoElement.currentTime
+                // immediately (it throws InvalidStateError). It seems that this is related to videoElement.readyState property
+                // Initially it is 0, but soon after 'open' event it goes to 1 and setting currentTime is allowed. Chrome allows to
+                // set currentTime even if readyState = 0.
+                // setTimeout is used to workaround InvalidStateError in IE11
+                try {
+                    currentTime = stickToBuffered ? stickTimeToBuffered(currentTime) : currentTime;
+                    element.currentTime = currentTime;
+                } catch (e) {
+                    if (element.readyState === 0 && e.code === e.INVALID_STATE_ERR) {
+                        setTimeout(function () {
+                            element.currentTime = currentTime;
+                        }, 400);
+                    }
                 }
             }
-        }
+        });
     }
 
     function stickTimeToBuffered(time) {
@@ -245,7 +258,9 @@ function VideoModel() {
     }
 
     function getPlaybackQuality() {
-        if (!element) { return null; }
+        if (!element) {
+            return null;
+        }
         let hasWebKit = ('webkitDroppedFrameCount' in element) && ('webkitDecodedFrameCount' in element);
         let hasQuality = ('getVideoPlaybackQuality' in element);
         let result = null;
@@ -365,7 +380,7 @@ function VideoModel() {
                 //label parameter could be a number (due to adaptationSet), but label, the attribute of textTrack, is a string => to modify...
                 //label could also be undefined (due to adaptationSet)
                 if (element.textTracks[i].kind === kind && (label ? element.textTracks[i].label == label : true) &&
-                   element.textTracks[i].language === lang && element.textTracks[i].isTTML === isTTML && element.textTracks[i].isEmbedded === isEmbedded) {
+                    element.textTracks[i].language === lang && element.textTracks[i].isTTML === isTTML && element.textTracks[i].isEmbedded === isEmbedded) {
                     return element.textTracks[i];
                 }
             }
@@ -406,6 +421,27 @@ function VideoModel() {
         }
     }
 
+    function waitForReadyState(targetReadyState, callback) {
+        if (targetReadyState === Constants.VIDEO_ELEMENT_READY_STATES.HAVE_NOTHING ||
+            getReadyState() >= targetReadyState) {
+            callback();
+        } else {
+            // wait for the appropriate callback before checking again
+            const event = READY_STATES_TO_EVENT_NAMES.get(targetReadyState);
+            _listenOnce(event, callback);
+        }
+    }
+
+    function _listenOnce(event, callback) {
+        const func = () => {
+            // Stop listening to this event.
+            removeEventListener(event, func);
+            // Call the original listener.
+            callback(event);
+        };
+        addEventListener(event, func);
+    }
+
     instance = {
         initialize: initialize,
         setCurrentTime: setCurrentTime,
diff --git a/src/streaming/protection/ProtectionEvents.js b/src/streaming/protection/ProtectionEvents.js
index 456164872e..236ebdc5d9 100644
--- a/src/streaming/protection/ProtectionEvents.js
+++ b/src/streaming/protection/ProtectionEvents.js
@@ -179,6 +179,12 @@ class ProtectionEvents extends EventsBase {
          * @ignore
          */
         this.VIDEO_ELEMENT_SELECTED = 'videoElementSelected';
+
+        /**
+         * Triggered when the key session has been updated successfully
+         * @ignore
+         */
+        this.KEY_SESSION_UPDATED = 'keySessionUpdated';
     }
 }
 
diff --git a/src/streaming/protection/controllers/ProtectionController.js b/src/streaming/protection/controllers/ProtectionController.js
index 3455884266..812ad01647 100644
--- a/src/streaming/protection/controllers/ProtectionController.js
+++ b/src/streaming/protection/controllers/ProtectionController.js
@@ -953,24 +953,24 @@ function ProtectionController(config) {
     }
 
     instance = {
-        initializeForMedia: initializeForMedia,
-        clearMediaInfoArrayByStreamId: clearMediaInfoArrayByStreamId,
-        createKeySession: createKeySession,
-        loadKeySession: loadKeySession,
-        removeKeySession: removeKeySession,
-        closeKeySession: closeKeySession,
-        setServerCertificate: setServerCertificate,
-        setMediaElement: setMediaElement,
-        setSessionType: setSessionType,
-        setRobustnessLevel: setRobustnessLevel,
-        setProtectionData: setProtectionData,
-        getSupportedKeySystemsFromContentProtection: getSupportedKeySystemsFromContentProtection,
-        getKeySystems: getKeySystems,
-        setKeySystems: setKeySystems,
-        setLicenseRequestFilters: setLicenseRequestFilters,
-        setLicenseResponseFilters: setLicenseResponseFilters,
-        stop: stop,
-        reset: reset
+        initializeForMedia,
+        clearMediaInfoArrayByStreamId,
+        createKeySession,
+        loadKeySession,
+        removeKeySession,
+        closeKeySession,
+        setServerCertificate,
+        setMediaElement,
+        setSessionType,
+        setRobustnessLevel,
+        setProtectionData,
+        getSupportedKeySystemsFromContentProtection,
+        getKeySystems,
+        setKeySystems,
+        setLicenseRequestFilters,
+        setLicenseResponseFilters,
+        stop,
+        reset
     };
 
     setup();
diff --git a/src/streaming/protection/models/ProtectionModel_01b.js b/src/streaming/protection/models/ProtectionModel_01b.js
index 454ad6544e..6449b8a545 100644
--- a/src/streaming/protection/models/ProtectionModel_01b.js
+++ b/src/streaming/protection/models/ProtectionModel_01b.js
@@ -251,6 +251,7 @@ function ProtectionModel_01b(config) {
                     message.keyPairs[i].key, message.keyPairs[i].keyID, sessionID);
             }
         }
+        eventBus.trigger(events.KEY_SESSION_UPDATED);
     }
 
     function closeKeySession(sessionToken) {
diff --git a/src/streaming/protection/models/ProtectionModel_21Jan2015.js b/src/streaming/protection/models/ProtectionModel_21Jan2015.js
index ddcc0b9b31..71f9d2b455 100644
--- a/src/streaming/protection/models/ProtectionModel_21Jan2015.js
+++ b/src/streaming/protection/models/ProtectionModel_21Jan2015.js
@@ -205,7 +205,7 @@ function ProtectionModel_21Jan2015(config) {
 
         // Generate initial key request.
         // keyids type is used for clearkey when keys are provided directly in the protection data and then request to a license server is not needed
-        const dataType = ks.systemString === ProtectionConstants.CLEARKEY_KEYSTEM_STRING && (initData ||  (protData && protData.clearkeys)) ? 'keyids' : 'cenc';
+        const dataType = ks.systemString === ProtectionConstants.CLEARKEY_KEYSTEM_STRING && (initData || (protData && protData.clearkeys)) ? 'keyids' : 'cenc';
         session.generateRequest(dataType, initData).then(function () {
             logger.debug('DRM: Session created.  SessionID = ' + sessionToken.getSessionID());
             eventBus.trigger(events.KEY_SESSION_CREATED, { data: sessionToken });
@@ -226,9 +226,13 @@ function ProtectionModel_21Jan2015(config) {
         if (protectionKeyController.isClearKey(keySystem)) {
             message = message.toJWK();
         }
-        session.update(message).catch(function (error) {
-            eventBus.trigger(events.KEY_ERROR, { data: new DashJSError(ProtectionErrors.MEDIA_KEYERR_CODE, 'Error sending update() message! ' + error.name, sessionToken) });
-        });
+        session.update(message)
+            .then(() => {
+                eventBus.trigger(events.KEY_SESSION_UPDATED);
+            })
+            .catch(function (error) {
+                eventBus.trigger(events.KEY_ERROR, {data: new DashJSError(ProtectionErrors.MEDIA_KEYERR_CODE, 'Error sending update() message! ' + error.name, sessionToken)});
+            });
     }
 
     function loadKeySession(sessionID, initData, sessionType) {
diff --git a/src/streaming/protection/models/ProtectionModel_3Feb2014.js b/src/streaming/protection/models/ProtectionModel_3Feb2014.js
index 671285158d..171e36aa12 100644
--- a/src/streaming/protection/models/ProtectionModel_3Feb2014.js
+++ b/src/streaming/protection/models/ProtectionModel_3Feb2014.js
@@ -243,6 +243,7 @@ function ProtectionModel_3Feb2014(config) {
             // For clearkey, message is a ClearKeyKeySet
             session.update(new Uint8Array(message.toJWK()));
         }
+        eventBus.trigger(events.KEY_SESSION_UPDATED);
     }
 
     /**
diff --git a/src/streaming/rules/DroppedFramesHistory.js b/src/streaming/rules/DroppedFramesHistory.js
index 1eb251f4be..33ca3fb1fe 100644
--- a/src/streaming/rules/DroppedFramesHistory.js
+++ b/src/streaming/rules/DroppedFramesHistory.js
@@ -1,47 +1,68 @@
-
 import FactoryMaker from '../../core/FactoryMaker';
 
-
 function DroppedFramesHistory() {
 
-    let values = [];
-    let lastDroppedFrames = 0;
-    let lastTotalFrames = 0;
+    let values = {};
+    let lastDroppedFrames = {};
+    let lastTotalFrames = {};
+
+    function push(streamId, index, playbackQuality) {
+
+        if (!index) {
+            return;
+        }
+
+        if (!values[streamId]) {
+            values[streamId] = [];
+            lastDroppedFrames[streamId] = 0;
+            lastTotalFrames[streamId] = 0;
+        }
 
-    function push(index, playbackQuality) {
         let droppedVideoFrames = playbackQuality && playbackQuality.droppedVideoFrames ? playbackQuality.droppedVideoFrames : 0;
         let totalVideoFrames = playbackQuality && playbackQuality.totalVideoFrames ? playbackQuality.totalVideoFrames : 0;
 
         let intervalDroppedFrames = droppedVideoFrames - lastDroppedFrames;
-        lastDroppedFrames = droppedVideoFrames;
+        lastDroppedFrames[streamId] = droppedVideoFrames;
 
         let intervalTotalFrames = totalVideoFrames - lastTotalFrames;
-        lastTotalFrames = totalVideoFrames;
+        lastTotalFrames[streamId] = totalVideoFrames;
 
+        const current = values[streamId];
         if (!isNaN(index)) {
-            if (!values[index]) {
-                values[index] = {droppedVideoFrames: intervalDroppedFrames, totalVideoFrames: intervalTotalFrames};
+            if (!current[index]) {
+                current[index] = { droppedVideoFrames: intervalDroppedFrames, totalVideoFrames: intervalTotalFrames };
             } else {
-                values[index].droppedVideoFrames += intervalDroppedFrames;
-                values[index].totalVideoFrames += intervalTotalFrames;
+                current[index].droppedVideoFrames += intervalDroppedFrames;
+                current[index].totalVideoFrames += intervalTotalFrames;
             }
         }
     }
 
-    function getDroppedFrameHistory() {
-        return values;
+    function getFrameHistory(streamId) {
+        return values[streamId];
+    }
+
+    function clearForStream(streamId) {
+        try {
+            delete values[streamId];
+            delete lastDroppedFrames[streamId];
+            delete lastTotalFrames[streamId];
+        } catch (e) {
+
+        }
     }
 
-    function reset(playbackQuality) {
-        values = [];
-        lastDroppedFrames = playbackQuality.droppedVideoFrames;
-        lastTotalFrames = playbackQuality.totalVideoFrames;
+    function reset() {
+        values = {};
+        lastDroppedFrames = {};
+        lastTotalFrames = {};
     }
 
     return {
-        push: push,
-        getFrameHistory: getDroppedFrameHistory,
-        reset: reset
+        push,
+        getFrameHistory,
+        clearForStream,
+        reset
     };
 }
 
diff --git a/src/streaming/rules/abr/ABRRulesCollection.js b/src/streaming/rules/abr/ABRRulesCollection.js
index 6a73749a45..3b67894a45 100644
--- a/src/streaming/rules/abr/ABRRulesCollection.js
+++ b/src/streaming/rules/abr/ABRRulesCollection.js
@@ -196,8 +196,8 @@ function ABRRulesCollection(config) {
         return maxQuality || SwitchRequest(context).create();
     }
 
-    function shouldAbandonFragment(rulesContext) {
-        const abandonRequestArray = abandonFragmentRules.map(rule => rule.shouldAbandon(rulesContext));
+    function shouldAbandonFragment(rulesContext, streamId) {
+        const abandonRequestArray = abandonFragmentRules.map(rule => rule.shouldAbandon(rulesContext, streamId));
         const activeRules = getActiveRules(abandonRequestArray);
         const shouldAbandon = getMinSwitchRequest(activeRules);
 
diff --git a/src/streaming/rules/abr/AbandonRequestsRule.js b/src/streaming/rules/abr/AbandonRequestsRule.js
index aa6181fd18..783321b27a 100644
--- a/src/streaming/rules/abr/AbandonRequestsRule.js
+++ b/src/streaming/rules/abr/AbandonRequestsRule.js
@@ -75,6 +75,8 @@ function AbandonRequestsRule(config) {
 
         const mediaInfo = rulesContext.getMediaInfo();
         const mediaType = rulesContext.getMediaType();
+        const streamInfo = rulesContext.getStreamInfo();
+        const streamId = streamInfo ? streamInfo.id : null;
         const req = rulesContext.getCurrentRequest();
 
         if (!isNaN(req.index)) {
@@ -121,10 +123,10 @@ function AbandonRequestsRule(config) {
                     const abrController = rulesContext.getAbrController();
                     const bytesRemaining = fragmentInfo.bytesTotal - fragmentInfo.bytesLoaded;
                     const bitrateList = abrController.getBitrateList(mediaInfo);
-                    const quality = abrController.getQualityForBitrate(mediaInfo, fragmentInfo.measuredBandwidthInKbps * settings.get().streaming.abr.bandwidthSafetyFactor);
-                    const minQuality = abrController.getMinAllowedIndexFor(mediaType);
+                    const quality = abrController.getQualityForBitrate(mediaInfo, fragmentInfo.measuredBandwidthInKbps * settings.get().streaming.abr.bandwidthSafetyFactor, streamId);
+                    const minQuality = abrController.getMinAllowedIndexFor(mediaType, streamId);
                     const newQuality = (minQuality !== undefined) ? Math.max(minQuality, quality) : quality;
-                    const estimateOtherBytesTotal = fragmentInfo.bytesTotal * bitrateList[newQuality].bitrate / bitrateList[abrController.getQualityFor(mediaType)].bitrate;
+                    const estimateOtherBytesTotal = fragmentInfo.bytesTotal * bitrateList[newQuality].bitrate / bitrateList[abrController.getQualityFor(mediaType, streamId)].bitrate;
 
                     if (bytesRemaining > estimateOtherBytesTotal) {
                         switchRequest.quality = newQuality;
diff --git a/src/streaming/rules/abr/BolaRule.js b/src/streaming/rules/abr/BolaRule.js
index 9f976b480e..ce045f8d9f 100644
--- a/src/streaming/rules/abr/BolaRule.js
+++ b/src/streaming/rules/abr/BolaRule.js
@@ -426,7 +426,7 @@ function BolaRule(config) {
 
         switch (bolaState.state) {
             case BOLA_STATE_STARTUP:
-                quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, latency);
+                quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, streamId, latency);
 
                 switchRequest.quality = quality;
                 switchRequest.reason.throughput = safeThroughput;
@@ -453,7 +453,7 @@ function BolaRule(config) {
 
                 // we want to avoid oscillations
                 // We implement the "BOLA-O" variant: when network bandwidth lies between two encoded bitrate levels, stick to the lowest level.
-                const qualityForThroughput = abrController.getQualityForBitrate(mediaInfo, safeThroughput, latency);
+                const qualityForThroughput = abrController.getQualityForBitrate(mediaInfo, safeThroughput, streamId, latency);
                 if (quality > bolaState.lastQuality && quality > qualityForThroughput) {
                     // only intervene if we are trying to *increase* quality to an *unsustainable* level
                     // we are only avoid oscillations - do not drop below last quality
@@ -496,7 +496,7 @@ function BolaRule(config) {
             default:
                 logger.debug('BOLA ABR rule invoked in bad state.');
                 // should not arrive here, try to recover
-                switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, latency);
+                switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, streamId, latency);
                 switchRequest.reason.state = bolaState.state;
                 switchRequest.reason.throughput = safeThroughput;
                 switchRequest.reason.latency = latency;
diff --git a/src/streaming/rules/abr/DroppedFramesRule.js b/src/streaming/rules/abr/DroppedFramesRule.js
index f22d15e331..8314adc308 100644
--- a/src/streaming/rules/abr/DroppedFramesRule.js
+++ b/src/streaming/rules/abr/DroppedFramesRule.js
@@ -1,4 +1,3 @@
-
 import FactoryMaker from '../../../core/FactoryMaker';
 import SwitchRequest from '../SwitchRequest';
 import Debug from '../../../core/Debug';
@@ -22,13 +21,23 @@ function DroppedFramesRule() {
         if (!rulesContext || !rulesContext.hasOwnProperty('getDroppedFramesHistory')) {
             return switchRequest;
         }
+
         const droppedFramesHistory = rulesContext.getDroppedFramesHistory();
+        const streamId = rulesContext.getStreamInfo().id;
+
         if (droppedFramesHistory) {
-            const dfh = droppedFramesHistory.getFrameHistory();
+            const dfh = droppedFramesHistory.getFrameHistory(streamId);
+
+            if (!dfh || dfh.length === 0) {
+                return switchRequest;
+            }
+
             let droppedFrames = 0;
             let totalFrames = 0;
             let maxIndex = SwitchRequest.NO_CHANGE;
-            for (let i = 1; i < dfh.length; i++) { //No point in measuring dropped frames for the zeroeth index.
+
+            //No point in measuring dropped frames for the zeroeth index.
+            for (let i = 1; i < dfh.length; i++) {
                 if (dfh[i]) {
                     droppedFrames = dfh[i].droppedVideoFrames;
                     totalFrames = dfh[i].totalVideoFrames;
@@ -40,14 +49,14 @@ function DroppedFramesRule() {
                     }
                 }
             }
-            return SwitchRequest(context).create(maxIndex, {droppedFrames: droppedFrames});
+            return SwitchRequest(context).create(maxIndex, { droppedFrames: droppedFrames });
         }
 
         return switchRequest;
     }
 
     instance = {
-        getMaxIndex: getMaxIndex
+        getMaxIndex
     };
 
     setup();
@@ -56,4 +65,4 @@ function DroppedFramesRule() {
 }
 
 DroppedFramesRule.__dashjs_factory_name = 'DroppedFramesRule';
-export default FactoryMaker.getClassFactory(DroppedFramesRule);
\ No newline at end of file
+export default FactoryMaker.getClassFactory(DroppedFramesRule);
diff --git a/src/streaming/rules/abr/InsufficientBufferRule.js b/src/streaming/rules/abr/InsufficientBufferRule.js
index 2b61732423..b4dc68e4a2 100644
--- a/src/streaming/rules/abr/InsufficientBufferRule.js
+++ b/src/streaming/rules/abr/InsufficientBufferRule.js
@@ -39,7 +39,7 @@ import MetricsConstants from '../../constants/MetricsConstants';
 function InsufficientBufferRule(config) {
 
     config = config || {};
-    const INSUFFICIENT_BUFFER_SAFETY_FACTOR = 0.5;
+    const INSUFFICIENT_BUFFER_SAFETY_FACTOR = 0.7;
     const SEGMENT_IGNORE_COUNT = 2;
 
     const context = this.context;
@@ -87,6 +87,8 @@ function InsufficientBufferRule(config) {
         const currentBufferState = dashMetrics.getCurrentBufferState(mediaType);
         const representationInfo = rulesContext.getRepresentationInfo();
         const fragmentDuration = representationInfo.fragmentDuration;
+        const streamInfo = rulesContext.getStreamInfo();
+        const streamId = streamInfo ? streamInfo.id : null;
 
         // Don't ask for a bitrate change if there is not info about buffer state or if fragmentDuration is not defined
         if (shouldIgnore(mediaType) || !fragmentDuration) {
@@ -107,7 +109,7 @@ function InsufficientBufferRule(config) {
             const latency = throughputHistory.getAverageLatency(mediaType);
             const bitrate = throughput * (bufferLevel / fragmentDuration) * INSUFFICIENT_BUFFER_SAFETY_FACTOR;
 
-            switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, bitrate, latency);
+            switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, bitrate, streamId, latency);
             switchRequest.reason = 'InsufficientBufferRule: being conservative to avoid immediate rebuffering';
         }
 
diff --git a/src/streaming/rules/abr/L2ARule.js b/src/streaming/rules/abr/L2ARule.js
index 6b679fbdf5..83c97da78d 100644
--- a/src/streaming/rules/abr/L2ARule.js
+++ b/src/streaming/rules/abr/L2ARule.js
@@ -362,7 +362,7 @@ function L2ARule(config) {
 
         switch (l2AState.state) {
             case L2A_STATE_STARTUP:
-                quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, latency);//During strat-up phase abr.controller is responsible for bitrate decisions.
+                quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, streamInfo.id, latency);//During strat-up phase abr.controller is responsible for bitrate decisions.
                 switchRequest.quality = quality;
                 switchRequest.reason.throughput = safeThroughput;
                 l2AState.lastQuality = quality;
@@ -447,7 +447,7 @@ function L2ARule(config) {
             default:
                 // should not arrive here, try to recover
                 logger.debug('L2A ABR rule invoked in bad state.');
-                switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, latency);
+                switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, safeThroughput, streamInfo.id, latency);
                 switchRequest.reason.state = l2AState.state;
                 switchRequest.reason.throughput = safeThroughput;
                 switchRequest.reason.latency = latency;
diff --git a/src/streaming/rules/abr/ThroughputRule.js b/src/streaming/rules/abr/ThroughputRule.js
index 1ee877708b..5bc5c9ff14 100644
--- a/src/streaming/rules/abr/ThroughputRule.js
+++ b/src/streaming/rules/abr/ThroughputRule.js
@@ -69,6 +69,7 @@ function ThroughputRule(config) {
         const scheduleController = rulesContext.getScheduleController();
         const abrController = rulesContext.getAbrController();
         const streamInfo = rulesContext.getStreamInfo();
+        const streamId = streamInfo ? streamInfo.id : null;
         const isDynamic = streamInfo && streamInfo.manifestInfo ? streamInfo.manifestInfo.isDynamic : null;
         const throughputHistory = abrController.getThroughputHistory();
         const throughput = throughputHistory.getSafeAverageThroughput(mediaType, isDynamic);
@@ -80,9 +81,9 @@ function ThroughputRule(config) {
             return switchRequest;
         }
 
-        if (abrController.getAbandonmentStateFor(mediaType) !== MetricsConstants.ABANDON_LOAD) {
+        if (abrController.getAbandonmentStateFor(streamId, mediaType) !== MetricsConstants.ABANDON_LOAD) {
             if (currentBufferState.state === MetricsConstants.BUFFER_LOADED || isDynamic) {
-                switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, throughput, latency);
+                switchRequest.quality = abrController.getQualityForBitrate(mediaInfo, throughput, streamId, latency);
                 scheduleController.setTimeToLoadDelay(0);
                 logger.debug('[' + mediaType + '] requesting switch to index: ', switchRequest.quality, 'Average throughput', Math.round(throughput), 'kbps');
                 switchRequest.reason = {throughput: throughput, latency: latency};
diff --git a/src/streaming/rules/abr/lolp/LoLpRule.js b/src/streaming/rules/abr/lolp/LoLpRule.js
index 90f9a9893e..282bc842ec 100644
--- a/src/streaming/rules/abr/lolp/LoLpRule.js
+++ b/src/streaming/rules/abr/lolp/LoLpRule.js
@@ -72,7 +72,7 @@ function LoLPRule(config) {
             let mediaType = rulesContext.getMediaInfo().type;
             let abrController = rulesContext.getAbrController();
             const streamInfo = rulesContext.getStreamInfo();
-            let currentQuality = abrController.getQualityFor(mediaType, streamInfo);
+            let currentQuality = abrController.getQualityFor(mediaType, streamInfo.id);
             const mediaInfo = rulesContext.getMediaInfo();
             const bufferStateVO = dashMetrics.getCurrentBufferState(mediaType);
             const scheduleController = rulesContext.getScheduleController();
@@ -98,7 +98,7 @@ function LoLPRule(config) {
                 return switchRequest;
             }
 
-            if (abrController.getAbandonmentStateFor(mediaType) === MetricsConstants.ABANDON_LOAD) {
+            if (abrController.getAbandonmentStateFor(streamInfo.id, mediaType) === MetricsConstants.ABANDON_LOAD) {
                 return switchRequest;
             }
 
diff --git a/src/streaming/rules/scheduling/BufferLevelRule.js b/src/streaming/rules/scheduling/BufferLevelRule.js
index 5cb6c7add1..21b3ed6b60 100644
--- a/src/streaming/rules/scheduling/BufferLevelRule.js
+++ b/src/streaming/rules/scheduling/BufferLevelRule.js
@@ -74,16 +74,20 @@ function BufferLevelRule(config) {
             }
         }  else if (type === Constants.AUDIO && hasVideoTrack) {
             const videoBufferLevel = dashMetrics.getCurrentBufferLevel(Constants.VIDEO);
+            // For multiperiod we need to consider that audio and video segments might have different durations.
+            // This can lead to scenarios in which we completely buffered the video segments and the video buffer level for the current period is not changing anymore. However we might still need a small audio segment to finish buffering audio as well.
+            // If we set the buffer time of audio equal to the video buffer time scheduling for the remaining audio segment will only be triggered when audio fragmentDuration > videoBufferLevel. That will delay preloading of the upcoming period.
+            // Should find a better solution than just adding 1
             if (isNaN(representationInfo.fragmentDuration)) {
-                bufferTarget = videoBufferLevel;
+                bufferTarget = videoBufferLevel + 1;
             } else {
-                bufferTarget = Math.max(videoBufferLevel, representationInfo.fragmentDuration);
+                bufferTarget = Math.max(videoBufferLevel + 1, representationInfo.fragmentDuration);
             }
         } else {
             const streamInfo = representationInfo.mediaInfo.streamInfo;
             if (abrController.isPlayingAtTopQuality(streamInfo)) {
-                const isLongFormContent = streamInfo.manifestInfo.duration >= settings.get().streaming.longFormContentDurationThreshold;
-                bufferTarget = isLongFormContent ? settings.get().streaming.bufferTimeAtTopQualityLongForm : settings.get().streaming.bufferTimeAtTopQuality;
+                const isLongFormContent = streamInfo.manifestInfo.duration >= settings.get().streaming.buffer.longFormContentDurationThreshold;
+                bufferTarget = isLongFormContent ? settings.get().streaming.buffer.bufferTimeAtTopQualityLongForm : settings.get().streaming.buffer.bufferTimeAtTopQuality;
             } else {
                 bufferTarget = mediaPlayerModel.getStableBufferTime();
             }
diff --git a/src/streaming/text/NotFragmentedTextBufferController.js b/src/streaming/text/NotFragmentedTextBufferController.js
index d43b627bf4..8c6323173d 100644
--- a/src/streaming/text/NotFragmentedTextBufferController.js
+++ b/src/streaming/text/NotFragmentedTextBufferController.js
@@ -28,35 +28,33 @@
  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  *  POSSIBILITY OF SUCH DAMAGE.
  */
-import Constants from '../constants/Constants';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
 import FactoryMaker from '../../core/FactoryMaker';
 import InitCache from '../utils/InitCache';
 import SourceBufferSink from '../SourceBufferSink';
-import TextController from '../../streaming/text/TextController';
 import DashJSError from '../../streaming/vo/DashJSError';
 import Errors from '../../core/errors/Errors';
 
 const BUFFER_CONTROLLER_TYPE = 'NotFragmentedTextBufferController';
+
 function NotFragmentedTextBufferController(config) {
 
     config = config || {};
     const context = this.context;
     const eventBus = EventBus(context).getInstance();
-    const textController = TextController(context).getInstance();
 
+    const textController = config.textController;
     const errHandler = config.errHandler;
     const streamInfo = config.streamInfo;
     const type = config.type;
-    const mimeType = config.mimeType;
-    const fragmentModel = config.fragmentModel;
+    const settings = config.settings;
 
     let instance,
         isBufferingCompleted,
         initialized,
         mediaSource,
-        buffer,
+        sourceBufferSink,
         initCache;
 
     function setup() {
@@ -64,8 +62,9 @@ function NotFragmentedTextBufferController(config) {
         mediaSource = null;
         isBufferingCompleted = false;
 
-        eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance);
-        eventBus.on(Events.INIT_FRAGMENT_LOADED, onInitFragmentLoaded, instance);
+        initCache = InitCache(context).getInstance();
+
+        eventBus.on(Events.INIT_FRAGMENT_LOADED, _onInitFragmentLoaded, instance);
     }
 
     function getBufferControllerType() {
@@ -74,32 +73,26 @@ function NotFragmentedTextBufferController(config) {
 
     function initialize(source) {
         setMediaSource(source);
-        initCache = InitCache(context).getInstance();
     }
 
-    function createBuffer(mediaInfoArr) {
-        const mediaInfo = mediaInfoArr[0];
-        try {
-            buffer = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            if (!initialized) {
-                const textBuffer = buffer.getBuffer();
-                if (textBuffer.hasOwnProperty(Constants.INITIALIZE)) {
-                    textBuffer.initialize(mimeType, streamInfo, mediaInfoArr, fragmentModel);
-                }
-                initialized = true;
-            }
-            return buffer;
-        } catch (e) {
-            if (mediaInfo && ((mediaInfo.isText) || (mediaInfo.codec.indexOf('codecs="stpp') !== -1) || (mediaInfo.codec.indexOf('codecs="wvtt') !== -1))) {
-                try {
-                    buffer = textController.getTextSourceBuffer();
-                } catch (e) {
-                    errHandler.error(new DashJSError(Errors.MEDIASOURCE_TYPE_UNSUPPORTED_CODE, Errors.MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE + type + ' : ' + e.message));
+    function createBufferSink(mediaInfo) {
+        return new Promise((resolve, reject) => {
+            try {
+                sourceBufferSink = SourceBufferSink(context).create({ mediaSource, textController });
+                sourceBufferSink.initializeForFirstUse(streamInfo, mediaInfo);
+                if (!initialized) {
+                    if (sourceBufferSink.getBuffer() && typeof sourceBufferSink.getBuffer().initialize === 'function') {
+                        sourceBufferSink.getBuffer().initialize();
+                    }
+                    initialized = true;
                 }
-            } else {
+                resolve(sourceBufferSink);
+            } catch (e) {
                 errHandler.error(new DashJSError(Errors.MEDIASOURCE_TYPE_UNSUPPORTED_CODE, Errors.MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE + type));
+                reject(e);
             }
-        }
+        });
+
     }
 
     function getStreamId() {
@@ -111,7 +104,7 @@ function NotFragmentedTextBufferController(config) {
     }
 
     function getBuffer() {
-        return buffer;
+        return sourceBufferSink;
     }
 
     function setMediaSource(value) {
@@ -126,9 +119,6 @@ function NotFragmentedTextBufferController(config) {
         return false;
     }
 
-    function dischargePreBuffer() {
-    }
-
     function getBufferLevel() {
         return 0;
     }
@@ -137,78 +127,115 @@ function NotFragmentedTextBufferController(config) {
         return isBufferingCompleted;
     }
 
-    function reset(errored) {
-        eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance);
-        eventBus.off(Events.INIT_FRAGMENT_LOADED, onInitFragmentLoaded, instance);
-
-        if (!errored && buffer) {
-            buffer.abort();
-            buffer.reset();
-            buffer = null;
+    function setIsBufferingCompleted(value) {
+        if (isBufferingCompleted === value) {
+            return;
         }
-    }
 
-    function onDataUpdateCompleted(e) {
-        if (initCache.extract(streamInfo.id, e.currentRepresentation.id) !== null) {
-            return;
+        isBufferingCompleted = value;
+
+        if (isBufferingCompleted) {
+            triggerEvent(Events.BUFFERING_COMPLETED);
         }
+    }
 
-        // Representation has changed, clear buffer
-        isBufferingCompleted = false;
+    function reset(errored) {
+        eventBus.off(Events.INIT_FRAGMENT_LOADED, _onInitFragmentLoaded, instance);
 
-        // // Text data file is contained in initialization segment
-        eventBus.trigger(Events.INIT_FRAGMENT_NEEDED,
-            { representationId: e.currentRepresentation.id, sender: instance },
-            { streamId: streamInfo.id, mediaType: type }
-        );
+        if (!errored && sourceBufferSink) {
+            sourceBufferSink.abort();
+            sourceBufferSink.reset();
+            sourceBufferSink = null;
+        }
     }
 
-    function appendInitSegment(representationId) {
+    function appendInitSegmentFromCache(representationId) {
         // If text data file already in cache then no need to append it again
         return initCache.extract(streamInfo.id, representationId) !== null;
     }
 
-    function onInitFragmentLoaded(e) {
-        if (!e.chunk.bytes) return;
+    function _onInitFragmentLoaded(e) {
+        if (!e.chunk.bytes || isBufferingCompleted) return;
 
-        initCache.save(e.chunk);
-        buffer.append(e.chunk);
-
-        isBufferingCompleted = true;
+        if (settings.get().streaming.cacheInitSegments) {
+            initCache.save(e.chunk);
+        }
+        sourceBufferSink.append(e.chunk);
 
-        eventBus.trigger(Events.STREAM_COMPLETED,
-            { request: e.request },
-            { streamId: streamInfo.id, mediaType: type }
-        );
+        setIsBufferingCompleted(true);
     }
 
     function getRangeAt() {
         return null;
     }
 
-    function updateTimestampOffset(MSETimeOffset) {
-        if (buffer.timestampOffset !== MSETimeOffset && !isNaN(MSETimeOffset)) {
-            buffer.timestampOffset = MSETimeOffset;
-        }
+    function getAllRangesWithSafetyFactor() {
+        return [];
+    }
+
+    function getContinuousBufferTimeForTargetTime() {
+        return Number.POSITIVE_INFINITY;
+    }
+
+    function clearBuffers() {
+        return Promise.resolve();
+    }
+
+    function updateBufferTimestampOffset() {
+        return Promise.resolve();
+    }
+
+    function prepareForPlaybackSeek() {
+        return Promise.resolve();
+    }
+
+    function prepareForReplacementTrackSwitch() {
+        isBufferingCompleted = false;
+        return Promise.resolve();
+    }
+
+    function updateAppendWindow() {
+        return Promise.resolve();
+    }
+
+    function setSeekTarget() {
+
+    }
+
+    function pruneAllSafely() {
+        return Promise.resolve();
+    }
+
+    function triggerEvent(eventType, data) {
+        let payload = data || {};
+        eventBus.trigger(eventType, payload, { streamId: streamInfo.id, mediaType: type });
     }
 
     instance = {
-        getBufferControllerType: getBufferControllerType,
-        initialize: initialize,
-        createBuffer: createBuffer,
-        getStreamId: getStreamId,
-        getType: getType,
-        getBuffer: getBuffer,
-        getBufferLevel: getBufferLevel,
-        setMediaSource: setMediaSource,
-        getMediaSource: getMediaSource,
-        getIsBufferingCompleted: getIsBufferingCompleted,
-        getIsPruningInProgress: getIsPruningInProgress,
-        dischargePreBuffer: dischargePreBuffer,
-        appendInitSegment: appendInitSegment,
-        getRangeAt: getRangeAt,
-        reset: reset,
-        updateTimestampOffset: updateTimestampOffset
+        initialize,
+        getStreamId,
+        getType,
+        getBufferControllerType,
+        createBufferSink,
+        getBuffer,
+        getBufferLevel,
+        getRangeAt,
+        getAllRangesWithSafetyFactor,
+        getContinuousBufferTimeForTargetTime,
+        setMediaSource,
+        getMediaSource,
+        appendInitSegmentFromCache,
+        getIsBufferingCompleted,
+        setIsBufferingCompleted,
+        getIsPruningInProgress,
+        reset,
+        clearBuffers,
+        prepareForPlaybackSeek,
+        prepareForReplacementTrackSwitch,
+        setSeekTarget,
+        updateAppendWindow,
+        pruneAllSafely,
+        updateBufferTimestampOffset
     };
 
     setup();
diff --git a/src/streaming/text/TextBufferController.js b/src/streaming/text/TextBufferController.js
deleted file mode 100644
index 6a806c2d8f..0000000000
--- a/src/streaming/text/TextBufferController.js
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * The copyright in this software is being made available under the BSD License,
- * included below. This software may be subject to other third party and contributor
- * rights, including patent rights, and no such rights are granted under this license.
- *
- * Copyright (c) 2013, Dash Industry Forum.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *  * Redistributions of source code must retain the above copyright notice, this
- *  list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright notice,
- *  this list of conditions and the following disclaimer in the documentation and/or
- *  other materials provided with the distribution.
- *  * Neither the name of Dash Industry Forum nor the names of its
- *  contributors may be used to endorse or promote products derived from this software
- *  without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
- *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- *  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- */
-import Constants from '../constants/Constants';
-import FactoryMaker from '../../core/FactoryMaker';
-import BufferController from './../controllers/BufferController';
-import NotFragmentedTextBufferController from './NotFragmentedTextBufferController';
-
-function TextBufferController(config) {
-
-    config = config || {};
-    let context = this.context;
-
-    let _BufferControllerImpl,
-        instance;
-
-    function setup() {
-
-        // according to text type, we create corresponding buffer controller
-        if (config.type === Constants.FRAGMENTED_TEXT) {
-
-            // in this case, internal buffer ocntroller is a classical BufferController object
-            _BufferControllerImpl = BufferController(context).create({
-                streamInfo: config.streamInfo,
-                type: config.type,
-                mediaPlayerModel: config.mediaPlayerModel,
-                manifestModel: config.manifestModel,
-                fragmentModel: config.fragmentModel,
-                errHandler: config.errHandler,
-                mediaController: config.mediaController,
-                representationController: config.representationController,
-                adapter: config.adapter,
-                textController: config.textController,
-                abrController: config.abrController,
-                playbackController: config.playbackController,
-                settings: config.settings
-            });
-        } else {
-
-            // in this case, internal buffer controller is a not fragmented text controller object
-            _BufferControllerImpl = NotFragmentedTextBufferController(context).create({
-                streamInfo: config.streamInfo,
-                type: config.type,
-                mimeType: config.mimeType,
-                fragmentModel: config.fragmentModel,
-                errHandler: config.errHandler
-            });
-        }
-    }
-
-    function getBufferControllerType() {
-        return _BufferControllerImpl.getBufferControllerType();
-    }
-
-    function initialize(source, StreamProcessor) {
-        return _BufferControllerImpl.initialize(source, StreamProcessor);
-    }
-
-    function createBuffer(mediaInfoArr, previousBuffers) {
-        return _BufferControllerImpl.createBuffer(mediaInfoArr, previousBuffers);
-    }
-
-    function getType() {
-        return _BufferControllerImpl.getType();
-    }
-
-    function getBuffer() {
-        return _BufferControllerImpl.getBuffer();
-    }
-
-    function setBuffer(value) {
-        _BufferControllerImpl.setBuffer(value);
-    }
-
-    function getMediaSource() {
-        return _BufferControllerImpl.getMediaSource();
-    }
-
-    function setMediaSource(value) {
-        _BufferControllerImpl.setMediaSource(value);
-    }
-
-    function getBufferLevel() {
-        return _BufferControllerImpl.getBufferLevel();
-    }
-
-    function reset(errored) {
-        _BufferControllerImpl.reset(errored);
-    }
-
-    function getIsBufferingCompleted() {
-        return _BufferControllerImpl.getIsBufferingCompleted();
-    }
-
-    function appendInitSegment(representationId) {
-        _BufferControllerImpl.appendInitSegment(representationId);
-    }
-
-    function getIsPruningInProgress() {
-        return _BufferControllerImpl.getIsPruningInProgress();
-    }
-
-    function dischargePreBuffer() {
-        return _BufferControllerImpl.dischargePreBuffer();
-    }
-
-    function getRangeAt(time) {
-        return _BufferControllerImpl.getRangeAt(time);
-    }
-
-    function updateTimestampOffset(MSETimeOffset) {
-        const buffer = getBuffer();
-        if (buffer.timestampOffset !== MSETimeOffset && !isNaN(MSETimeOffset)) {
-            buffer.timestampOffset = MSETimeOffset;
-        }
-    }
-
-    function updateAppendWindow() {
-        _BufferControllerImpl.updateAppendWindow();
-    }
-
-    function getRepresentationInfo(quality) {
-        return _BufferControllerImpl.getRepresentationInfo(quality);
-    }
-
-    instance = {
-        getBufferControllerType: getBufferControllerType,
-        initialize: initialize,
-        createBuffer: createBuffer,
-        getType: getType,
-        getBuffer: getBuffer,
-        setBuffer: setBuffer,
-        getBufferLevel: getBufferLevel,
-        setMediaSource: setMediaSource,
-        getMediaSource: getMediaSource,
-        getIsBufferingCompleted: getIsBufferingCompleted,
-        getIsPruningInProgress: getIsPruningInProgress,
-        dischargePreBuffer: dischargePreBuffer,
-        appendInitSegment: appendInitSegment,
-        getRangeAt: getRangeAt,
-        reset: reset,
-        updateTimestampOffset: updateTimestampOffset,
-        updateAppendWindow,
-        getRepresentationInfo
-    };
-
-    setup();
-
-    return instance;
-}
-
-TextBufferController.__dashjs_factory_name = 'TextBufferController';
-export default FactoryMaker.getClassFactory(TextBufferController);
diff --git a/src/streaming/text/TextController.js b/src/streaming/text/TextController.js
index 544f9be95b..2fc0dbd33d 100644
--- a/src/streaming/text/TextController.js
+++ b/src/streaming/text/TextController.js
@@ -36,151 +36,129 @@ import VTTParser from '../utils/VTTParser';
 import TTMLParser from '../utils/TTMLParser';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
-import { checkParameterType } from '../utils/SupervisorTools';
+import MediaPlayerEvents from '../../streaming/MediaPlayerEvents';
+import {checkParameterType} from '../utils/SupervisorTools';
 
-function TextController() {
+function TextController(config) {
 
     let context = this.context;
 
+    const adapter = config.adapter;
+    const errHandler = config.errHandler;
+    const manifestModel = config.manifestModel;
+    const mediaController = config.mediaController;
+    const videoModel = config.videoModel;
+    const settings = config.settings;
+
     let instance,
-        textSourceBuffer,
-        errHandler,
-        adapter,
-        manifestModel,
-        mediaController,
-        videoModel,
-        streamController,
+        streamData,
+        textSourceBuffers,
         textTracks,
         vttParser,
         ttmlParser,
         eventBus,
         defaultSettings,
         initialSettingsSet,
-        lastEnabledIndex,
-        textDefaultEnabled, // this is used for default settings (each time a file is loaded, we check value of this settings )
-        allTracksAreDisabled, // this is used for one session (when a file has been loaded, we use this settings to enable/disable text)
+        allTracksAreDisabled,
         forceTextStreaming,
         textTracksAdded,
-        disableTextBeforeTextTracksAdded,
-        previousPeriodSelectedTrack;
+        disableTextBeforeTextTracksAdded;
 
     function setup() {
-
         defaultSettings = null;
-        lastEnabledIndex = -1;
         forceTextStreaming = false;
         textTracksAdded = false;
         initialSettingsSet = false;
         disableTextBeforeTextTracksAdded = false;
-        textTracks = TextTracks(context).getInstance();
+
         vttParser = VTTParser(context).getInstance();
         ttmlParser = TTMLParser(context).getInstance();
-        textSourceBuffer = TextSourceBuffer(context).getInstance();
         eventBus = EventBus(context).getInstance();
 
-        textTracks.initialize();
-        eventBus.on(Events.TEXT_TRACKS_QUEUE_INITIALIZED, onTextTracksAdded, instance);
-        eventBus.on(Events.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, instance);
-
-        /*
-        * register those event callbacks in order to detect switch of periods and set
-        * correctly the selected track index in the new period.
-        * there is different cases :
-        *   - switch occurs after a seek command from the user
-        *   - switch occurs but codecs in streams are different
-        *   - switch occurs and codecs in streams are not different
-        */
-        eventBus.on(Events.PERIOD_SWITCH_STARTED, onPeriodSwitchStarted, instance);
-        eventBus.on(Events.STREAM_COMPLETED, onStreamCompleted, instance);
-        eventBus.on(Events.PERIOD_SWITCH_COMPLETED, onPeriodSwitchCompleted, instance);
-
         resetInitialSettings();
     }
 
-    function onPeriodSwitchStarted(e) {
-        if (previousPeriodSelectedTrack === undefined && e.fromStreamInfo !== null /* test if this is the first period */) {
-            previousPeriodSelectedTrack = this.getCurrentTrackIdx();
-        }
+    function initialize() {
+        eventBus.on(Events.CURRENT_TRACK_CHANGED, _onCurrentTrackChanged, instance);
+        eventBus.on(Events.TEXT_TRACKS_QUEUE_INITIALIZED, _onTextTracksAdded, instance);
     }
 
-    function onStreamCompleted() {
-        if (previousPeriodSelectedTrack === undefined) {
-            previousPeriodSelectedTrack = this.getCurrentTrackIdx();
-        }
+    function initializeForStream(streamInfo) {
+        const streamId = streamInfo.id;
+        const tracks = TextTracks(context).create({
+            videoModel,
+            streamInfo
+        });
+        tracks.initialize();
+        textTracks[streamId] = tracks;
+
+        const textSourceBuffer = TextSourceBuffer(context).create({
+            errHandler,
+            adapter,
+            manifestModel,
+            mediaController,
+            videoModel,
+            textTracks: tracks,
+            vttParser,
+            ttmlParser,
+            streamInfo
+        });
+        textSourceBuffer.initialize();
+        textSourceBuffers[streamId] = textSourceBuffer;
+
+        streamData[streamId] = {};
+        streamData[streamId].lastEnabledIndex = -1;
     }
 
-    function onPeriodSwitchCompleted() {
-        if (previousPeriodSelectedTrack !== undefined) {
-            this.setTextTrack(previousPeriodSelectedTrack);
-            previousPeriodSelectedTrack = undefined;
+    /**
+     * All media infos have been added. Start creating the track objects
+     * @param {object} streamInfo
+     */
+    function createTracks(streamInfo) {
+        const streamId = streamInfo.id;
+
+        if (!textTracks[streamId]) {
+            return;
         }
+        textTracks[streamId].createTracks();
     }
 
-    function setConfig(config) {
-        if (!config) {
+    /**
+     * Adds the new mediaInfo objects to the textSourceBuffer.
+     * @param {object} streamInfo
+     * @param {array} mInfos
+     * @param {string|null} mimeType
+     * @param {object} fragmentModel
+     */
+    function addMediaInfosToBuffer(streamInfo, mInfos, mimeType = null, fragmentModel = null) {
+        const streamId = streamInfo.id;
+
+        if (!textSourceBuffers[streamId]) {
             return;
         }
-        if (config.errHandler) {
-            errHandler = config.errHandler;
-        }
-        if (config.adapter) {
-            adapter = config.adapter;
-        }
-        if (config.manifestModel) {
-            manifestModel = config.manifestModel;
-        }
-        if (config.mediaController) {
-            mediaController = config.mediaController;
-        }
-        if (config.videoModel) {
-            videoModel = config.videoModel;
-        }
-        if (config.streamController) {
-            streamController = config.streamController;
-        }
-        if (config.textTracks) {
-            textTracks = config.textTracks;
-        }
-        if (config.vttParser) {
-            vttParser = config.vttParser;
-        }
-        if (config.ttmlParser) {
-            ttmlParser = config.ttmlParser;
-        }
-
-        // create config for source buffer
-        textSourceBuffer.setConfig({
-            errHandler: errHandler,
-            adapter: adapter,
-            manifestModel: manifestModel,
-            mediaController: mediaController,
-            videoModel: videoModel,
-            streamController: streamController,
-            textTracks: textTracks,
-            vttParser: vttParser,
-            ttmlParser: ttmlParser
-        });
+        textSourceBuffers[streamId].addMediaInfos(mInfos, mimeType, fragmentModel);
     }
 
-    function getTextSourceBuffer() {
-        return textSourceBuffer;
+    function getTextSourceBuffer(streamInfo) {
+        const streamId = streamInfo.id;
+
+        if (textSourceBuffers && textSourceBuffers[streamId]) {
+            return textSourceBuffers[streamId];
+        }
     }
 
     function getAllTracksAreDisabled() {
         return allTracksAreDisabled;
     }
 
-    function addEmbeddedTrack(mediaInfo) {
-        textSourceBuffer.addEmbeddedTrack(mediaInfo);
-    }
+    function addEmbeddedTrack(streamInfo, mediaInfo) {
+        const streamId = streamInfo.id;
 
-    function setTextDefaultLanguage(lang) {
-        checkParameterType(lang, 'string');
-        if (!defaultSettings) {
-            defaultSettings = {};
+        if (!textSourceBuffers[streamId]) {
+            return;
         }
-        defaultSettings.lang = lang;
-        initialSettingsSet = true;
+
+        textSourceBuffers[streamId].addEmbeddedTrack(mediaInfo);
     }
 
     function setInitialSettings(settings) {
@@ -188,40 +166,43 @@ function TextController() {
         initialSettingsSet = true;
     }
 
-    function getTextDefaultLanguage() {
-        return defaultSettings && defaultSettings.lang || '';
-    }
-
-    function onTextTracksAdded(e) {
+    function _onTextTracksAdded(e) {
         let tracks = e.tracks;
         let index = e.index;
+        const streamId = e.streamId;
 
-        if (defaultSettings) {
-            tracks.some((item, idx) => {
-                // matchSettings is compatible with setTextDefaultLanguage and setInitialSettings
-                if (mediaController.matchSettings(defaultSettings, item)) {
-                    this.setTextTrack(idx);
-                    index = idx;
-                    return true;
-                }
-            });
-        }
+        const textDefaultEnabled = settings.get().streaming.text.defaultEnabled;
 
-        if (textDefaultEnabled === false || ( textDefaultEnabled === undefined && !defaultSettings ) || disableTextBeforeTextTracksAdded) {
-            // disable text at startup if explicitely configured with setTextDefaultEnabled(false) or if there is no defaultSettings (configuration or from domStorage)
-            this.setTextTrack(-1);
+        if ((textDefaultEnabled === false && !isTextEnabled()) || disableTextBeforeTextTracksAdded) {
+            // disable text at startup if explicitly configured with setTextDefaultEnabled(false) or if there is no defaultSettings (configuration or from domStorage)
+            setTextTrack(streamId, -1);
+        } else {
+            if (defaultSettings) {
+                tracks.some((item, idx) => {
+                    // matchSettings is compatible with setTextDefaultLanguage and setInitialSettings
+                    if (mediaController.matchSettings(defaultSettings, item)) {
+                        setTextTrack(streamId, idx);
+                        index = idx;
+                        return true;
+                    }
+                });
+            }
+            allTracksAreDisabled = false;
         }
 
-        lastEnabledIndex = index;
-        eventBus.trigger(Events.TEXT_TRACKS_ADDED, {
+        streamData[streamId].lastEnabledIndex = index;
+
+        eventBus.trigger(MediaPlayerEvents.TEXT_TRACKS_ADDED, {
             enabled: isTextEnabled(),
             index: index,
-            tracks: tracks
+            tracks: tracks,
+            streamId
         });
+
         textTracksAdded = true;
     }
 
-    function onCurrentTrackChanged(event) {
+    function _onCurrentTrackChanged(event) {
         if (!initialSettingsSet && event && event.newMediaInfo) {
             let mediaInfo = event.newMediaInfo;
             if (mediaInfo.type === Constants.FRAGMENTED_TEXT) {
@@ -234,41 +215,22 @@ function TextController() {
         }
     }
 
-    function setTextDefaultEnabled(enable) {
-        checkParameterType(enable,'boolean');
-        textDefaultEnabled = enable;
-
-        if (!textDefaultEnabled) {
-            // disable text at startup
-            this.setTextTrack(-1);
-        } else {
-            allTracksAreDisabled = false;
-        }
-    }
-
-    function getTextDefaultEnabled() {
-        return textDefaultEnabled === undefined ? false : textDefaultEnabled;
-    }
-
-    function enableText(enable) {
-        checkParameterType(enable,'boolean');
-        if (!textDefaultEnabled && enable) {
-            textDefaultEnabled = true;
-        }
+    function enableText(streamId, enable) {
+        checkParameterType(enable, 'boolean');
         if (isTextEnabled() !== enable) {
             // change track selection
             if (enable) {
                 // apply last enabled track
-                this.setTextTrack(lastEnabledIndex);
+                setTextTrack(streamId, streamData[streamId].lastEnabledIndex);
             }
 
             if (!enable) {
                 // keep last index and disable text track
-                lastEnabledIndex = this.getCurrentTrackIdx();
+                streamData[streamId].lastEnabledIndex = getCurrentTrackIdx(streamId);
                 if (!textTracksAdded) {
                     disableTextBeforeTextTracksAdded = true;
                 } else {
-                    this.setTextTrack(-1);
+                    setTextTrack(streamId, -1);
                 }
             }
         }
@@ -284,89 +246,103 @@ function TextController() {
 
     // when set to true ScheduleController will allow schedule of chunks even if tracks are all disabled. Allowing streaming to hidden track for external players to work with.
     function enableForcedTextStreaming(enable) {
-        checkParameterType(enable,'boolean');
+        checkParameterType(enable, 'boolean');
         forceTextStreaming = enable;
     }
 
-    function setTextTrack(idx) {
+    function setTextTrack(streamId, idx) {
         //For external time text file, the only action needed to change a track is marking the track mode to showing.
         // Fragmented text tracks need the additional step of calling TextController.setTextTrack();
-        let config = textSourceBuffer.getConfig();
-        let fragmentModel = config.fragmentModel;
-        let fragmentedTracks = config.fragmentedTracks;
-        let videoModel = config.videoModel;
-        let mediaInfosArr,
-            streamProcessor;
+        allTracksAreDisabled = idx === -1;
 
-        allTracksAreDisabled = idx === -1 ? true : false;
+        if (allTracksAreDisabled && mediaController) {
+            mediaController.saveTextSettingsDisabled();
+        }
 
-        let oldTrackIdx = textTracks.getCurrentTrackIdx();
-        if (oldTrackIdx !== idx) {
-            if (allTracksAreDisabled && mediaController) {
-                mediaController.saveTextSettingsDisabled();
-            }
-            textTracks.setModeForTrackIdx(oldTrackIdx, Constants.TEXT_HIDDEN);
-            textTracks.setCurrentTrackIdx(idx);
-            textTracks.setModeForTrackIdx(idx, Constants.TEXT_SHOWING);
-
-            let currentTrackInfo = textTracks.getCurrentTrackInfo();
-
-            if (currentTrackInfo && currentTrackInfo.isFragmented && !currentTrackInfo.isEmbedded) {
-                for (let i = 0; i < fragmentedTracks.length; i++) {
-                    let mediaInfo = fragmentedTracks[i];
-                    if (currentTrackInfo.lang === mediaInfo.lang && currentTrackInfo.index === mediaInfo.index &&
-                        (mediaInfo.id ? currentTrackInfo.id === mediaInfo.id : currentTrackInfo.id === mediaInfo.index)) {
-                        let currentFragTrack = mediaController.getCurrentTrackFor(Constants.FRAGMENTED_TEXT, streamController.getActiveStreamInfo());
-                        if (mediaInfo !== currentFragTrack) {
-                            fragmentModel.abortRequests();
-                            fragmentModel.removeExecutedRequestsBeforeTime();
-                            textSourceBuffer.remove();
-                            textTracks.deleteCuesFromTrackIdx(oldTrackIdx);
-                            mediaController.setTrack(mediaInfo);
-                            textSourceBuffer.setCurrentFragmentedTrackIdx(i);
-                        } else if (oldTrackIdx === -1) {
-                            //in fragmented use case, if the user selects the older track (the one selected before disabled text track)
-                            //no CURRENT_TRACK_CHANGED event will be trigger, so dashHandler current time has to be updated and the scheduleController
-                            //has to be restarted.
-                            const streamProcessors = streamController.getActiveStreamProcessors();
-                            for (let i = 0; i < streamProcessors.length; i++) {
-                                if (streamProcessors[i].getType() === Constants.FRAGMENTED_TEXT) {
-                                    streamProcessor = streamProcessors[i];
-                                    break;
-                                }
-                            }
-                            streamProcessor.setBufferingTime(videoModel.getTime());
-                            streamProcessor.getScheduleController().start();
-                        }
-                    }
-                }
-            } else if (currentTrackInfo && !currentTrackInfo.isFragmented) {
-                const streamProcessors = streamController.getActiveStreamProcessors();
-                for (let i = 0; i < streamProcessors.length; i++) {
-                    if (streamProcessors[i].getType() === Constants.TEXT) {
-                        streamProcessor = streamProcessors[i];
-                        mediaInfosArr = streamProcessor.getMediaInfoArr();
-                        break;
-                    }
-                }
+        let oldTrackIdx = getCurrentTrackIdx(streamId);
 
-                if (streamProcessor && mediaInfosArr) {
-                    for (let i = 0; i < mediaInfosArr.length; i++) {
-                        if (mediaInfosArr[i].index === currentTrackInfo.index && mediaInfosArr[i].lang === currentTrackInfo.lang) {
-                            streamProcessor.selectMediaInfo(mediaInfosArr[i]);
-                            break;
-                        }
-                    }
+        // No change, no action required
+        if (oldTrackIdx === idx || !textTracks[streamId]) {
+            return;
+        }
+
+        textTracks[streamId].setModeForTrackIdx(oldTrackIdx, Constants.TEXT_HIDDEN);
+        textTracks[streamId].setCurrentTrackIdx(idx);
+        textTracks[streamId].setModeForTrackIdx(idx, Constants.TEXT_SHOWING);
+
+        let currentTrackInfo = textTracks[streamId].getCurrentTrackInfo();
+
+        if (currentTrackInfo && currentTrackInfo.isFragmented && !currentTrackInfo.isEmbedded) {
+            _setFragmentedTextTrack(streamId, currentTrackInfo, oldTrackIdx);
+        } else if (currentTrackInfo && !currentTrackInfo.isFragmented) {
+            _setNonFragmentedTextTrack(streamId, currentTrackInfo);
+        }
+    }
+
+    function _setFragmentedTextTrack(streamId, currentTrackInfo, oldTrackIdx) {
+
+        if (!textSourceBuffers[streamId]) {
+            return;
+        }
+
+        let config = textSourceBuffers[streamId].getConfig();
+        let fragmentedTracks = config.fragmentedTracks;
+
+        for (let i = 0; i < fragmentedTracks.length; i++) {
+            let mediaInfo = fragmentedTracks[i];
+            if (currentTrackInfo.lang === mediaInfo.lang && currentTrackInfo.index === mediaInfo.index &&
+                (mediaInfo.id ? currentTrackInfo.id === mediaInfo.id : currentTrackInfo.id === mediaInfo.index)) {
+                let currentFragTrack = mediaController.getCurrentTrackFor(Constants.FRAGMENTED_TEXT, streamId);
+                if (mediaInfo !== currentFragTrack) {
+                    textTracks[streamId].deleteCuesFromTrackIdx(oldTrackIdx);
+                    mediaController.setTrack(mediaInfo);
+                    textSourceBuffers[streamId].setCurrentFragmentedTrackIdx(i);
                 }
+            } else if (oldTrackIdx === -1) {
+                //in fragmented use case, if the user selects the older track (the one selected before disabled text track)
+                //no CURRENT_TRACK_CHANGED event will be triggered because the mediaInfo in the StreamProcessor is equal to the one we are selecting
+                // For that reason we reactivate the StreamProcessor and the ScheduleController
+                eventBus.trigger(Events.SET_FRAGMENTED_TEXT_AFTER_DISABLED, {}, {
+                    streamId,
+                    mediaType: Constants.FRAGMENTED_TEXT
+                });
+
             }
         }
     }
 
-    function getCurrentTrackIdx() {
-        return textTracks.getCurrentTrackIdx();
+    function _setNonFragmentedTextTrack(streamId, currentTrackInfo) {
+        eventBus.trigger(Events.SET_NON_FRAGMENTED_TEXT, {
+            currentTrackInfo
+        }, {
+            streamId,
+            mediaType: Constants.TEXT
+        });
+    }
+
+    function getCurrentTrackIdx(streamId) {
+        return textTracks[streamId].getCurrentTrackIdx();
+    }
+
+    function deactivateStream(streamInfo) {
+        if (!streamInfo) {
+            return;
+        }
+        const streamId = streamInfo.id;
+
+        if (textSourceBuffers[streamId]) {
+            textSourceBuffers[streamId].resetMediaInfos();
+        }
+
+        if (textTracks[streamId]) {
+            textTracks[streamId].deleteAllTextTracks();
+        }
     }
 
     function resetInitialSettings() {
+        textSourceBuffers = {};
+        textTracks = {};
+        streamData = {};
         allTracksAreDisabled = true;
         textTracksAdded = false;
         disableTextBeforeTextTracksAdded = false;
@@ -374,30 +350,35 @@ function TextController() {
 
     function reset() {
         resetInitialSettings();
-        textSourceBuffer.resetEmbedded();
-        textSourceBuffer.reset();
+        eventBus.off(Events.CURRENT_TRACK_CHANGED, _onCurrentTrackChanged, instance);
+        eventBus.off(Events.TEXT_TRACKS_QUEUE_INITIALIZED, _onTextTracksAdded, instance);
+
+        Object.keys(textSourceBuffers).forEach((key) => {
+            textSourceBuffers[key].resetEmbedded();
+            textSourceBuffers[key].reset();
+        });
     }
 
     instance = {
-        setConfig: setConfig,
-        getTextSourceBuffer: getTextSourceBuffer,
-        getAllTracksAreDisabled: getAllTracksAreDisabled,
-        addEmbeddedTrack: addEmbeddedTrack,
-        getTextDefaultLanguage: getTextDefaultLanguage,
-        setTextDefaultLanguage: setTextDefaultLanguage,
-        setTextDefaultEnabled: setTextDefaultEnabled,
-        getTextDefaultEnabled: getTextDefaultEnabled,
-        setInitialSettings: setInitialSettings,
-        enableText: enableText,
-        isTextEnabled: isTextEnabled,
-        setTextTrack: setTextTrack,
-        getCurrentTrackIdx: getCurrentTrackIdx,
-        enableForcedTextStreaming: enableForcedTextStreaming,
-        reset: reset
+        deactivateStream,
+        initialize,
+        initializeForStream,
+        createTracks,
+        getTextSourceBuffer,
+        getAllTracksAreDisabled,
+        addEmbeddedTrack,
+        setInitialSettings,
+        enableText,
+        isTextEnabled,
+        setTextTrack,
+        getCurrentTrackIdx,
+        enableForcedTextStreaming,
+        addMediaInfosToBuffer,
+        reset
     };
     setup();
     return instance;
 }
 
 TextController.__dashjs_factory_name = 'TextController';
-export default FactoryMaker.getSingletonFactory(TextController);
+export default FactoryMaker.getClassFactory(TextController);
diff --git a/src/streaming/text/TextSourceBuffer.js b/src/streaming/text/TextSourceBuffer.js
index e6084d7ab3..e8d727f25a 100644
--- a/src/streaming/text/TextSourceBuffer.js
+++ b/src/streaming/text/TextSourceBuffer.js
@@ -29,13 +29,12 @@
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 import Constants from '../constants/Constants';
-import { HTTPRequest } from '../vo/metrics/HTTPRequest';
+import {HTTPRequest} from '../vo/metrics/HTTPRequest';
 import TextTrackInfo from '../vo/TextTrackInfo';
 import BoxParser from '../utils/BoxParser';
 import CustomTimeRanges from '../utils/CustomTimeRanges';
 import FactoryMaker from '../../core/FactoryMaker';
 import Debug from '../../core/Debug';
-import TextTracks from './TextTracks';
 import EmbeddedTextHtmlRender from './EmbeddedTextHtmlRender';
 import ISOBoxer from 'codem-isoboxer';
 import cea608parser from '../../../externals/cea608-parser';
@@ -44,7 +43,16 @@ import Events from '../../core/events/Events';
 import DashJSError from '../vo/DashJSError';
 import Errors from '../../core/errors/Errors';
 
-function TextSourceBuffer() {
+function TextSourceBuffer(config) {
+    const errHandler = config.errHandler;
+    const adapter = config.adapter;
+    const manifestModel = config.manifestModel;
+    const mediaController = config.mediaController;
+    const videoModel = config.videoModel;
+    const textTracks = config.textTracks;
+    const vttParser = config.vttParser;
+    const ttmlParser = config.ttmlParser;
+    const streamInfo = config.streamInfo;
 
     const context = this.context;
     const eventBus = EventBus(context).getInstance();
@@ -53,38 +61,33 @@ function TextSourceBuffer() {
     let instance,
         logger,
         boxParser,
-        errHandler,
-        adapter,
-        manifestModel,
-        mediaController,
         parser,
-        vttParser,
-        ttmlParser,
         mediaInfos,
-        textTracks,
-        fragmentedFragmentModel,
+        fragmentModel,
         initializationSegmentReceived,
         timescale,
         fragmentedTracks,
-        videoModel,
-        streamController,
         firstFragmentedSubtitleStart,
         currFragmentedTrackIdx,
         embeddedTracks,
         embeddedTimescale,
         embeddedLastSequenceNumber,
         embeddedCea608FieldParsers,
-        embeddedTextHtmlRender,
-        mseTimeOffset;
+        embeddedTextHtmlRender;
 
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
+        boxParser = BoxParser(context).getInstance();
 
         resetInitialSettings();
     }
 
-    function resetFragmented () {
-        fragmentedFragmentModel = null;
+    function getStreamId() {
+        return streamInfo.id;
+    }
+
+    function _resetFragmented() {
+        fragmentModel = null;
         timescale = NaN;
         fragmentedTracks = [];
         firstFragmentedSubtitleStart = null;
@@ -92,39 +95,36 @@ function TextSourceBuffer() {
     }
 
     function resetInitialSettings() {
-        resetFragmented();
+        _resetFragmented();
 
         mediaInfos = [];
         parser = null;
     }
 
-    function initialize(mimeType, streamInfo, mediaInfoArr, fragmentModel) {
-        if (!embeddedInitialized) {
-            initEmbedded();
-        }
-
-        textTracks.setConfig({
-            videoModel: videoModel
-        });
-        textTracks.initialize();
+    function initialize() {
 
-        if (!boxParser) {
-            boxParser = BoxParser(context).getInstance();
+        if (!embeddedInitialized) {
+            _initEmbedded();
         }
 
-        addMediaInfos(mimeType, streamInfo, mediaInfoArr, fragmentModel);
     }
 
-    function addMediaInfos(mimeType, streamInfo, mediaInfoArr, fragmentModel) {
-        const isFragmented = !adapter.getIsTextTrack(mimeType);
+    /**
+     * There might be media infos of different types. For instance text and fragmentedText.
+     * @param {array} mInfos
+     * @param {string} mimeType
+     * @param {object} fModel
+     */
+    function addMediaInfos(mInfos, mimeType, fModel) {
+        const isFragmented = mimeType && !adapter.getIsTextTrack(mimeType);
 
-        mediaInfos = mediaInfos.concat(mediaInfoArr);
+        mediaInfos = mediaInfos.concat(mInfos);
 
         if (isFragmented) {
-            fragmentedFragmentModel = fragmentModel;
+            fragmentModel = fModel;
             instance.buffered = CustomTimeRanges(context).create();
-            fragmentedTracks = mediaController.getTracksFor(Constants.FRAGMENTED_TEXT, streamInfo);
-            const currFragTrack = mediaController.getCurrentTrackFor(Constants.FRAGMENTED_TEXT, streamInfo);
+            fragmentedTracks = mediaController.getTracksFor(Constants.FRAGMENTED_TEXT, streamInfo.id);
+            const currFragTrack = mediaController.getCurrentTrackFor(Constants.FRAGMENTED_TEXT, streamInfo.id);
             for (let i = 0; i < fragmentedTracks.length; i++) {
                 if (fragmentedTracks[i] === currFragTrack) {
                     setCurrentFragmentedTrackIdx(i);
@@ -133,27 +133,47 @@ function TextSourceBuffer() {
             }
         }
 
-        for (let i = 0; i < mediaInfos.length; i++) {
-            createTextTrackFromMediaInfo(null, mediaInfos[i]);
+        for (let i = 0; i < mInfos.length; i++) {
+            _createTextTrackFromMediaInfo(mInfos[i]);
         }
+
+    }
+
+    /**
+     * Create a new track based on the mediaInfo information
+     * @param {object} mediaInfo
+     * @private
+     */
+    function _createTextTrackFromMediaInfo(mediaInfo) {
+        const textTrackInfo = new TextTrackInfo();
+        const trackKindMap = { subtitle: 'subtitles', caption: 'captions' }; //Dash Spec has no "s" on end of KIND but HTML needs plural.
+
+        textTrackInfo.lang = mediaInfo.lang;
+        textTrackInfo.labels = mediaInfo.labels;
+        textTrackInfo.id = mediaInfo.id ? mediaInfo.id : mediaInfo.index; // AdaptationSet id (an unsigned int) as it's optional parameter, use mediaInfo.index
+        textTrackInfo.index = mediaInfo.index; // AdaptationSet index in manifest
+        textTrackInfo.isTTML = _checkTtml(mediaInfo);
+        textTrackInfo.defaultTrack = getIsDefault(mediaInfo);
+        textTrackInfo.isFragmented = !adapter.getIsTextTrack(mediaInfo.mimeType);
+        textTrackInfo.isEmbedded = !!mediaInfo.isEmbedded;
+        textTrackInfo.kind = _getKind(mediaInfo, trackKindMap);
+        textTrackInfo.roles = mediaInfo.roles;
+        textTrackInfo.accessibility = mediaInfo.accessibility;
+
+        textTracks.addTextTrack(textTrackInfo);
     }
 
     function abort() {
-        textTracks.deleteAllTextTracks();
-        resetFragmented();
-        boxParser = null;
-        mediaInfos = [];
     }
 
     function reset() {
         resetInitialSettings();
 
-        streamController = null;
-        videoModel = null;
-        textTracks = null;
+        mediaInfos = [];
+        boxParser = null;
     }
 
-    function onVideoChunkReceived(e) {
+    function _onVideoChunkReceived(e) {
         const chunk = e.chunk;
 
         if (chunk.mediaInfo.embeddedCaptions) {
@@ -161,14 +181,8 @@ function TextSourceBuffer() {
         }
     }
 
-    function initEmbedded() {
+    function _initEmbedded() {
         embeddedTracks = [];
-        textTracks = TextTracks(context).getInstance();
-        textTracks.setConfig({
-            videoModel: videoModel
-        });
-        textTracks.initialize();
-        boxParser = BoxParser(context).getInstance();
         currFragmentedTrackIdx = null;
         embeddedTimescale = 0;
         embeddedCea608FieldParsers = [];
@@ -176,21 +190,13 @@ function TextSourceBuffer() {
         embeddedInitialized = true;
         embeddedTextHtmlRender = EmbeddedTextHtmlRender(context).getInstance();
 
-        const streamProcessors = streamController.getActiveStreamProcessors();
-        for (const i in streamProcessors) {
-            if (streamProcessors[i].getType() === 'video') {
-                mseTimeOffset = streamProcessors[i].getRepresentationInfo().MSETimeOffset;
-                break;
-            }
-        }
-
-        eventBus.on(Events.VIDEO_CHUNK_RECEIVED, onVideoChunkReceived, this);
-        eventBus.on(Events.BUFFER_CLEARED, onVideoBufferCleared, this);
+        eventBus.on(Events.VIDEO_CHUNK_RECEIVED, _onVideoChunkReceived, instance);
+        eventBus.on(Events.BUFFER_CLEARED, onVideoBufferCleared, instance);
     }
 
     function resetEmbedded() {
-        eventBus.off(Events.VIDEO_CHUNK_RECEIVED, onVideoChunkReceived, this);
-        eventBus.off(Events.BUFFER_CLEARED, onVideoBufferCleared, this);
+        eventBus.off(Events.VIDEO_CHUNK_RECEIVED, _onVideoChunkReceived, instance);
+        eventBus.off(Events.BUFFER_CLEARED, onVideoBufferCleared, instance);
         if (textTracks) {
             textTracks.deleteAllTextTracks();
         }
@@ -201,9 +207,11 @@ function TextSourceBuffer() {
     }
 
     function addEmbeddedTrack(mediaInfo) {
+
         if (!embeddedInitialized) {
-            initEmbedded();
+            return;
         }
+
         if (mediaInfo) {
             if (mediaInfo.id === Constants.CC1 || mediaInfo.id === Constants.CC3) {
                 for (let i = 0; i < embeddedTracks.length; i++) {
@@ -218,42 +226,9 @@ function TextSourceBuffer() {
         }
     }
 
-    function setConfig(config) {
-        if (!config) {
-            return;
-        }
-        if (config.errHandler) {
-            errHandler = config.errHandler;
-        }
-        if (config.adapter) {
-            adapter = config.adapter;
-        }
-        if (config.manifestModel) {
-            manifestModel = config.manifestModel;
-        }
-        if (config.mediaController) {
-            mediaController = config.mediaController;
-        }
-        if (config.videoModel) {
-            videoModel = config.videoModel;
-        }
-        if (config.streamController) {
-            streamController = config.streamController;
-        }
-        if (config.textTracks) {
-            textTracks = config.textTracks;
-        }
-        if (config.vttParser) {
-            vttParser = config.vttParser;
-        }
-        if (config.ttmlParser) {
-            ttmlParser = config.ttmlParser;
-        }
-    }
-
     function getConfig() {
         const config = {
-            fragmentModel: fragmentedFragmentModel,
+            fragmentModel: fragmentModel,
             fragmentedTracks: fragmentedTracks,
             videoModel: videoModel
         };
@@ -265,245 +240,261 @@ function TextSourceBuffer() {
         currFragmentedTrackIdx = idx;
     }
 
-    function createTextTrackFromMediaInfo(captionData, mediaInfo) {
-        const textTrackInfo = new TextTrackInfo();
-        const trackKindMap = { subtitle: 'subtitles', caption: 'captions' }; //Dash Spec has no "s" on end of KIND but HTML needs plural.
-        const getKind = function () {
-            let kind = (mediaInfo.roles.length > 0) ? trackKindMap[mediaInfo.roles[0]] : trackKindMap.caption;
-            kind = (kind === trackKindMap.caption || kind === trackKindMap.subtitle) ? kind : trackKindMap.caption;
-            return kind;
-        };
+    function _checkTtml(mediaInfo) {
+        return (mediaInfo.codec && mediaInfo.codec.search(Constants.STPP) >= 0) || (mediaInfo.mimeType && mediaInfo.mimeType.search(Constants.TTML) >= 0);
+    }
 
-        const checkTTML = function () {
-            let ttml = false;
-            if (mediaInfo.codec && mediaInfo.codec.search(Constants.STPP) >= 0) {
-                ttml = true;
-            }
-            if (mediaInfo.mimeType && mediaInfo.mimeType.search(Constants.TTML) >= 0) {
-                ttml = true;
-            }
-            return ttml;
-        };
+    function _getKind(mediaInfo, trackKindMap) {
+        let kind = (mediaInfo.roles.length > 0) ? trackKindMap[mediaInfo.roles[0]] : trackKindMap.caption;
 
-        textTrackInfo.captionData = captionData;
-        textTrackInfo.lang = mediaInfo.lang;
-        textTrackInfo.labels = mediaInfo.labels;
-        textTrackInfo.id = mediaInfo.id ? mediaInfo.id : mediaInfo.index; // AdaptationSet id (an unsigned int) as it's optional parameter, use mediaInfo.index
-        textTrackInfo.index = mediaInfo.index; // AdaptationSet index in manifest
-        textTrackInfo.isTTML = checkTTML();
-        textTrackInfo.defaultTrack = getIsDefault(mediaInfo);
-        textTrackInfo.isFragmented = !adapter.getIsTextTrack(mediaInfo.mimeType);
-        textTrackInfo.isEmbedded = mediaInfo.isEmbedded ? true : false;
-        textTrackInfo.kind = getKind();
-        textTrackInfo.roles = mediaInfo.roles;
-        textTrackInfo.accessibility = mediaInfo.accessibility;
-        const totalNrTracks = (mediaInfos ? mediaInfos.length : 0) + embeddedTracks.length;
-        textTracks.addTextTrack(textTrackInfo, totalNrTracks);
+        kind = (kind === trackKindMap.caption || kind === trackKindMap.subtitle) ? kind : trackKindMap.caption;
+
+        return kind;
     }
 
     function append(bytes, chunk) {
-        let result,
-            sampleList,
-            i, j, k,
-            samplesInfo,
-            ccContent;
         const mediaInfo = chunk.mediaInfo;
         const mediaType = mediaInfo.type;
         const mimeType = mediaInfo.mimeType;
         const codecType = mediaInfo.codec || mimeType;
+
         if (!codecType) {
             logger.error('No text type defined');
             return;
         }
 
         if (mediaType === Constants.FRAGMENTED_TEXT) {
-            if (!initializationSegmentReceived && chunk.segmentType === 'InitializationSegment') {
-                initializationSegmentReceived = true;
-                timescale = boxParser.getMediaTimescaleFromMoov(bytes);
+            _appendFragmentedText(bytes, chunk, codecType);
+        } else if (mediaType === Constants.TEXT) {
+            _appendText(bytes, chunk, codecType);
+        } else if (mediaType === Constants.VIDEO) {
+            _appendEmbeddedText(bytes, chunk);
+        }
+    }
+
+    function _appendFragmentedText(bytes, chunk, codecType) {
+        let sampleList,
+            samplesInfo;
+
+        if (chunk.segmentType === 'InitializationSegment') {
+            initializationSegmentReceived = true;
+            timescale = boxParser.getMediaTimescaleFromMoov(bytes);
+        } else {
+            if (!initializationSegmentReceived) {
+                return;
+            }
+            samplesInfo = boxParser.getSamplesInfo(bytes);
+            sampleList = samplesInfo.sampleList;
+            if (sampleList.length > 0) {
+                firstFragmentedSubtitleStart = sampleList[0].cts - chunk.start * timescale;
+            }
+            if (codecType.search(Constants.STPP) >= 0) {
+                _appendFragmentedSttp(bytes, sampleList, codecType);
             } else {
-                if (!initializationSegmentReceived) {
-                    return;
-                }
-                samplesInfo = boxParser.getSamplesInfo(bytes);
-                sampleList = samplesInfo.sampleList;
-                if (firstFragmentedSubtitleStart === null && sampleList.length > 0) {
-                    firstFragmentedSubtitleStart = sampleList[0].cts - chunk.start * timescale;
-                }
-                if (codecType.search(Constants.STPP) >= 0) {
-                    parser = parser !== null ? parser : getParser(codecType);
-                    for (i = 0; i < sampleList.length; i++) {
-                        const sample = sampleList[i];
-                        const sampleStart = sample.cts;
-                        const sampleRelStart = sampleStart - firstFragmentedSubtitleStart;
-                        this.buffered.add(sampleRelStart / timescale, (sampleRelStart + sample.duration) / timescale);
-                        const dataView = new DataView(bytes, sample.offset, sample.subSizes[0]);
-                        ccContent = ISOBoxer.Utils.dataViewToString(dataView, Constants.UTF8);
-                        const images = [];
-                        let subOffset = sample.offset + sample.subSizes[0];
-                        for (j = 1; j < sample.subSizes.length; j++) {
-                            const inData = new Uint8Array(bytes, subOffset, sample.subSizes[j]);
-                            const raw = String.fromCharCode.apply(null, inData);
-                            images.push(raw);
-                            subOffset += sample.subSizes[j];
-                        }
-                        try {
-                            // Only used for Miscrosoft Smooth Streaming support - caption time is relative to sample time. In this case, we apply an offset.
-                            const manifest = manifestModel.getValue();
-                            const offsetTime = manifest.ttmlTimeIsRelative ? sampleStart / timescale : 0;
-                            result = parser.parse(ccContent, offsetTime, sampleStart / timescale, (sampleStart + sample.duration) / timescale, images);
-                            textTracks.addCaptions(currFragmentedTrackIdx, firstFragmentedSubtitleStart / timescale, result);
-                        } catch (e) {
-                            fragmentedFragmentModel.removeExecutedRequestsBeforeTime();
-                            this.remove();
-                            logger.error('TTML parser error: ' + e.message);
-                        }
-                    }
-                } else {
-                    // WebVTT case
-                    const captionArray = [];
-                    for (i = 0 ; i < sampleList.length; i++) {
-                        const sample = sampleList[i];
-                        sample.cts -= firstFragmentedSubtitleStart;
-                        this.buffered.add(sample.cts / timescale, (sample.cts + sample.duration) / timescale);
-                        const sampleData = bytes.slice(sample.offset, sample.offset + sample.size);
-                        // There are boxes inside the sampleData, so we need a ISOBoxer to get at it.
-                        const sampleBoxes = ISOBoxer.parseBuffer(sampleData);
-
-                        for (j = 0 ; j < sampleBoxes.boxes.length; j++) {
-                            const box1 = sampleBoxes.boxes[j];
-                            logger.debug('VTT box1: ' + box1.type);
-                            if (box1.type === 'vtte') {
-                                continue; //Empty box
-                            }
-                            if (box1.type === 'vttc') {
-                                logger.debug('VTT vttc boxes.length = ' + box1.boxes.length);
-                                for (k = 0 ; k < box1.boxes.length; k++) {
-                                    const box2 = box1.boxes[k];
-                                    logger.debug('VTT box2: ' + box2.type);
-                                    if (box2.type === 'payl') {
-                                        const cue_text = box2.cue_text;
-                                        logger.debug('VTT cue_text = ' + cue_text);
-                                        const start_time = sample.cts / timescale;
-                                        const end_time = (sample.cts + sample.duration) / timescale;
-                                        captionArray.push({
-                                            start: start_time,
-                                            end: end_time,
-                                            data: cue_text,
-                                            styles: {}
-                                        });
-                                        logger.debug('VTT ' + start_time + '-' + end_time + ' : ' + cue_text);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (captionArray.length > 0) {
-                        textTracks.addCaptions(currFragmentedTrackIdx, 0, captionArray);
-                    }
-                }
+                _appendFragmentedWebVtt(bytes, sampleList);
+            }
+        }
+    }
+
+    function _appendFragmentedSttp(bytes, sampleList, codecType) {
+        let i, j;
+
+        parser = parser !== null ? parser : getParser(codecType);
+
+        for (i = 0; i < sampleList.length; i++) {
+            const sample = sampleList[i];
+            const sampleStart = sample.cts;
+            const timestampOffset = _getTimestampOffset();
+            const start = timestampOffset + sampleStart / timescale;
+            const end = start + sample.duration / timescale;
+            instance.buffered.add(start, end);
+            const dataView = new DataView(bytes, sample.offset, sample.subSizes[0]);
+            let ccContent = ISOBoxer.Utils.dataViewToString(dataView, Constants.UTF8);
+            const images = [];
+            let subOffset = sample.offset + sample.subSizes[0];
+
+            for (j = 1; j < sample.subSizes.length; j++) {
+                const inData = new Uint8Array(bytes, subOffset, sample.subSizes[j]);
+                const raw = String.fromCharCode.apply(null, inData);
+                images.push(raw);
+                subOffset += sample.subSizes[j];
             }
-        } else if (mediaType === Constants.TEXT) {
-            const dataView = new DataView(bytes, 0, bytes.byteLength);
-            ccContent = ISOBoxer.Utils.dataViewToString(dataView, Constants.UTF8);
 
             try {
-                result = getParser(codecType).parse(ccContent, 0);
-                textTracks.addCaptions(textTracks.getCurrentTrackIdx(), 0, result);
+                const manifest = manifestModel.getValue();
+
+                // Only used for Miscrosoft Smooth Streaming support - caption time is relative to sample time. In this case, we apply an offset.
+                const offsetTime = manifest.ttmlTimeIsRelative ? sampleStart / timescale : 0;
+
+                const result = parser.parse(ccContent, offsetTime, sampleStart / timescale, (sampleStart + sample.duration) / timescale, images);
+                textTracks.addCaptions(currFragmentedTrackIdx, timestampOffset, result);
             } catch (e) {
-                errHandler.error(new DashJSError(Errors.TIMED_TEXT_ERROR_ID_PARSE_CODE, Errors.TIMED_TEXT_ERROR_MESSAGE_PARSE + e.message, ccContent));
+                fragmentModel.removeExecutedRequestsBeforeTime();
+                this.remove();
+                logger.error('TTML parser error: ' + e.message);
             }
-        } else if (mediaType === Constants.VIDEO) { //embedded text
-            if (chunk.segmentType === HTTPRequest.INIT_SEGMENT_TYPE) {
-                if (embeddedTimescale === 0) {
-                    embeddedTimescale = boxParser.getMediaTimescaleFromMoov(bytes);
-                    for (i = 0; i < embeddedTracks.length; i++) {
-                        createTextTrackFromMediaInfo(null, embeddedTracks[i]);
-                    }
-                }
-            } else { // MediaSegment
-                if (embeddedTimescale === 0) {
-                    logger.warn('CEA-608: No timescale for embeddedTextTrack yet');
-                    return;
+        }
+    }
+
+    function _appendFragmentedWebVtt(bytes, sampleList) {
+        let i, j, k;
+
+        const captionArray = [];
+        for (i = 0; i < sampleList.length; i++) {
+            const sample = sampleList[i];
+            sample.cts -= firstFragmentedSubtitleStart;
+            const timestampOffset = _getTimestampOffset();
+            const start = timestampOffset + sample.cts / timescale;
+            const end = start + sample.duration / timescale;
+            instance.buffered.add(start, end);
+            const sampleData = bytes.slice(sample.offset, sample.offset + sample.size);
+            // There are boxes inside the sampleData, so we need a ISOBoxer to get at it.
+            const sampleBoxes = ISOBoxer.parseBuffer(sampleData);
+
+            for (j = 0; j < sampleBoxes.boxes.length; j++) {
+                const box1 = sampleBoxes.boxes[j];
+                logger.debug('VTT box1: ' + box1.type);
+                if (box1.type === 'vtte') {
+                    continue; //Empty box
                 }
-                const makeCueAdderForIndex = function (self, trackIndex) {
-                    function newCue(startTime, endTime, captionScreen) {
-                        let captionsArray = null;
-                        if (videoModel.getTTMLRenderingDiv()) {
-                            captionsArray = embeddedTextHtmlRender.createHTMLCaptionsFromScreen(videoModel.getElement(), startTime, endTime, captionScreen);
-                        } else {
-                            const text = captionScreen.getDisplayText();
-                            captionsArray = [{
-                                start: startTime,
-                                end: endTime,
-                                data: text,
+                if (box1.type === 'vttc') {
+                    logger.debug('VTT vttc boxes.length = ' + box1.boxes.length);
+                    for (k = 0; k < box1.boxes.length; k++) {
+                        const box2 = box1.boxes[k];
+                        logger.debug('VTT box2: ' + box2.type);
+                        if (box2.type === 'payl') {
+                            const cue_text = box2.cue_text;
+                            logger.debug('VTT cue_text = ' + cue_text);
+                            const start_time = sample.cts / timescale;
+                            const end_time = (sample.cts + sample.duration) / timescale;
+                            captionArray.push({
+                                start: start_time,
+                                end: end_time,
+                                data: cue_text,
                                 styles: {}
-                            }];
-                        }
-                        if (captionsArray) {
-                            textTracks.addCaptions(trackIndex, 0, captionsArray);
-                        }
-                    }
-                    return newCue;
-                };
-
-                samplesInfo = boxParser.getSamplesInfo(bytes);
-
-                const sequenceNumber = samplesInfo.lastSequenceNumber;
-
-                if (!embeddedCea608FieldParsers[0] && !embeddedCea608FieldParsers[1]) {
-                    // Time to setup the CEA-608 parsing
-                    let field, handler, trackIdx;
-                    for (i = 0; i < embeddedTracks.length; i++) {
-                        if (embeddedTracks[i].id === Constants.CC1) {
-                            field = 0;
-                            trackIdx = textTracks.getTrackIdxForId(Constants.CC1);
-                        } else if (embeddedTracks[i].id === Constants.CC3) {
-                            field = 1;
-                            trackIdx = textTracks.getTrackIdxForId(Constants.CC3);
-                        }
-                        if (trackIdx === -1) {
-                            logger.warn('CEA-608: data before track is ready.');
-                            return;
+                            });
+                            logger.debug('VTT ' + start_time + '-' + end_time + ' : ' + cue_text);
                         }
-                        handler = makeCueAdderForIndex(this, trackIdx);
-                        embeddedCea608FieldParsers[i] = new cea608parser.Cea608Parser(i + 1, {
-                            'newCue': handler
-                        }, null);
                     }
                 }
+            }
+        }
+        if (captionArray.length > 0) {
+            textTracks.addCaptions(currFragmentedTrackIdx, 0, captionArray);
+        }
+    }
 
-                if (embeddedTimescale) {
-                    if (embeddedLastSequenceNumber !== null && sequenceNumber !== embeddedLastSequenceNumber + samplesInfo.numSequences) {
-                        for (i = 0; i < embeddedCea608FieldParsers.length; i++) {
-                            if (embeddedCea608FieldParsers[i]) {
-                                embeddedCea608FieldParsers[i].reset();
-                            }
+    function _appendText(bytes, chunk, codecType) {
+        let result,
+            ccContent;
+
+        const dataView = new DataView(bytes, 0, bytes.byteLength);
+        ccContent = ISOBoxer.Utils.dataViewToString(dataView, Constants.UTF8);
+
+        try {
+            result = getParser(codecType).parse(ccContent, 0);
+            textTracks.addCaptions(textTracks.getCurrentTrackIdx(), 0, result);
+        } catch (e) {
+            errHandler.error(new DashJSError(Errors.TIMED_TEXT_ERROR_ID_PARSE_CODE, Errors.TIMED_TEXT_ERROR_MESSAGE_PARSE + e.message, ccContent));
+        }
+    }
+
+    function _appendEmbeddedText(bytes, chunk) {
+        let i, samplesInfo;
+
+        // Init segment
+        if (chunk.segmentType === HTTPRequest.INIT_SEGMENT_TYPE) {
+            if (embeddedTimescale === 0) {
+                embeddedTimescale = boxParser.getMediaTimescaleFromMoov(bytes);
+            }
+        }
+
+        // MediaSegment
+        else if (chunk.segmentType === HTTPRequest.MEDIA_SEGMENT_TYPE) {
+
+            if (embeddedTimescale === 0) {
+                logger.warn('CEA-608: No timescale for embeddedTextTrack yet');
+                return;
+            }
+
+            samplesInfo = boxParser.getSamplesInfo(bytes);
+
+            const sequenceNumber = samplesInfo.lastSequenceNumber;
+            if (!embeddedCea608FieldParsers[0] && !embeddedCea608FieldParsers[1]) {
+                _setupCeaParser();
+            }
+
+            if (embeddedTimescale) {
+                if (embeddedLastSequenceNumber !== null && sequenceNumber !== embeddedLastSequenceNumber + samplesInfo.numSequences) {
+                    for (i = 0; i < embeddedCea608FieldParsers.length; i++) {
+                        if (embeddedCea608FieldParsers[i]) {
+                            embeddedCea608FieldParsers[i].reset();
                         }
                     }
+                }
 
-                    const allCcData = extractCea608Data(bytes, samplesInfo.sampleList);
+                const allCcData = _extractCea608Data(bytes, samplesInfo.sampleList);
 
-                    for (let fieldNr = 0; fieldNr < embeddedCea608FieldParsers.length; fieldNr++) {
-                        const ccData = allCcData.fields[fieldNr];
-                        const fieldParser = embeddedCea608FieldParsers[fieldNr];
-                        if (fieldParser) {
-                            for (i = 0; i < ccData.length; i++) {
-                                fieldParser.addData(ccData[i][0] / embeddedTimescale, ccData[i][1]);
-                            }
+                for (let fieldNr = 0; fieldNr < embeddedCea608FieldParsers.length; fieldNr++) {
+                    const ccData = allCcData.fields[fieldNr];
+                    const fieldParser = embeddedCea608FieldParsers[fieldNr];
+                    if (fieldParser) {
+                        for (i = 0; i < ccData.length; i++) {
+                            fieldParser.addData(ccData[i][0] / embeddedTimescale, ccData[i][1]);
                         }
                     }
-                    embeddedLastSequenceNumber = sequenceNumber;
                 }
+                embeddedLastSequenceNumber = sequenceNumber;
             }
         }
     }
+
+    function _setupCeaParser() {
+        // Time to setup the CEA-608 parsing
+        let trackIdx;
+        for (let i = 0; i < embeddedTracks.length; i++) {
+            trackIdx = textTracks.getTrackIdxForId(embeddedTracks[i].id);
+
+            if (trackIdx === -1) {
+                logger.warn('CEA-608: data before track is ready.');
+                return;
+            }
+
+            const handler = _makeCueAdderForIndex(trackIdx);
+            embeddedCea608FieldParsers[i] = new cea608parser.Cea608Parser(i + 1, {
+                newCue: handler
+            }, null);
+        }
+    }
+
+    function _makeCueAdderForIndex(trackIndex) {
+        function newCue(startTime, endTime, captionScreen) {
+            let captionsArray;
+            if (videoModel.getTTMLRenderingDiv()) {
+                captionsArray = embeddedTextHtmlRender.createHTMLCaptionsFromScreen(videoModel.getElement(), startTime, endTime, captionScreen);
+            } else {
+                const text = captionScreen.getDisplayText();
+                captionsArray = [{
+                    start: startTime,
+                    end: endTime,
+                    data: text,
+                    styles: {}
+                }];
+            }
+            if (captionsArray) {
+                textTracks.addCaptions(trackIndex, 0, captionsArray);
+            }
+        }
+        return newCue;
+    }
+
     /**
      * Extract CEA-608 data from a buffer of data.
      * @param {ArrayBuffer} data
      * @param {Array} samples cue information
      * @returns {Object|null} ccData corresponding to one segment.
      */
-    function extractCea608Data(data, samples) {
+    function _extractCea608Data(data, samples) {
         if (samples.length === 0) {
             return null;
         }
@@ -527,7 +518,8 @@ function TextSourceBuffer() {
                         } else {
                             idx += 1;
                         }
-                        allCcData.fields[k].push([sample.cts + (mseTimeOffset * embeddedTimescale), ccData[k], idx]);
+                        const timestampOffset = _getTimestampOffset();
+                        allCcData.fields[k].push([sample.cts + (timestampOffset * embeddedTimescale), ccData[k], idx]);
                         lastSampleTime = sample.cts;
                     }
                 }
@@ -549,6 +541,10 @@ function TextSourceBuffer() {
         return allCcData;
     }
 
+    function _getTimestampOffset() {
+        return !isNaN(instance.timestampOffset) ? instance.timestampOffset : 0;
+    }
+
     function getIsDefault(mediaInfo) {
         //TODO How to tag default. currently same order as listed in manifest.
         // Is there a way to mark a text adaptation set as the default one? DASHIF meeting talk about using role which is being used for track KIND
@@ -579,10 +575,10 @@ function TextSourceBuffer() {
     function remove(start, end) {
         //if start and end are not defined, remove all
         if ((start === undefined) && (start === end)) {
-            start = this.buffered.start(0);
-            end = this.buffered.end(this.buffered.length - 1);
+            start = instance.buffered.start(0);
+            end = instance.buffered.end(instance.buffered.length - 1);
         }
-        this.buffered.remove(start, end);
+        instance.buffered.remove(start, end);
     }
 
     function onVideoBufferCleared(e) {
@@ -594,17 +590,23 @@ function TextSourceBuffer() {
         });
     }
 
+    function resetMediaInfos() {
+        mediaInfos = [];
+    }
+
     instance = {
-        initialize: initialize,
-        append: append,
-        abort: abort,
-        addEmbeddedTrack: addEmbeddedTrack,
-        resetEmbedded: resetEmbedded,
-        setConfig: setConfig,
-        getConfig: getConfig,
-        setCurrentFragmentedTrackIdx: setCurrentFragmentedTrackIdx,
-        remove: remove,
-        reset: reset
+        initialize,
+        addMediaInfos,
+        resetMediaInfos,
+        getStreamId,
+        append,
+        abort,
+        addEmbeddedTrack,
+        resetEmbedded,
+        getConfig,
+        setCurrentFragmentedTrackIdx,
+        remove,
+        reset
     };
 
     setup();
@@ -613,4 +615,4 @@ function TextSourceBuffer() {
 }
 
 TextSourceBuffer.__dashjs_factory_name = 'TextSourceBuffer';
-export default FactoryMaker.getSingletonFactory(TextSourceBuffer);
+export default FactoryMaker.getClassFactory(TextSourceBuffer);
diff --git a/src/streaming/text/TextTracks.js b/src/streaming/text/TextTracks.js
index 13ecf889e5..0c64cfc3d8 100644
--- a/src/streaming/text/TextTracks.js
+++ b/src/streaming/text/TextTracks.js
@@ -31,22 +31,23 @@
 import Constants from '../constants/Constants';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
+import MediaPlayerEvents from '../../streaming/MediaPlayerEvents';
 import FactoryMaker from '../../core/FactoryMaker';
 import Debug from '../../core/Debug';
-import { renderHTML } from 'imsc';
-import { checkParameterType } from '../utils/SupervisorTools';
+import {renderHTML} from 'imsc';
 
-function TextTracks() {
+function TextTracks(config) {
 
     const context = this.context;
     const eventBus = EventBus(context).getInstance();
+    const videoModel = config.videoModel;
+    const streamInfo = config.streamInfo;
 
     let instance,
         logger,
         Cue,
-        videoModel,
         textTrackQueue,
-        trackElementArr,
+        nativeTrackElementArr,
         currentTrackIdx,
         actualVideoLeft,
         actualVideoTop,
@@ -71,7 +72,7 @@ function TextTracks() {
 
         Cue = window.VTTCue || window.TextTrackCue;
         textTrackQueue = [];
-        trackElementArr = [];
+        nativeTrackElementArr = [];
         currentTrackIdx = -1;
         actualVideoLeft = 0;
         actualVideoTop = 0;
@@ -94,94 +95,92 @@ function TextTracks() {
         }
     }
 
-    function createTrackForUserAgent (i) {
-        const kind = textTrackQueue[i].kind;
-        const label = textTrackQueue[i].id !== undefined ? textTrackQueue[i].id : textTrackQueue[i].lang;
-        const lang = textTrackQueue[i].lang;
-        const isTTML = textTrackQueue[i].isTTML;
-        const isEmbedded = textTrackQueue[i].isEmbedded;
+    function getStreamId() {
+        return streamInfo.id;
+    }
+
+    function _createTrackForUserAgent(element) {
+        const kind = element.kind;
+        const label = element.id !== undefined ? element.id : element.lang;
+        const lang = element.lang;
+        const isTTML = element.isTTML;
+        const isEmbedded = element.isEmbedded;
         const track = videoModel.addTextTrack(kind, label, lang, isTTML, isEmbedded);
+
         return track;
     }
 
-    function setDisplayCConTop(value) {
-        checkParameterType(value, 'boolean');
-        displayCCOnTop = value;
-        if (!captionContainer || document[fullscreenAttribute]) {
-            return;
-        }
-        captionContainer.style.zIndex = value ? topZIndex : null;
+    function addTextTrack(textTrackInfoVO) {
+        textTrackQueue.push(textTrackInfoVO);
     }
 
-    function addTextTrack(textTrackInfoVO, totalTextTracks) {
-        if (textTrackQueue.length === totalTextTracks) {
-            logger.error('Trying to add too many tracks.');
-            return;
-        }
+    function createTracks() {
 
-        textTrackQueue.push(textTrackInfoVO);
+        //Sort in same order as in manifest
+        textTrackQueue.sort(function (a, b) {
+            return a.index - b.index;
+        });
 
-        if (textTrackQueue.length === totalTextTracks) {
-            textTrackQueue.sort(function (a, b) { //Sort in same order as in manifest
-                return a.index - b.index;
-            });
-            captionContainer = videoModel.getTTMLRenderingDiv();
-            let defaultIndex = -1;
-            for (let i = 0 ; i < textTrackQueue.length; i++) {
-                const track = createTrackForUserAgent.call(this, i);
-                trackElementArr.push(track); //used to remove tracks from video element when added manually
-
-                if (textTrackQueue[i].defaultTrack) {
-                    // track.default is an object property identifier that is a reserved word
-                    // The following jshint directive is used to suppressed the warning "Expected an identifier and instead saw 'default' (a reserved word)"
-                    /*jshint -W024 */
-                    track.default = true;
-                    defaultIndex = i;
-                }
+        captionContainer = videoModel.getTTMLRenderingDiv();
+        let defaultIndex = -1;
+        for (let i = 0; i < textTrackQueue.length; i++) {
+            const track = _createTrackForUserAgent(textTrackQueue[i]);
 
-                const textTrack = getTrackByIdx(i);
-                if (textTrack) {
-                    //each time a track is created, its mode should be showing by default
-                    //sometime, it's not on Chrome
-                    textTrack.mode = Constants.TEXT_SHOWING;
-                    if (captionContainer && (textTrackQueue[i].isTTML || textTrackQueue[i].isEmbedded)) {
-                        textTrack.renderingType = 'html';
-                    } else {
-                        textTrack.renderingType = 'default';
-                    }
+            //used to remove tracks from video element when added manually
+            nativeTrackElementArr.push(track);
+
+            if (textTrackQueue[i].defaultTrack) {
+                // track.default is an object property identifier that is a reserved word
+                // The following jshint directive is used to suppressed the warning "Expected an identifier and instead saw 'default' (a reserved word)"
+                /*jshint -W024 */
+                track.default = true;
+                defaultIndex = i;
+            }
+
+            const textTrack = getTrackByIdx(i);
+            if (textTrack) {
+                //each time a track is created, its mode should be showing by default
+                //sometime, it's not on Chrome
+                textTrack.mode = Constants.TEXT_SHOWING;
+                if (captionContainer && (textTrackQueue[i].isTTML || textTrackQueue[i].isEmbedded)) {
+                    textTrack.renderingType = 'html';
+                } else {
+                    textTrack.renderingType = 'default';
                 }
-                this.addCaptions(i, 0, textTrackQueue[i].captionData);
-                eventBus.trigger(Events.TEXT_TRACK_ADDED);
             }
 
-            //set current track index in textTrackQueue array
-            setCurrentTrackIdx.call(this, defaultIndex);
+            addCaptions(i, 0, textTrackQueue[i].captionData);
+            eventBus.trigger(MediaPlayerEvents.TEXT_TRACK_ADDED);
+        }
 
-            if (defaultIndex >= 0) {
+        //set current track index in textTrackQueue array
+        setCurrentTrackIdx.call(this, defaultIndex);
 
-                let onMetadataLoaded = function () {
-                    const track = getTrackByIdx(defaultIndex);
-                    if (track) {
-                        checkVideoSize.call(this, track, true);
-                    }
-                    eventBus.off(Events.PLAYBACK_METADATA_LOADED, onMetadataLoaded, this);
-                };
+        if (defaultIndex >= 0) {
 
-                eventBus.on(Events.PLAYBACK_METADATA_LOADED, onMetadataLoaded, this);
+            let onMetadataLoaded = function () {
+                const track = getTrackByIdx(defaultIndex);
+                if (track) {
+                    checkVideoSize.call(this, track, true);
+                }
+                eventBus.off(MediaPlayerEvents.PLAYBACK_METADATA_LOADED, onMetadataLoaded, this);
+            };
 
-                for (let idx = 0; idx < textTrackQueue.length; idx++) {
-                    const videoTextTrack = getTrackByIdx(idx);
-                    if (videoTextTrack) {
-                        videoTextTrack.mode = (idx === defaultIndex) ? Constants.TEXT_SHOWING : Constants.TEXT_HIDDEN;
-                    }
+            eventBus.on(MediaPlayerEvents.PLAYBACK_METADATA_LOADED, onMetadataLoaded, this);
+
+            for (let idx = 0; idx < textTrackQueue.length; idx++) {
+                const videoTextTrack = getTrackByIdx(idx);
+                if (videoTextTrack) {
+                    videoTextTrack.mode = (idx === defaultIndex) ? Constants.TEXT_SHOWING : Constants.TEXT_HIDDEN;
                 }
             }
-
-            eventBus.trigger(Events.TEXT_TRACKS_QUEUE_INITIALIZED, {
-                index: currentTrackIdx,
-                tracks: textTrackQueue
-            }); //send default idx.
         }
+
+        eventBus.trigger(Events.TEXT_TRACKS_QUEUE_INITIALIZED, {
+            index: currentTrackIdx,
+            tracks: textTrackQueue,
+            streamId: streamInfo.id
+        });
     }
 
     function getVideoVisibleVideoSize(viewWidth, viewHeight, videoWidth, videoHeight, aspectRatio, use80Percent) {
@@ -242,7 +241,7 @@ function TextTracks() {
 
         if (videoWidth !== 0 && videoHeight !== 0) {
 
-            let aspectRatio =  videoWidth / videoHeight;
+            let aspectRatio = videoWidth / videoHeight;
             let use80Percent = false;
             if (track.isFromCEA608) {
                 // If this is CEA608 then use predefined aspect ratio
@@ -271,7 +270,7 @@ function TextTracks() {
                         containerStyle.width = actualVideoWidth + 'px';
                         containerStyle.height = actualVideoHeight + 'px';
                         containerStyle.zIndex = (fullscreenAttribute && document[fullscreenAttribute]) || displayCCOnTop ? topZIndex : null;
-                        eventBus.trigger(Events.CAPTION_CONTAINER_RESIZE);
+                        eventBus.trigger(MediaPlayerEvents.CAPTION_CONTAINER_RESIZE);
                     }
                 }
 
@@ -392,7 +391,7 @@ function TextTracks() {
                 //TODO add ErrorHandler management
             }, previousISDState, true /*enableRollUp*/);
             finalCue.id = cue.cueID;
-            eventBus.trigger(Events.CAPTION_RENDERED, { captionDiv: finalCue, currentTrackIdx });
+            eventBus.trigger(MediaPlayerEvents.CAPTION_RENDERED, { captionDiv: finalCue, currentTrackIdx });
         }
     }
 
@@ -419,7 +418,7 @@ function TextTracks() {
             track.isFromCEA608 = currentItem.isFromCEA608;
 
             if (currentItem.type === 'html' && captionContainer) {
-                cue = new Cue(currentItem.start - timeOffset, currentItem.end - timeOffset, '');
+                cue = new Cue(currentItem.start + timeOffset, currentItem.end + timeOffset, '');
                 cue.cueHTMLElement = currentItem.cueHTMLElement;
                 cue.isd = currentItem.isd;
                 cue.images = currentItem.images;
@@ -445,7 +444,10 @@ function TextTracks() {
                         } else {
                             captionContainer.appendChild(this.cueHTMLElement);
                             scaleCue.call(self, this);
-                            eventBus.trigger(Events.CAPTION_RENDERED, { captionDiv: this.cueHTMLElement, currentTrackIdx });
+                            eventBus.trigger(MediaPlayerEvents.CAPTION_RENDERED, {
+                                captionDiv: this.cueHTMLElement,
+                                currentTrackIdx
+                            });
                         }
                     }
                 };
@@ -481,7 +483,7 @@ function TextTracks() {
                     }
                     cue.onenter = function () {
                         if (track.mode === Constants.TEXT_SHOWING) {
-                            eventBus.trigger(Events.CAPTION_RENDERED, { currentTrackIdx });
+                            eventBus.trigger(MediaPlayerEvents.CAPTION_RENDERED, { currentTrackIdx });
                         }
                     };
                 }
@@ -571,7 +573,7 @@ function TextTracks() {
             const cues = track.cues;
             const lastIdx = cues.length - 1;
 
-            for (let r = lastIdx; r >= 0 ; r--) {
+            for (let r = lastIdx; r >= 0; r--) {
                 if (cueInRange(cues[r], start, end)) {
                     track.removeCue(cues[r]);
                 }
@@ -587,7 +589,7 @@ function TextTracks() {
     }
 
     function deleteAllTextTracks() {
-        const ln = trackElementArr ? trackElementArr.length : 0;
+        const ln = nativeTrackElementArr ? nativeTrackElementArr.length : 0;
         for (let i = 0; i < ln; i++) {
             const track = getTrackByIdx(i);
             if (track) {
@@ -595,7 +597,7 @@ function TextTracks() {
                 track.mode = 'disabled';
             }
         }
-        trackElementArr = [];
+        nativeTrackElementArr = [];
         textTrackQueue = [];
         if (videoSizeCheckInterval) {
             clearInterval(videoSizeCheckInterval);
@@ -610,8 +612,8 @@ function TextTracks() {
     }
 
     function deleteTextTrack(idx) {
-        videoModel.removeChild(trackElementArr[idx]);
-        trackElementArr.splice(idx, 1);
+        videoModel.removeChild(nativeTrackElementArr[idx]);
+        nativeTrackElementArr.splice(idx, 1);
     }
 
     /* Set native cue style to transparent background to avoid it being displayed. */
@@ -657,15 +659,6 @@ function TextTracks() {
         }
     }
 
-    function setConfig(config) {
-        if (!config) {
-            return;
-        }
-        if (config.videoModel) {
-            videoModel = config.videoModel;
-        }
-    }
-
     function setModeForTrackIdx(idx, mode) {
         const track = getTrackByIdx(idx);
         if (track && track.mode !== mode) {
@@ -678,19 +671,19 @@ function TextTracks() {
     }
 
     instance = {
-        initialize: initialize,
-        setDisplayCConTop: setDisplayCConTop,
-        addTextTrack: addTextTrack,
-        addCaptions: addCaptions,
-        getCurrentTrackIdx: getCurrentTrackIdx,
-        setCurrentTrackIdx: setCurrentTrackIdx,
-        getTrackIdxForId: getTrackIdxForId,
-        getCurrentTrackInfo: getCurrentTrackInfo,
-        setModeForTrackIdx: setModeForTrackIdx,
-        deleteCuesFromTrackIdx: deleteCuesFromTrackIdx,
-        deleteAllTextTracks: deleteAllTextTracks,
-        deleteTextTrack: deleteTextTrack,
-        setConfig: setConfig
+        initialize,
+        getStreamId,
+        addTextTrack,
+        addCaptions,
+        createTracks,
+        getCurrentTrackIdx,
+        setCurrentTrackIdx,
+        getTrackIdxForId,
+        getCurrentTrackInfo,
+        setModeForTrackIdx,
+        deleteCuesFromTrackIdx,
+        deleteAllTextTracks,
+        deleteTextTrack
     };
 
     setup();
@@ -699,4 +692,4 @@ function TextTracks() {
 }
 
 TextTracks.__dashjs_factory_name = 'TextTracks';
-export default FactoryMaker.getSingletonFactory(TextTracks);
+export default FactoryMaker.getClassFactory(TextTracks);
diff --git a/src/streaming/thumbnail/ThumbnailController.js b/src/streaming/thumbnail/ThumbnailController.js
index 86321676f2..1a375d6c41 100644
--- a/src/streaming/thumbnail/ThumbnailController.js
+++ b/src/streaming/thumbnail/ThumbnailController.js
@@ -34,7 +34,7 @@ import Constants from '../constants/Constants';
 import Thumbnail from '../vo/Thumbnail';
 import ThumbnailTracks from './ThumbnailTracks';
 import BitrateInfo from '../vo/BitrateInfo';
-import { replaceTokenForTemplate, unescapeDollarsInTemplate } from '../../dash/utils/SegmentsUtils';
+import {replaceTokenForTemplate, unescapeDollarsInTemplate} from '../../dash/utils/SegmentsUtils';
 
 function ThumbnailController(config) {
 
@@ -54,15 +54,21 @@ function ThumbnailController(config) {
             debug: config.debug,
             eventBus: config.eventBus,
             events: config.events,
-            dashConstants: config.dashConstants
+            dashConstants: config.dashConstants,
+            dashMetrics: config.dashMetrics,
+            segmentBaseController: config.segmentBaseController
         });
     }
 
+    function initialize() {
+        thumbnailTracks.addTracks();
+    }
+
     function getStreamId() {
         return streamInfo.id;
     }
 
-    function provideThumbnail(time, callback) {
+    function provide(time, callback) {
 
         if (typeof callback !== 'function') {
             return;
@@ -75,12 +81,9 @@ function ThumbnailController(config) {
             return;
         }
 
-        // Calculate index of the sprite given a time
-        if (isNaN(track.segmentDuration)) {
-            request = thumbnailTracks.getThumbnailRequestForTime(time);
-            if (request) {
-                track.segmentDuration = request.duration;
-            }
+        request = thumbnailTracks.getThumbnailRequestForTime(time);
+        if (request) {
+            track.segmentDuration = request.duration;
         }
 
         offset = time % track.segmentDuration;
@@ -102,7 +105,7 @@ function ThumbnailController(config) {
         } else {
             if (!request) {
                 const seq = Math.floor(time / track.segmentDuration);
-                thumbnail.url = buildUrlFromTemplate(track, seq);
+                thumbnail.url = _buildUrlFromTemplate(track, seq);
             } else {
                 thumbnail.url = request.url;
                 track.segmentDuration = NaN;
@@ -111,7 +114,7 @@ function ThumbnailController(config) {
         }
     }
 
-    function buildUrlFromTemplate(track, seq) {
+    function _buildUrlFromTemplate(track, seq) {
         const seqIdx = seq + track.startNumber;
         let url = replaceTokenForTemplate(track.templateUrl, 'Number', seqIdx);
         url = replaceTokenForTemplate(url, 'Time', (seqIdx - 1) * track.segmentDuration * track.timescale);
@@ -149,12 +152,13 @@ function ThumbnailController(config) {
     }
 
     instance = {
-        getStreamId: getStreamId,
-        provide: provideThumbnail,
-        setTrackByIndex: setTrackByIndex,
-        getCurrentTrackIndex: getCurrentTrackIndex,
-        getBitrateList: getBitrateList,
-        reset: reset
+        getStreamId,
+        initialize,
+        provide,
+        setTrackByIndex,
+        getCurrentTrackIndex,
+        getBitrateList,
+        reset
     };
 
     setup();
diff --git a/src/streaming/thumbnail/ThumbnailTracks.js b/src/streaming/thumbnail/ThumbnailTracks.js
index 67ca602079..b9b4f5be56 100644
--- a/src/streaming/thumbnail/ThumbnailTracks.js
+++ b/src/streaming/thumbnail/ThumbnailTracks.js
@@ -33,14 +33,14 @@ import DashConstants from '../../dash/constants/DashConstants';
 import FactoryMaker from '../../core/FactoryMaker';
 import ThumbnailTrackInfo from '../vo/ThumbnailTrackInfo';
 import URLUtils from '../../streaming/utils/URLUtils';
-import { replaceIDForTemplate, getTimeBasedSegment } from '../../dash/utils/SegmentsUtils';
-import Events from '../../core/events/Events';
+import {replaceIDForTemplate, getTimeBasedSegment} from '../../dash/utils/SegmentsUtils';
 import BoxParser from '../../streaming/utils/BoxParser';
 import XHRLoader from '../../streaming/net/XHRLoader';
 import DashHandler from '../../dash/DashHandler';
+import SegmentsController from '../../dash/controllers/SegmentsController';
 
 export const THUMBNAILS_SCHEME_ID_URIS = ['http://dashif.org/thumbnail_tile',
-                                   'http://dashif.org/guidelines/thumbnail_tile'];
+    'http://dashif.org/guidelines/thumbnail_tile'];
 
 function ThumbnailTracks(config) {
     const context = this.context;
@@ -57,65 +57,44 @@ function ThumbnailTracks(config) {
 
     let instance,
         tracks,
-        indexHandler,
+        dashHandler,
         currentTrackIndex,
         mediaInfo,
+        segmentsController,
         loader,
         boxParser;
 
-    function initialize() {
+    function setup() {
         reset();
         loader = XHRLoader(context).create({});
         boxParser = BoxParser(context).getInstance();
 
-        indexHandler = DashHandler(context).create({
-            streamInfo: streamInfo,
-            timelineConverter: timelineConverter,
-            baseURLController: baseURLController,
-            debug: debug,
-            eventBus: eventBus,
-            events: events,
-            dashConstants: dashConstants,
-            urlUtils: urlUtils
+        segmentsController = SegmentsController(context).create({
+            events,
+            eventBus,
+            streamInfo,
+            timelineConverter,
+            dashConstants,
+            dashMetrics: config.dashMetrics,
+            segmentBaseController: config.segmentBaseController,
+            type: Constants.IMAGE
         });
 
-        // initialize controllers
-        indexHandler.initialize(adapter ? adapter.getIsDynamic() : false);
-
-        // parse representation and create tracks
-        addTracks();
-    }
-
-    function normalizeSegments(fragments, representation) {
-        const segments = [];
-        let count = 0;
-
-        let i,
-            len,
-            s,
-            seg;
-
-        for (i = 0, len = fragments.length; i < len; i++) {
-            s = fragments[i];
-
-            seg = getTimeBasedSegment(
-                timelineConverter,
-                adapter.getIsDynamic(),
-                representation,
-                s.startTime,
-                s.duration,
-                s.timescale,
-                s.media,
-                s.mediaRange,
-                count);
+        dashHandler = DashHandler(context).create({
+            streamInfo,
+            type: Constants.IMAGE,
+            timelineConverter,
+            segmentsController,
+            baseURLController,
+            debug,
+            eventBus,
+            events,
+            dashConstants,
+            urlUtils
+        });
 
-            if (seg) {
-                segments.push(seg);
-                seg = null;
-                count++;
-            }
-        }
-        return segments;
+        // initialize controllers
+        dashHandler.initialize(adapter ? adapter.getIsDynamic() : false);
     }
 
     function addTracks() {
@@ -134,11 +113,11 @@ function ThumbnailTracks(config) {
         if (voReps && voReps.length > 0) {
             voReps.forEach((rep) => {
                 if ((rep.segmentInfoType === DashConstants.SEGMENT_TEMPLATE && rep.segmentDuration > 0 && rep.media) ||
-                     rep.segmentInfoType === DashConstants.SEGMENT_TIMELINE) {
-                    createTrack(rep);
+                    rep.segmentInfoType === DashConstants.SEGMENT_TIMELINE) {
+                    _createTrack(rep);
                 }
                 if (rep.segmentInfoType === DashConstants.SEGMENT_BASE) {
-                    createTrack(rep, true);
+                    _createTrack(rep, true);
                 }
             });
         }
@@ -150,7 +129,7 @@ function ThumbnailTracks(config) {
         }
     }
 
-    function createTrack(representation, useSegmentBase) {
+    function _createTrack(representation, useSegmentBase) {
         const track = new ThumbnailTrackInfo();
         track.id = representation.id;
         track.bitrate = representation.bandwidth;
@@ -172,57 +151,11 @@ function ThumbnailTracks(config) {
         }
 
         if (useSegmentBase) {
-            eventBus.trigger(Events.SEGMENTBASE_SEGMENTSLIST_REQUEST_NEEDED, {
-                streamId: streamInfo.id,
-                mediaType: Constants.IMAGE,
-                mimeType: mediaInfo.mimeType,
-                representation: representation,
-                callback: function (streamId, mediaType, segments, representation) {
-                    let cache = [];
-                    segments = normalizeSegments(segments, representation);
-                    track.segmentDuration = segments[0].duration; //assume all segments have the same duration
-                    track.readThumbnail = function (time, callback) {
-
-                        let cached = null;
-                        cache.some(el => {
-                            if (el.start <= time && el.end > time) {
-                                cached = el.url;
-                                return true;
-                            }
-                        });
-                        if (cached) {
-                            callback(cached);
-                        } else {
-                            segments.some((ss) => {
-                                if (ss.mediaStartTime <= time && ss.mediaStartTime + ss.duration > time) {
-                                    const baseURL = baseURLController.resolve(representation.path);
-                                    loader.load({
-                                        method: 'get',
-                                        url: baseURL.url,
-                                        request: {
-                                            range: ss.mediaRange,
-                                            responseType: 'arraybuffer'
-                                        },
-                                        onload: function (e) {
-                                            let info = boxParser.getSamplesInfo(e.target.response);
-                                            let blob = new Blob( [ e.target.response.slice(info.sampleList[0].offset, info.sampleList[0].offset + info.sampleList[0].size) ], { type: 'image/jpeg' } );
-                                            let imageUrl = window.URL.createObjectURL( blob );
-                                            cache.push({
-                                                start: ss.mediaStartTime,
-                                                end: ss.mediaStartTime + ss.duration,
-                                                url: imageUrl
-                                            });
-                                            if (callback)
-                                                callback(imageUrl);
-                                        }
-                                    });
-                                    return true;
-                                }
-                            });
-                        }
-                    };
-                }
-            });
+            segmentsController.updateSegmentData(representation)
+                .then((data) => {
+                    _handleUpdatedSegmentData(track, representation, data);
+                });
+
         } else {
             track.startNumber = representation.startNumber;
             track.segmentDuration = representation.segmentDuration;
@@ -238,6 +171,86 @@ function ThumbnailTracks(config) {
         }
     }
 
+    function _handleUpdatedSegmentData(track, representation, data) {
+        let cache = [];
+        const segments = _normalizeSegments(data, representation);
+        representation.segments = segments;
+        track.segmentDuration = representation.segments[0].duration; //assume all segments have the same duration
+
+        track.readThumbnail = function (time, callback) {
+
+            let cached = null;
+            cache.some(el => {
+                if (el.start <= time && el.end > time) {
+                    cached = el.url;
+                    return true;
+                }
+            });
+            if (cached) {
+                callback(cached);
+            } else {
+                representation.segments.some((ss) => {
+                    if (ss.mediaStartTime <= time && ss.mediaStartTime + ss.duration > time) {
+                        const baseURL = baseURLController.resolve(representation.path);
+                        loader.load({
+                            method: 'get',
+                            url: baseURL.url,
+                            request: {
+                                range: ss.mediaRange,
+                                responseType: 'arraybuffer'
+                            },
+                            onload: function (e) {
+                                let info = boxParser.getSamplesInfo(e.target.response);
+                                let blob = new Blob([e.target.response.slice(info.sampleList[0].offset, info.sampleList[0].offset + info.sampleList[0].size)], { type: 'image/jpeg' });
+                                let imageUrl = window.URL.createObjectURL(blob);
+                                cache.push({
+                                    start: ss.mediaStartTime,
+                                    end: ss.mediaStartTime + ss.duration,
+                                    url: imageUrl
+                                });
+                                if (callback)
+                                    callback(imageUrl);
+                            }
+                        });
+                        return true;
+                    }
+                });
+            }
+        };
+    }
+
+    function _normalizeSegments(data, representation) {
+        const segments = [];
+        let count = 0;
+
+        let i,
+            len,
+            s,
+            seg;
+
+        for (i = 0, len = data.segments.length; i < len; i++) {
+            s = data.segments[i];
+
+            seg = getTimeBasedSegment(
+                timelineConverter,
+                adapter.getIsDynamic(),
+                representation,
+                s.startTime,
+                s.duration,
+                s.timescale,
+                s.media,
+                s.mediaRange,
+                count);
+
+            if (seg) {
+                segments.push(seg);
+                seg = null;
+                count++;
+            }
+        }
+        return segments;
+    }
+
     function buildTemplateUrl(representation) {
         const templateUrl = urlUtils.isRelative(representation.media) ?
             urlUtils.resolve(representation.media, baseURLController.resolve(representation.path).url) : representation.media;
@@ -285,7 +298,7 @@ function ThumbnailTracks(config) {
             }
         }
 
-        return indexHandler.getSegmentRequestForTime(mediaInfo, currentVoRep, time);
+        return dashHandler.getSegmentRequestForTime(mediaInfo, currentVoRep, time);
     }
 
     function reset() {
@@ -295,16 +308,16 @@ function ThumbnailTracks(config) {
     }
 
     instance = {
-        initialize: initialize,
-        getTracks: getTracks,
-        reset: reset,
-        setTrackByIndex: setTrackByIndex,
-        getCurrentTrack: getCurrentTrack,
-        getCurrentTrackIndex: getCurrentTrackIndex,
-        getThumbnailRequestForTime: getThumbnailRequestForTime
+        getTracks,
+        addTracks,
+        reset,
+        setTrackByIndex,
+        getCurrentTrack,
+        getCurrentTrackIndex,
+        getThumbnailRequestForTime
     };
 
-    initialize();
+    setup();
 
     return instance;
 }
diff --git a/src/streaming/utils/BoxParser.js b/src/streaming/utils/BoxParser.js
index 40db5cfef7..8f2b38307d 100644
--- a/src/streaming/utils/BoxParser.js
+++ b/src/streaming/utils/BoxParser.js
@@ -298,12 +298,12 @@ function BoxParser(/*config*/) {
     }
 
     instance = {
-        parse: parse,
-        findLastTopIsoBoxCompleted: findLastTopIsoBoxCompleted,
-        getMediaTimescaleFromMoov: getMediaTimescaleFromMoov,
-        getSamplesInfo: getSamplesInfo,
-        findInitRange: findInitRange,
-        parsePayload: parsePayload
+        parse,
+        findLastTopIsoBoxCompleted,
+        getMediaTimescaleFromMoov,
+        getSamplesInfo,
+        findInitRange,
+        parsePayload
     };
 
     setup();
diff --git a/src/streaming/utils/Capabilities.js b/src/streaming/utils/Capabilities.js
index 29b07acfd9..289451f2f8 100644
--- a/src/streaming/utils/Capabilities.js
+++ b/src/streaming/utils/Capabilities.js
@@ -30,6 +30,7 @@
  */
 import FactoryMaker from '../../core/FactoryMaker';
 import {THUMBNAILS_SCHEME_ID_URIS} from '../thumbnail/ThumbnailTracks';
+import Constants from '../constants/Constants';
 
 const codecCompatibilityTable = [
     {
@@ -77,20 +78,101 @@ function Capabilities() {
     }
 
     /**
-     * Check if a codec is supported by the MediaSource
-     * @param {string} codec
-     * @return {boolean}
+     * Check if a codec is supported by the MediaSource. We use the MediaCapabilities API or the MSE to check.
+     * @param {object} config
+     * @param {string} type
+     * @return {Promise<boolean>}
      */
-    function supportsCodec(codec) {
-        if ('MediaSource' in window && MediaSource.isTypeSupported(codec)) {
-            return true;
+    function supportsCodec(config, type) {
+
+        if (type !== Constants.AUDIO && type !== Constants.VIDEO) {
+            return Promise.resolve(true);
         }
 
-        if ('WebKitMediaSource' in window && WebKitMediaSource.isTypeSupported(codec)) {
-            return true;
+        if (_canUseMediaCapabilitiesApi(config, type)) {
+            return _checkCodecWithMediaCapabilities(config, type);
         }
 
-        return false;
+        return _checkCodecWithMse(config);
+    }
+
+    /**
+     * MediaCapabilitiesAPI throws an error if one of the attribute is missing. We only use it if we have all required information.
+     * @param {object} config
+     * @param {string} type
+     * @return {*|boolean|boolean}
+     * @private
+     */
+    function _canUseMediaCapabilitiesApi(config, type) {
+
+        return navigator.mediaCapabilities && navigator.mediaCapabilities.decodingInfo && ((config.codec && type === Constants.AUDIO) || (type === Constants.VIDEO && config.codec && config.width && config.height && config.bitrate && config.framerate));
+    }
+
+    /**
+     * Check codec support using the MSE
+     * @param {object} config
+     * @return {Promise<void> | Promise<boolean>}
+     * @private
+     */
+    function _checkCodecWithMse(config) {
+        return new Promise((resolve) => {
+            if (!config || !config.codec) {
+                resolve(false);
+                return;
+            }
+
+            let codec = config.codec;
+            if (config.width && config.height) {
+                codec += ';width="' + config.width + '";height="' + config.height + '"';
+            }
+
+            if ('MediaSource' in window && MediaSource.isTypeSupported(codec)) {
+                resolve(true);
+                return;
+            } else if ('WebKitMediaSource' in window && WebKitMediaSource.isTypeSupported(codec)) {
+                resolve(true);
+                return;
+            }
+
+            resolve(false);
+        });
+
+    }
+
+    /**
+     * Check codec support using the MediaCapabilities API
+     * @param {object} config
+     * @param {string} type
+     * @return {Promise<boolean>}
+     * @private
+     */
+    function _checkCodecWithMediaCapabilities(config, type) {
+        return new Promise((resolve) => {
+
+            if (!config || !config.codec) {
+                resolve(false);
+                return;
+            }
+
+            const configuration = {
+                type: 'media-source'
+            };
+
+            configuration[type] = {};
+            configuration[type].contentType = config.codec;
+            configuration[type].width = config.width;
+            configuration[type].height = config.height;
+            configuration[type].bitrate = parseInt(config.bitrate);
+            configuration[type].framerate = parseFloat(config.framerate);
+
+            navigator.mediaCapabilities.decodingInfo(configuration)
+                .then((result) => {
+                    resolve(result.supported);
+                })
+                .catch(() => {
+                    resolve(false);
+                });
+        });
     }
 
     /**
diff --git a/src/streaming/utils/CapabilitiesFilter.js b/src/streaming/utils/CapabilitiesFilter.js
index 7899ecdfc5..4e3883a0dc 100644
--- a/src/streaming/utils/CapabilitiesFilter.js
+++ b/src/streaming/utils/CapabilitiesFilter.js
@@ -7,6 +7,8 @@ function CapabilitiesFilter() {
     let instance,
         adapter,
         capabilities,
+        manifestModel,
+        errHandler,
         settings,
         logger,
         customCapabilitiesFilters;
@@ -33,102 +35,214 @@ function CapabilitiesFilter() {
             settings = config.settings;
         }
 
-    }
-
-    function filterUnsupportedFeaturesOfPeriod(streamInfo) {
-        _filterUnsupportedCodecs(Constants.VIDEO, streamInfo);
-        _filterUnsupportedCodecs(Constants.AUDIO, streamInfo);
+        if (config.manifestModel) {
+            manifestModel = config.manifestModel;
+        }
 
-        if (settings.get().streaming.filterUnsupportedEssentialProperties) {
-            _filterUnsupportedEssentialProperties(streamInfo);
+        if (config.errHandler) {
+            errHandler = config.errHandler;
         }
 
-        _applyCustomFilters(streamInfo);
     }
 
+    function filterUnsupportedFeatures(manifest) {
+        return new Promise((resolve) => {
+            const promises = [];
 
-    function _filterUnsupportedCodecs(type, streamInfo) {
-        const realPeriod = adapter.getRealPeriodByIndex(streamInfo ? streamInfo.index : null);
+            promises.push(_filterUnsupportedCodecs(Constants.VIDEO, manifest));
+            promises.push(_filterUnsupportedCodecs(Constants.AUDIO, manifest));
 
-        if (!realPeriod || !realPeriod.AdaptationSet_asArray || realPeriod.AdaptationSet_asArray.length === 0) {
-            return;
+            Promise.all(promises)
+                .then(() => {
+                    if (settings.get().streaming.filterUnsupportedEssentialProperties) {
+                        _filterUnsupportedEssentialProperties(manifest);
+                    }
+                    _applyCustomFilters(manifest);
+                    resolve();
+                })
+                .catch(() => {
+                    resolve();
+                });
+        });
+    }
+
+
+    function _filterUnsupportedCodecs(type, manifest) {
+        if (!manifest || !manifest.Period_asArray || manifest.Period_asArray.length === 0) {
+            return Promise.resolve();
         }
 
-        realPeriod.AdaptationSet_asArray = realPeriod.AdaptationSet_asArray.filter((as) => {
+        const promises = [];
+        manifest.Period_asArray.forEach((period) => {
+            promises.push(_filterUnsupportedAdaptationSetsOfPeriod(period, type));
+        });
+
+        return Promise.all(promises);
+    }
+
+    function _filterUnsupportedAdaptationSetsOfPeriod(period, type) {
+        return new Promise((resolve) => {
 
-            if (!as.Representation_asArray || as.Representation_asArray.length === 0 || !adapter.getIsTypeOf(as, type)) {
-                return true;
+            if (!period || !period.AdaptationSet_asArray || period.AdaptationSet_asArray.length === 0) {
+                resolve();
+                return;
             }
 
-            as.Representation_asArray = as.Representation_asArray.filter((_, i) => {
-                const codec = adapter.getCodec(as, i, true);
-                if (!capabilities.supportsCodec(codec)) {
-                    logger.error('[Stream] codec not supported: ' + codec);
-                    return false;
+            const promises = [];
+            period.AdaptationSet_asArray.forEach((as) => {
+                if (adapter.getIsTypeOf(as, type)) {
+                    promises.push(_filterUnsupportedRepresentationsOfAdaptation(as, type));
                 }
-                return true;
             });
 
-            return as.Representation_asArray && as.Representation_asArray.length > 0;
-        });
+            Promise.all(promises)
+                .then(() => {
+                    period.AdaptationSet_asArray = period.AdaptationSet_asArray.filter((as) => {
+                        const supported = as.Representation_asArray && as.Representation_asArray.length > 0;
 
-    }
+                        if (!supported) {
+                            logger.warn(`AdaptationSet has been removed because of no supported Representation`);
+                        }
 
-    function _filterUnsupportedEssentialProperties(streamInfo) {
-        const realPeriod = adapter.getRealPeriodByIndex(streamInfo ? streamInfo.index : null);
+                        return supported;
+                    });
 
-        if (!realPeriod || !realPeriod.AdaptationSet_asArray || realPeriod.AdaptationSet_asArray.length === 0) {
-            return;
-        }
+                    resolve();
+                })
+                .catch(() => {
+                    resolve();
+                });
+        });
 
-        realPeriod.AdaptationSet_asArray = realPeriod.AdaptationSet_asArray.filter((as) => {
+    }
+
+    function _filterUnsupportedRepresentationsOfAdaptation(as, type) {
+        return new Promise((resolve) => {
 
             if (!as.Representation_asArray || as.Representation_asArray.length === 0) {
-                return true;
+                resolve();
+                return;
             }
 
-            as.Representation_asArray = as.Representation_asArray.filter((rep) => {
-                const essentialProperties = adapter.getEssentialPropertiesForRepresentation(rep);
+            const promises = [];
+            const configurations = [];
 
-                if (essentialProperties && essentialProperties.length > 0) {
-                    let i = 0;
-                    while (i < essentialProperties.length) {
-                        if (!capabilities.supportsEssentialProperty(essentialProperties[i])) {
-                            logger.debug('[Stream] EssentialProperty not supported: ' + essentialProperties[i].schemeIdUri);
-                            return false;
-                        }
-                        i += 1;
-                    }
-                }
+            as.Representation_asArray.forEach((rep, i) => {
+                const codec = adapter.getCodec(as, i, false);
+                const config = _createConfiguration(type,rep, codec);
 
-                return true;
+                configurations.push(config);
+                promises.push(capabilities.supportsCodec(config, type));
             });
 
-            return as.Representation_asArray && as.Representation_asArray.length > 0;
+            Promise.all(promises)
+                .then((supported) => {
+                    as.Representation_asArray = as.Representation_asArray.filter((_, i) => {
+                        if (!supported[i]) {
+                            logger.debug(`[Stream] Codec ${configurations[i].codec} not supported `);
+                        }
+                        return supported[i];
+                    });
+                    resolve();
+                })
+                .catch(() => {
+                    resolve();
+                });
         });
+    }
+
+    function _createConfiguration(type, rep, codec) {
+        switch (type) {
+            case Constants.VIDEO:
+                return _createVideoConfiguration(rep, codec);
+            case Constants.AUDIO:
+                return _createAudioConfiguration(rep, codec);
+            default:
+                return null;
 
+        }
     }
 
-    function _applyCustomFilters(streamInfo) {
-        if (!customCapabilitiesFilters || customCapabilitiesFilters.length === 0) return;
+    function _createVideoConfiguration(rep, codec) {
+        const width = rep.width || null;
+        const height = rep.height || null;
+        const framerate = rep.frameRate || null;
+        const bitrate = rep.bandwidth || null;
+
+        return {
+            codec,
+            width,
+            height,
+            framerate,
+            bitrate
+        };
+    }
+
+    function _createAudioConfiguration(rep, codec) {
+        const samplerate = rep.audioSamplingRate || null;
+        const bitrate = rep.bandwidth || null;
+
+        return {
+            codec,
+            bitrate,
+            samplerate
+        };
+    }
 
-        const realPeriod = adapter.getRealPeriodByIndex(streamInfo ? streamInfo.index : null);
+    function _filterUnsupportedEssentialProperties(manifest) {
 
-        if (!realPeriod || !realPeriod.AdaptationSet_asArray || realPeriod.AdaptationSet_asArray.length === 0) {
+        if (!manifest || !manifest.Period_asArray || manifest.Period_asArray.length === 0) {
             return;
         }
 
-        realPeriod.AdaptationSet_asArray = realPeriod.AdaptationSet_asArray.filter((as) => {
+        manifest.Period_asArray.forEach((period) => {
+            period.AdaptationSet_asArray = period.AdaptationSet_asArray.filter((as) => {
 
-            if (!as.Representation_asArray || as.Representation_asArray.length === 0) {
-                return true;
-            }
+                if (!as.Representation_asArray || as.Representation_asArray.length === 0) {
+                    return true;
+                }
+
+                as.Representation_asArray = as.Representation_asArray.filter((rep) => {
+                    const essentialProperties = adapter.getEssentialPropertiesForRepresentation(rep);
+
+                    if (essentialProperties && essentialProperties.length > 0) {
+                        let i = 0;
+                        while (i < essentialProperties.length) {
+                            if (!capabilities.supportsEssentialProperty(essentialProperties[i])) {
+                                logger.debug('[Stream] EssentialProperty not supported: ' + essentialProperties[i].schemeIdUri);
+                                return false;
+                            }
+                            i += 1;
+                        }
+                    }
 
-            as.Representation_asArray = as.Representation_asArray.filter((representation) => {
-                return !customCapabilitiesFilters.some(customFilter => !customFilter(representation));
+                    return true;
+                });
+
+                return as.Representation_asArray && as.Representation_asArray.length > 0;
             });
+        });
+
+    }
+
+    function _applyCustomFilters(manifest) {
+        if (!customCapabilitiesFilters || customCapabilitiesFilters.length === 0 || !manifest || !manifest.Period_asArray || manifest.Period_asArray.length === 0) {
+            return;
+        }
+
+        manifest.Period_asArray.forEach((period) => {
+            period.AdaptationSet_asArray = period.AdaptationSet_asArray.filter((as) => {
+
+                if (!as.Representation_asArray || as.Representation_asArray.length === 0) {
+                    return true;
+                }
+
+                as.Representation_asArray = as.Representation_asArray.filter((representation) => {
+                    return !customCapabilitiesFilters.some(customFilter => !customFilter(representation));
+                });
 
-            return as.Representation_asArray && as.Representation_asArray.length > 0;
+                return as.Representation_asArray && as.Representation_asArray.length > 0;
+            });
         });
     }
 
@@ -138,7 +252,7 @@ function CapabilitiesFilter() {
 
     instance = {
         setConfig,
-        filterUnsupportedFeaturesOfPeriod,
+        filterUnsupportedFeatures,
         setCustomCapabilitiesFilters
     };
 
diff --git a/src/streaming/utils/LiveEdgeFinder.js b/src/streaming/utils/LiveEdgeFinder.js
deleted file mode 100644
index 5994d0370a..0000000000
--- a/src/streaming/utils/LiveEdgeFinder.js
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * The copyright in this software is being made available under the BSD License,
- * included below. This software may be subject to other third party and contributor
- * rights, including patent rights, and no such rights are granted under this license.
- *
- * Copyright (c) 2013, Dash Industry Forum.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *  * Redistributions of source code must retain the above copyright notice, this
- *  list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright notice,
- *  this list of conditions and the following disclaimer in the documentation and/or
- *  other materials provided with the distribution.
- *  * Neither the name of Dash Industry Forum nor the names of its
- *  contributors may be used to endorse or promote products derived from this software
- *  without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
- *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- *  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- */
-import FactoryMaker from '../../core/FactoryMaker';
-import Constants from '../constants/Constants';
-
-/**
- * @param {Object} config
- * @returns {{initialize: initialize, getLiveEdge: getLiveEdge, reset: reset}|*}
- * @constructor
- * @ignore
- */
-function LiveEdgeFinder(config) {
-
-    config = config || {};
-    let instance;
-    let timelineConverter = config.timelineConverter;
-
-    function checkConfig() {
-        if (!timelineConverter || !timelineConverter.hasOwnProperty('getExpectedLiveEdge')) {
-            throw new Error(Constants.MISSING_CONFIG_ERROR);
-        }
-    }
-
-    function getLiveEdge(representationInfo) {
-        checkConfig();
-        return representationInfo.DVRWindow ? representationInfo.DVRWindow.end : 0;
-    }
-
-    function reset() {
-        timelineConverter = null;
-    }
-
-    instance = {
-        getLiveEdge: getLiveEdge,
-        reset: reset
-    };
-
-    return instance;
-}
-
-LiveEdgeFinder.__dashjs_factory_name = 'LiveEdgeFinder';
-export default FactoryMaker.getClassFactory(LiveEdgeFinder);
diff --git a/test/unit/Streaming.StreamProcessor.js b/test/unit/Streaming.StreamProcessor.js
index 2f7acc1eb6..638b2af66a 100644
--- a/test/unit/Streaming.StreamProcessor.js
+++ b/test/unit/Streaming.StreamProcessor.js
@@ -1,27 +1,7 @@
 import StreamProcessor from '../../src/streaming/StreamProcessor';
 import Constants from '../../src/streaming/constants/Constants';
-import EventBus from '../../src/core/EventBus';
-import Events from '../../src/core/events/Events';
-
-import ObjectsHelper from './helpers/ObjectsHelper';
-
-import DashMetricsMock from './mocks/DashMetricsMock';
-import ManifestModelMock from './mocks/ManifestModelMock';
-import PlaybackControllerMock from './mocks/PlaybackControllerMock';
-import AbrControllerMock from './mocks/AbrControllerMock';
-import AdapterMock from './mocks/AdapterMock';
-
 const expect = require('chai').expect;
-const testType = 'video';
-const objectsHelper = new ObjectsHelper();
 const context = {};
-const dashMetricsMock = new DashMetricsMock();
-const manifestModelMock = new ManifestModelMock();
-const timelineConverterMock = objectsHelper.getDummyTimelineConverter();
-const playbackControllerMock = new PlaybackControllerMock();
-const abrControllerMock = new AbrControllerMock();
-const adapterMock = new AdapterMock();
-const eventBus = EventBus(context).getInstance();
 
 const streamInfo = {
     id: 'streamId',
@@ -42,22 +22,8 @@ describe('StreamProcessor', function () {
             streamProcessor.reset();
         });
 
-        it('setBufferingTime should not throw an error', function () {
-            expect(streamProcessor.setBufferingTime.bind(streamProcessor)).to.not.throw();
-        });
-
-        it('getInitRequest should return null', function () {
-            const initRequest = streamProcessor.getInitRequest(0);
-            expect(initRequest).to.be.null; // jshint ignore:line
-        });
-
-        it('getInitRequest should throw an error when quality is not a number', function () {
-            expect(streamProcessor.getInitRequest.bind(streamProcessor, {})).to.be.throw(Constants.BAD_ARGUMENT_ERROR + ' : argument is not an integer');
-        });
-
-        it('getFragmentRequest should return null', function () {
-            const nextFragRequest = streamProcessor.getFragmentRequest();
-            expect(nextFragRequest).to.be.null; // jshint ignore:line
+        it('setExplicitBufferingTime should not throw an error', function () {
+            expect(streamProcessor.setExplicitBufferingTime.bind(streamProcessor)).to.not.throw();
         });
 
         it('getRepresentationInfo should throw an error when quality is not a number', function () {
@@ -65,52 +31,4 @@ describe('StreamProcessor', function () {
         });
     });
 
-    it('when a BUFFER_LEVEL_UPDATED event occurs, should update dvr info metrics', function () {
-        const streamProcessor = StreamProcessor(context).create({
-            streamInfo: streamInfo,
-            type: testType,
-            dashMetrics: dashMetricsMock,
-            manifestModel: manifestModelMock,
-            playbackController: playbackControllerMock,
-            timelineConverter: timelineConverterMock,
-            abrController: abrControllerMock,
-            adapter: adapterMock
-        });
-
-        streamProcessor.initialize();
-
-        let dvrInfo = dashMetricsMock.getCurrentDVRInfo();
-        expect(dvrInfo).to.be.null; // jshint ignore:line
-
-        eventBus.trigger(Events.BUFFER_LEVEL_UPDATED, {streamId: streamInfo.id, mediaType: testType, bufferLevel: 50});
-
-        dvrInfo = dashMetricsMock.getCurrentDVRInfo();
-        expect(dvrInfo).not.to.be.null; // jshint ignore:line
-        expect(dvrInfo.type).to.equal(testType); // jshint ignore:line
-    });
-
-    it('when a BUFFER_LEVEL_UPDATED event occurs for a non active stream it should not update dvr info metrics', function () {
-        streamInfo.id = 'wrongId';
-        dashMetricsMock.resetCurrentDvrWindow();
-        const streamProcessor = StreamProcessor(context).create({
-            streamInfo: streamInfo,
-            type: testType,
-            dashMetrics: dashMetricsMock,
-            manifestModel: manifestModelMock,
-            playbackController: playbackControllerMock,
-            timelineConverter: timelineConverterMock,
-            abrController: abrControllerMock,
-            adapter: adapterMock
-        });
-
-        streamProcessor.initialize();
-
-        let dvrInfo = dashMetricsMock.getCurrentDVRInfo();
-        expect(dvrInfo).to.be.null; // jshint ignore:line
-
-        eventBus.trigger(Events.BUFFER_LEVEL_UPDATED, {streamId: streamInfo.id, mediaType: testType, bufferLevel: 50});
-
-        dvrInfo = dashMetricsMock.getCurrentDVRInfo();
-        expect(dvrInfo).to.be.null; // jshint ignore:line
-    });
 });
diff --git a/test/unit/dash.DashHandler.js b/test/unit/dash.DashHandler.js
index 41e5a9e7a5..096f3f8e8b 100644
--- a/test/unit/dash.DashHandler.js
+++ b/test/unit/dash.DashHandler.js
@@ -1,7 +1,6 @@
 import DashHandler from '../../src/dash/DashHandler';
 import Constants from '../../src/streaming/constants/Constants';
 import DashConstants from '../../src/dash/constants/DashConstants';
-import Settings from '../../src/core/Settings';
 import Events from '../../src/core/events/Events';
 import EventBus from '../../src/core/EventBus';
 import Debug from '../../src/core/Debug';
@@ -10,7 +9,6 @@ import MediaPlayerEvents from '../../src/streaming/MediaPlayerEvents';
 
 import ObjectsHelper from './helpers/ObjectsHelper';
 import VoHelper from './helpers/VOHelper';
-import MediaPlayerModelMock from './mocks/MediaPlayerModelMock';
 import DashMetricsMock from './mocks/DashMetricsMock';
 
 const expect = require('chai').expect;
@@ -22,7 +20,6 @@ describe('DashHandler', function () {
     // Arrange
     const context = {};
     const testType = Constants.VIDEO;
-    const settings = Settings(context).getInstance();
     const eventBus = EventBus(context).getInstance();
     const debug = Debug(context).getInstance();
 
@@ -31,23 +28,21 @@ describe('DashHandler', function () {
     const timelineConverter = objectsHelper.getDummyTimelineConverter();
     const streamProcessor = objectsHelper.getDummyStreamProcessor(testType);
     const baseURLController = objectsHelper.getDummyBaseURLController();
-    const mediaPlayerModel = new MediaPlayerModelMock();
-    const dashMetricsMock = new DashMetricsMock();
+    const segmentsController = objectsHelper.getDummySegmentsController();
+    const dashMetrics = new DashMetricsMock();
+
 
     const config = {
-        streamInfo: { id: 'id' },
-        type: 'video',
-        mimeType: streamProcessor.getMediaInfo().mimeType,
-        timelineConverter: timelineConverter,
-        baseURLController: baseURLController,
-        mediaPlayerModel: mediaPlayerModel,
-        dashMetrics: dashMetricsMock,
-        settings: settings,
-        eventBus: eventBus,
+        eventBus,
         events: Events,
-        debug: debug,
-        dashConstants: DashConstants,
-        urlUtils: URLUtils(context).getInstance()
+        debug,
+        urlUtils: URLUtils(context).getInstance(),
+        type: 'video',
+        streamInfo: { id: 'id' },
+        segmentsController,
+        timelineConverter,
+        baseURLController,
+        dashMetrics
     };
 
     const dashHandler = DashHandler(context).create(config);
diff --git a/test/unit/dash.SegmentBaseLoader.js b/test/unit/dash.SegmentBaseLoader.js
index 485f2d75a6..c430abae75 100644
--- a/test/unit/dash.SegmentBaseLoader.js
+++ b/test/unit/dash.SegmentBaseLoader.js
@@ -17,24 +17,6 @@ let segmentBaseLoader;
 const eventBus = EventBus(context).getInstance();
 
 describe('SegmentBaseLoader', function () {
-    describe('Not well initialized', function () {
-        beforeEach(function () {
-            segmentBaseLoader = SegmentBaseLoader(context).getInstance();
-            segmentBaseLoader.initialize();
-        });
-
-        afterEach(function () {
-            segmentBaseLoader.reset();
-        });
-
-        it('should throw an exception when attempting to call loadInitialization While the setConfig function was not called, and parameters are undefined', function () {
-            expect(segmentBaseLoader.loadInitialization.bind(segmentBaseLoader)).to.throw('setConfig function has to be called previously');
-        });
-
-        it('should throw an exception when attempting to call loadSegments While the setConfig function was not called, and parameters are undefined', function () {
-            expect(segmentBaseLoader.loadSegments.bind(segmentBaseLoader)).to.throw('setConfig function has to be called previously');
-        });
-    });
 
     describe('Well initialized', function () {
         beforeEach(function () {
@@ -57,25 +39,27 @@ describe('SegmentBaseLoader', function () {
             segmentBaseLoader.reset();
         });
 
-        it('should trigger INITIALIZATION_LOADED event when loadInitialization function is called without representation parameter', function (done) {
-            const onInitLoaded = function () {
-                eventBus.off(Events.INITIALIZATION_LOADED, onInitLoaded);
-                done();
-            };
-            eventBus.on(Events.INITIALIZATION_LOADED, onInitLoaded, this);
-            segmentBaseLoader.loadInitialization();
+        it('should work if loadInitialization function is called without representation parameter', function (done) {
+            segmentBaseLoader.loadInitialization()
+                .then(() => {
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should trigger SEGMENTS_LOADED event with an error when loadSegments function is called without representation parameter', function (done) {
-            const onSegmentLoaded = function (e) {
-                eventBus.off(Events.SEGMENTS_LOADED, onSegmentLoaded);
-                expect(e.error).not.to.equal(undefined);
-                expect(e.error.code).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_CODE);
-                expect(e.error.message).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE);
-                done();
-            };
-            eventBus.on(Events.SEGMENTS_LOADED, onSegmentLoaded, this);
-            segmentBaseLoader.loadSegments();
+            segmentBaseLoader.loadSegments()
+                .then((e) => {
+                    expect(e.error).not.to.equal(undefined);
+                    expect(e.error.code).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_CODE);
+                    expect(e.error.message).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
     });
-});
\ No newline at end of file
+});
diff --git a/test/unit/dash.WebSegmentBaseLoader.js b/test/unit/dash.WebSegmentBaseLoader.js
index ba98821cd1..a57d092dda 100644
--- a/test/unit/dash.WebSegmentBaseLoader.js
+++ b/test/unit/dash.WebSegmentBaseLoader.js
@@ -41,13 +41,6 @@ describe('WebmSegmentBaseLoader', function () {
         afterEach(function () {
             webmSegmentBaseLoader.reset();
         });
-        it('should throw an exception when attempting to call loadInitialization While the setConfig function was not called, and parameters are undefined', function () {
-            expect(webmSegmentBaseLoader.loadInitialization.bind(webmSegmentBaseLoader)).to.throw('setConfig function has to be called previously');
-        });
-
-        it('should throw an exception when attempting to call loadSegments While the setConfig function was not called, and parameters are undefined', function () {
-            expect(webmSegmentBaseLoader.loadSegments.bind(webmSegmentBaseLoader)).to.throw('setConfig function has to be called previously');
-        });
 
         it('should throw an exception when attempting to call setConfig with an empty config parameter or malformed', function () {
             expect(webmSegmentBaseLoader.setConfig.bind(webmSegmentBaseLoader, {})).to.throw(Constants.MISSING_CONFIG_ERROR);
@@ -77,27 +70,31 @@ describe('WebmSegmentBaseLoader', function () {
 
         it('should trigger INITIALIZATION_LOADED event when loadInitialization function is called without representation parameter', function (done) {
             const self = this.test.ctx;
-            const onInitLoaded = function () {
-                eventBus.off(Events.INITIALIZATION_LOADED, onInitLoaded);
-                done();
-            };
-            eventBus.on(Events.INITIALIZATION_LOADED, onInitLoaded, this);
-            webmSegmentBaseLoader.loadInitialization();
+            webmSegmentBaseLoader.loadInitialization()
+                .then(() => {
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
             self.requests[0].respond(200);
         });
 
         it('should trigger SEGMENTS_LOADED event with an error when loadSegments function is called without representation parameter', function (done) {
             const self = this.test.ctx;
-            const onSegmentLoaded = function (e) {
-                eventBus.off(Events.SEGMENTS_LOADED, onSegmentLoaded);
-                expect(e.error).not.to.equal(undefined);
-                expect(e.error.code).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_CODE);
-                expect(e.error.message).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE);
-                done();
-            };
-            eventBus.on(Events.SEGMENTS_LOADED, onSegmentLoaded, this);
-            webmSegmentBaseLoader.loadSegments();
+
+            webmSegmentBaseLoader.loadSegments()
+                .then((e) => {
+                    expect(e.error).not.to.equal(undefined);
+                    expect(e.error.code).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_CODE);
+                    expect(e.error.message).to.equal(Errors.SEGMENT_BASE_LOADER_ERROR_MESSAGE);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
+
             self.requests[0].respond(200);
         });
     });
-});
\ No newline at end of file
+});
diff --git a/test/unit/dash.controllers.RepresentationController.js b/test/unit/dash.controllers.RepresentationController.js
index 301c43303e..f15a8d65f3 100644
--- a/test/unit/dash.controllers.RepresentationController.js
+++ b/test/unit/dash.controllers.RepresentationController.js
@@ -13,6 +13,7 @@ import SpecHelper from './helpers/SpecHelper';
 import AbrControllerMock from './mocks/AbrControllerMock';
 import PlaybackControllerMock from './mocks/PlaybackControllerMock';
 import DashMetricsMock from './mocks/DashMetricsMock';
+import SegmentsControllerMock from './mocks/SegmentsControllerMock';
 
 const chai = require('chai');
 const spies = require('chai-spies');
@@ -42,6 +43,7 @@ describe('RepresentationController', function () {
     const abrControllerMock = new AbrControllerMock();
     const playbackControllerMock = new PlaybackControllerMock();
     const dashMetricsMock = new DashMetricsMock();
+    const segmentsController = new SegmentsControllerMock();
 
     abrControllerMock.registerStreamType();
 
@@ -78,6 +80,7 @@ describe('RepresentationController', function () {
             representationController = RepresentationController(context).create({
                 streamInfo: streamProcessor.getStreamInfo(),
                 abrController: abrControllerMock,
+                segmentsController,
                 timelineConverter: timelineConverter,
                 playbackController: playbackControllerMock,
                 dashMetrics: dashMetricsMock,
@@ -93,26 +96,6 @@ describe('RepresentationController', function () {
             representationController = null;
         });
 
-        describe('when data update started', function () {
-            let spy;
-
-            beforeEach(function () {
-                spy = chai.spy();
-                eventBus.on(Events.DATA_UPDATE_STARTED, spy);
-            });
-
-            afterEach(function () {
-                eventBus.off(Events.DATA_UPDATE_STARTED, spy);
-            });
-
-            it('should fire dataUpdateStarted event when new data is set', function () {
-                // Act
-                representationController.updateData(data, voRepresentations, testType, 0);
-
-                // Assert
-                expect(spy).to.have.been.called.exactly(1);
-            });
-        });
 
         describe('when data update completed', function () {
             beforeEach(function (done) {
@@ -149,23 +132,6 @@ describe('RepresentationController', function () {
                 expect(currentRepresentation.adaptation.period.duration).to.equal(150); // jshint ignore:line
             });
 
-            it('when a WALLCLOCK_TIME_UPDATED event occurs, should update availability window for dynamic content', function () {
-                const firstRepresentation = representationController.getRepresentationForQuality(0);
-
-                expect(firstRepresentation.segmentAvailabilityRange.start).to.equal(undefined); // jshint ignore:line
-                expect(firstRepresentation.segmentAvailabilityRange.end).to.equal(undefined); // jshint ignore:line
-
-                timelineConverter.setRange({start: 0, end: 4});
-
-                eventBus.trigger(Events.WALLCLOCK_TIME_UPDATED, {
-                    isDynamic: true,
-                    time: new Date()
-                });
-
-                expect(firstRepresentation.segmentAvailabilityRange.start).to.equal(0); // jshint ignore:line
-                expect(firstRepresentation.segmentAvailabilityRange.end).to.equal(4); // jshint ignore:line
-            });
-
             it('when a QUALITY_CHANGE_REQUESTED event occurs, should update current representation', function () {
                 let currentRepresentation = representationController.getCurrentRepresentation();
                 expect(currentRepresentation.index).to.equal(0); // jshint ignore:line
@@ -176,13 +142,6 @@ describe('RepresentationController', function () {
                 expect(currentRepresentation.index).to.equal(1); // jshint ignore:line
             });
 
-            it('when a REPRESENTATION_UPDATE_COMPLETED event occurs, should notify data update completed', function () {
-                let spy = chai.spy();
-                eventBus.on(Events.DATA_UPDATE_COMPLETED, spy);
-
-                eventBus.trigger(Events.REPRESENTATION_UPDATE_COMPLETED, {sender: { getType() { return testType;}, getStreamInfo() { return streamProcessor.getStreamInfo(); }}, representation: voRepresentations[1]});
-                expect(spy).to.have.been.called.exactly(1);
-            });
         });
 
         describe('when a call to reset is done', function () {
diff --git a/test/unit/dash.controllers.SegmentsController.js b/test/unit/dash.controllers.SegmentsController.js
index 0d6faf5d1a..f7041bafb9 100644
--- a/test/unit/dash.controllers.SegmentsController.js
+++ b/test/unit/dash.controllers.SegmentsController.js
@@ -67,7 +67,4 @@ describe('SegmentsController', function () {
         expect(s).to.be.null; // jshint ignore:line
     });
 
-    it('update should not throw an error even if no parameter is defined', function () {
-        expect(segmentsController.update.bind(segmentsController)).not.to.throw();
-    });
 });
diff --git a/test/unit/dash.utils.TemplateSegmentsGetter.js b/test/unit/dash.utils.TemplateSegmentsGetter.js
index 11594bbcb4..3b35c4f725 100644
--- a/test/unit/dash.utils.TemplateSegmentsGetter.js
+++ b/test/unit/dash.utils.TemplateSegmentsGetter.js
@@ -42,7 +42,7 @@ describe('TemplateSegmentsGetter', () => {
     describe('availableSegmentsNumber calculation', () => {
         it('should set availableSegmentsNumber as 1 if duration is not defined', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = undefined;
 
             templateSegmentsGetter.getSegmentByIndex(representation, 0);
@@ -51,7 +51,7 @@ describe('TemplateSegmentsGetter', () => {
 
         it('should calculate representation segment range correctly', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = 5;
 
             templateSegmentsGetter.getSegmentByIndex(representation, 0);
@@ -62,7 +62,7 @@ describe('TemplateSegmentsGetter', () => {
     describe('getSegmentByIndex', () => {
         it('should return segment given an index', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = 1;
 
             let seg = templateSegmentsGetter.getSegmentByIndex(representation, 0);
@@ -83,7 +83,7 @@ describe('TemplateSegmentsGetter', () => {
 
         it('should return null if segment is out of range', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = 5;
 
             let seg = templateSegmentsGetter.getSegmentByIndex(representation, 1 + 100 / 5);
@@ -94,7 +94,7 @@ describe('TemplateSegmentsGetter', () => {
     describe('getSegmentByTime', () => {
         it('should return null if segment duration is not defined', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = undefined;
 
             let seg = templateSegmentsGetter.getSegmentByTime(representation, 0);
@@ -103,7 +103,7 @@ describe('TemplateSegmentsGetter', () => {
 
         it('should return segment by time', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = 5;
 
             let seg = templateSegmentsGetter.getSegmentByTime(representation, 0);
@@ -129,7 +129,7 @@ describe('TemplateSegmentsGetter', () => {
 
         it('should return null if segment is out of range', () => {
             const representation = voHelper.getDummyRepresentation(Constants.VIDEO);
-            representation.segmentAvailabilityRange = {start: 0, end: 100};
+            representation.segmentAvailabilityWindow = {start: 0, end: 100};
             representation.segmentDuration = 5;
 
             let seg = templateSegmentsGetter.getSegmentByTime(representation, 110);
diff --git a/test/unit/dash.utils.TimelineConverter.js b/test/unit/dash.utils.TimelineConverter.js
index 2dc15fc80b..f725c94def 100644
--- a/test/unit/dash.utils.TimelineConverter.js
+++ b/test/unit/dash.utils.TimelineConverter.js
@@ -1,9 +1,8 @@
-import EventBus from '../../src/core/EventBus';
 import TimelineConverter from '../../src/dash/utils/TimelineConverter';
-import Events from '../../src/core/events/Events';
-
 import SpecHelper from './helpers/SpecHelper';
 import VoHelper from './helpers/VOHelper';
+import Settings from '../../src/core/Settings';
+import StreamMock from './mocks/StreamMock';
 
 const expect = require('chai').expect;
 const sinon = require('sinon');
@@ -13,17 +12,16 @@ describe('TimelineConverter', function () {
     const testType = 'video';
     const voHelper = new VoHelper();
     const specHelper = new SpecHelper();
-    const eventBus = EventBus(context).getInstance();
-    const representation = voHelper.getDummyRepresentation(testType);
     const timelineConverter = TimelineConverter(context).getInstance();
+    const settings = Settings(context).getInstance();
+    let representation;
+    let timelineRepresentation;
 
     timelineConverter.initialize();
 
-    it('should set an expected live edge', function () {
-        const expectedValue = 10;
-
-        timelineConverter.setExpectedLiveEdge(expectedValue);
-        expect(timelineConverter.getExpectedLiveEdge()).to.be.equal(expectedValue);
+    beforeEach(() => {
+        representation = voHelper.getDummyRepresentation(testType);
+        timelineRepresentation = voHelper.getDummyTimelineRepresentation(testType);
     });
 
     it('should calculate presentation time from media time', function () {
@@ -46,39 +44,1285 @@ describe('TimelineConverter', function () {
         expect(timelineConverter.calcPresentationTimeFromWallTime(wallClock, representation.adaptation.period)).to.be.equal(expectedValue);
     });
 
-    it('should calculate availability window for static mpd', function () {
+    describe('should calcAvailabilityStartTimeFromPresentationTime() for a segment and ', () => {
+
+        describe('a static MPD and ', () => {
+
+            before(() => {
+                settings.update({
+                    streaming: {
+                        calcSegmentAvailabilityRangeFromTimeline: false
+                    }
+                });
+            });
+
+            beforeEach(() => {
+                representation.adaptation.period.mpd.manifest.type = 'static';
+
+            });
+
+            it('an init segment', function () {
+                representation.adaptation.period.start = 0;
+                representation.adaptation.period.duration = 100;
+                const presentationStartTime = representation.adaptation.period.start;
+
+                const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, representation, false);
+                expect(ast.getTime()).to.be.equal(new Date(representation.adaptation.period.mpd.availabilityStartTime).getTime());
+            });
+
+            it('an init segment and period@start > 0', function () {
+                representation.adaptation.period.start = 10;
+                representation.adaptation.period.duration = 100;
+                const presentationStartTime = representation.adaptation.period.start;
+
+                const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, representation, false);
+                expect(ast.getTime()).to.be.equal(new Date(representation.adaptation.period.mpd.availabilityStartTime).getTime());
+            });
+
+            it('media segment with presentationEndTime inside period boundary and period start set to 0', function () {
+                representation.adaptation.period.start = 0;
+                representation.adaptation.period.duration = 100;
+                const presentationEndTime = 8;
+
+                const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, false);
+                expect(ast.getTime()).to.be.equal(new Date(representation.adaptation.period.mpd.availabilityStartTime).getTime());
+            });
+
+            it('media segment with presentationEndTime inside period boundary and period start > 0', function () {
+                representation.adaptation.period.start = 10;
+                representation.adaptation.period.duration = 100;
+                const presentationEndTime = 20;
+
+                const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, false);
+                expect(ast.getTime()).to.be.equal(new Date(representation.adaptation.period.mpd.availabilityStartTime).getTime());
+            });
+
+
+        });
+
+        describe('a dynamic MPD and ', () => {
+
+            before(() => {
+                settings.update({
+                    streaming: {
+                        calcSegmentAvailabilityRangeFromTimeline: false
+                    }
+                });
+            });
+
+            beforeEach(function () {
+                representation.adaptation.period.mpd.manifest.type = 'dynamic';
+            });
+
+
+            describe('SegmentTemplate and ', function () {
+
+                it('an init segment', function () {
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationStartTime = representation.adaptation.period.start;
+
+                    const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, representation, true);
+                    expect(ast.getTime()).to.be.equal(new Date(representation.adaptation.period.mpd.availabilityStartTime).getTime());
+                });
 
-        representation.adaptation.period.start = 0;
-        representation.adaptation.period.duration = 100;
-        representation.adaptation.period.mpd.manifest.type = 'static';
-        const range = timelineConverter.calcSegmentAvailabilityRange(representation, false);
-        expect(range.start).to.be.equal(representation.adaptation.period.start);
-        expect(range.end).to.be.equal(representation.adaptation.period.duration);
+                it('an init segment and period@start > 0', function () {
+                    representation.adaptation.period.start = 10;
+                    representation.adaptation.period.duration = 100;
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationStartTime = representation.adaptation.period.start;
+
+                    const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationStartTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationStartTime);
+                    expect(ast.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+                it('a media segment and period@start > 0', function () {
+                    representation.adaptation.period.start = 10;
+                    representation.adaptation.period.duration = 100;
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationEndTime = representation.adaptation.period.start + 8;
+
+                    const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationEndTime);
+                    expect(ast.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+                it('a media segment and period@start > 0 and availabilityTimeOffset > 0', function () {
+                    representation.adaptation.period.start = 10;
+                    representation.adaptation.period.duration = 100;
+                    representation.availabilityTimeOffset = 10;
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationEndTime = representation.adaptation.period.start + 8;
+
+                    const ast = timelineConverter.calcAvailabilityStartTimeFromPresentationTime(presentationEndTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationEndTime - representation.availabilityTimeOffset);
+                    expect(ast.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+
+            });
+
+            describe('with SegmentTimeline and shouldCalculateFromTimeline is true', function () {
+
+                before(() => {
+                    settings.update({
+                        streaming: {
+                            calcSegmentAvailabilityRangeFromTimeline: true
+                        }
+                    });
+                });
+            });
+        });
     });
 
-    describe('when time sync is complete', function () {
-        let updateCompleted;
+    describe('should calcAvailabilityEndTimeFromPresentationTime() for a segment and ', () => {
+
+        describe('a static MPD and ', () => {
+
+            before(() => {
+                settings.update({
+                    streaming: {
+                        calcSegmentAvailabilityRangeFromTimeline: false
+                    }
+                });
+            });
+
+            beforeEach(() => {
+                representation.adaptation.period.mpd.manifest.type = 'static';
+            });
+
+            it('an init segment', function () {
+                representation.adaptation.period.start = 0;
+                representation.adaptation.period.duration = 100;
+                const presentationEndTime = representation.adaptation.period.start + representation.adaptation.period.start;
+
+                const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, false);
+                expect(aet).to.be.equal(representation.adaptation.period.mpd.availabilityEndTime);
+            });
+
+            it('an init segment and period@start > 0', function () {
+                representation.adaptation.period.start = 10;
+                representation.adaptation.period.duration = 100;
+                const presentationEndTime = representation.adaptation.period.start + representation.adaptation.period.start;
+
+                const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, false);
+                expect(aet).to.be.equal(representation.adaptation.period.mpd.availabilityEndTime);
+            });
+
+            it('media segment with presentationEndTime inside period boundary and period start set to 0', function () {
+                representation.adaptation.period.start = 0;
+                representation.adaptation.period.duration = 100;
+                const presentationEndTime = 8;
+
+                const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, false);
+                expect(aet).to.be.equal(representation.adaptation.period.mpd.availabilityEndTime);
+            });
+
+            it('media segment with presentationEndTime inside period boundary and period start > 0', function () {
+                representation.adaptation.period.start = 10;
+                representation.adaptation.period.duration = 100;
+                const presentationEndTime = 20;
+
+                const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, false);
+                expect(aet).to.be.equal(representation.adaptation.period.mpd.availabilityEndTime);
+            });
+
 
-        beforeEach(function (done) {
-            updateCompleted = false;
-            setTimeout(() => {
-                eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED, {offset: 0});
-                updateCompleted = true;
-                done();
-            }, specHelper.getExecutionDelay());
         });
 
+        describe('a dynamic MPD and ', () => {
+
+            before(() => {
+                settings.update({
+                    streaming: {
+                        calcSegmentAvailabilityRangeFromTimeline: false
+                    }
+                });
+            });
+
+
+
+            describe('SegmentTemplate and ', function () {
+
+                it('an init segment', function () {
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationEndTime = representation.adaptation.period.start + representation.adaptation.period.duration;
+
+                    const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationEndTime + representation.adaptation.period.mpd.timeShiftBufferDepth);
+                    expect(aet.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+                it('an init segment and period@start > 0', function () {
+                    representation.adaptation.period.start = 10;
+                    representation.adaptation.period.duration = 100;
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationEndTime = representation.adaptation.period.start + representation.adaptation.period.duration;
+
+                    const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationEndTime + representation.adaptation.period.mpd.timeShiftBufferDepth);
+                    expect(aet.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+                it('a media segment and period@start > 0', function () {
+                    representation.adaptation.period.start = 10;
+                    representation.adaptation.period.duration = 100;
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationEndTime = representation.adaptation.period.start + 8;
+
+                    const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationEndTime + representation.adaptation.period.mpd.timeShiftBufferDepth);
+                    expect(aet.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+                it('a media segment and period@start > 0 and availabilityTimeOffset > 0', function () {
+                    representation.adaptation.period.start = 10;
+                    representation.adaptation.period.duration = 100;
+                    representation.availabilityTimeOffset = 10;
+                    representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
+                    const presentationEndTime = representation.adaptation.period.start + 8;
+
+                    const aet = timelineConverter.calcAvailabilityEndTimeFromPresentationTime(presentationEndTime, representation, true);
+                    const targetDate = new Date(representation.adaptation.period.mpd.availabilityStartTime);
+                    targetDate.setSeconds(targetDate.getSeconds() + presentationEndTime + representation.adaptation.period.mpd.timeShiftBufferDepth);
+                    expect(aet.getTime()).to.be.equal(targetDate.getTime());
+                });
+
+
+            });
+
+            describe('with SegmentTimeline and shouldCalculateFromTimeline is true', function () {
+
+                before(() => {
+                    settings.update({
+                        streaming: {
+                            calcSegmentAvailabilityRangeFromTimeline: true
+                        }
+                    });
+                });
+            });
+        });
+    });
+
+
+    describe('should calculate the time shift buffer window', () => {
+
+        let streamOneMock;
+        let streamTwoMock;
+        let streams;
+
+        beforeEach(() => {
+            streamOneMock = new StreamMock();
+            streamOneMock.setStreamInfo({
+                start: 0,
+                duration: 50
+            });
+            streamTwoMock = new StreamMock();
+            streamTwoMock.setStreamInfo({
+                start: 50,
+                duration: 50
+            });
+            streams = [];
+        });
+
+        describe('for a static MPD', () => {
+
+            it('with SegmentTemplate and one period', function () {
+                streams.push(streamOneMock);
+                const range = timelineConverter.calcTimeShiftBufferWindow(streams, false);
+                expect(range.start).to.be.equal(0);
+                expect(range.end).to.be.equal(50);
+            });
+
+            it('with SegmentTemplate and two periods', function () {
+                streams.push(streamOneMock, streamTwoMock);
+                const range = timelineConverter.calcTimeShiftBufferWindow(streams, false);
+                expect(range.start).to.be.equal(0);
+                expect(range.end).to.be.equal(100);
+            });
+
+            it('with SegmentTimeline and one period and shouldCalculateFromTimeline set to true', function () {
+                settings.update({
+                    streaming: {
+                        calcSegmentAvailabilityRangeFromTimeline: true
+                    }
+                });
+                streams.push(streamOneMock);
+                const range = timelineConverter.calcTimeShiftBufferWindow(streams, false);
+                expect(range.start).to.be.equal(0);
+                expect(range.end).to.be.equal(50);
+            });
+
+            it('with SegmentTimeline and two periods and shouldCalculateFromTimeline set to true', function () {
+                settings.update({
+                    streaming: {
+                        calcSegmentAvailabilityRangeFromTimeline: true
+                    }
+                });
+                streams.push(streamOneMock, streamTwoMock);
+                const range = timelineConverter.calcTimeShiftBufferWindow(streams, false);
+                expect(range.start).to.be.equal(0);
+                expect(range.end).to.be.equal(100);
+            });
+        });
+
+        describe('for a dynamic MPD', () => {
+
+            describe('with SegmentTemplate', function () {
+
+                before(() => {
+                    settings.update({
+                        streaming: {
+                            calcSegmentAvailabilityRangeFromTimeline: false
+                        }
+                    });
+                });
+
+                it('with single period and period covering whole tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period and period start larger than AST', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 10,
+                        duration: 50
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(10);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period and period end smaller than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 20
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(20);
+                    clock.restore();
+                });
+
+                it('with single period and period end infinite', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period AST larger than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() + tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(-30);
+                    clock.restore();
+                });
+
+                it('with single period start larger than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 40,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(40);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period end smaller than now minus tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 5;
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 30 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
 
-        it('should calculate availability window for dynamic mpd', function () {
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.NaN; // jshint ignore:line
+                    expect(range.end).to.be.NaN; // jshint ignore:line
+                    clock.restore();
+                });
 
-            var clock = sinon.useFakeTimers(new Date().getTime());
-            representation.adaptation.period.mpd.availabilityStartTime = new Date(new Date().getTime() - representation.adaptation.period.mpd.timeShiftBufferDepth * 1000);
-            timelineConverter.setExpectedLiveEdge(100);
+                it('with two periods covering whole tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 100;
 
-            const range = timelineConverter.calcSegmentAvailabilityRange(representation, true);
-            expect(range.start).to.be.equal(0);
-            expect(range.end).to.be.equal(49);
-            clock.restore();
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(100);
+                    clock.restore();
+                });
+
+                it('with two periods and period start larger than AST', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 100;
+
+                    streamOneMock.setStreamInfo({
+                        start: 10,
+                        duration: 40
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(10);
+                    expect(range.end).to.be.equal(100);
+                    clock.restore();
+                });
+
+                it('with two periods and second period end smaller than tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 80;
+
+                    streamTwoMock.setStreamInfo({
+                        start: 50,
+                        duration: 20
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(70);
+                    clock.restore();
+                });
+
+                it('with two periods and second period end infinite', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 120;
+
+                    streamTwoMock.setStreamInfo({
+                        start: 50,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(120);
+                    clock.restore();
+                });
+
+                it('with two periods, both start times larger than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 40,
+                        duration: 10
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(40);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with two periods, end time of second period larger than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 80,
+                        duration: 10
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(10);
+                    clock.restore();
+                });
+
+                it('with two periods both ending before tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 5;
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 10
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 30 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+                    streams.push(streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.NaN; // jshint ignore:line
+                    expect(range.end).to.be.NaN; // jshint ignore:line
+                    clock.restore();
+                });
+            });
+            describe('with SegmentTimeline and calcSegmentAvailabilityRangeFromTimeline set to true', function () {
+
+                before(() => {
+                    settings.update({
+                        streaming: {
+                            calcSegmentAvailabilityRangeFromTimeline: true
+                        }
+                    });
+                });
+
+                beforeEach(() => {
+                    streamOneMock.setRepresentation(voHelper.getDummyTimelineRepresentation(testType));
+                    streamTwoMock.setRepresentation(voHelper.getDummyTimelineRepresentation(testType));
+                });
+
+                it('with single period and period covering whole tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period and period start greater than 0', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 10;
+                    dummyRep.adaptation.period.duration = 50;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 10,
+                        duration: 50
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(10);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period and period start greater than 0 and end infinite', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 10;
+                    dummyRep.adaptation.period.duration = Number.POSITIVE_INFINITY;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 10,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(10);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period and period end smaller than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 20;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 20
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(20);
+                    clock.restore();
+                });
+
+                it('with single period and period end out of the "normal" TSBD', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 20;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 20
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 2000 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(20);
+                    clock.restore();
+                });
+
+                it('with single period and last segments out of the "normal" TSBD', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 300;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 300
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 2000 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(20);
+                    expect(range.end).to.be.equal(50);
+                    clock.restore();
+                });
+
+                it('with single period and last segments out of the "normal" large TSBD', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 300;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 300;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 300
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 2000 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(50);
+                    clock.restore();
+                });
+
+                it('with single period and period end infinite', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 300;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = Number.POSITIVE_INFINITY;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(50);
+                    clock.restore();
+                });
+
+                it('with single period start larger than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 40;
+                    dummyRep.adaptation.period.duration = Number.POSITIVE_INFINITY;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 40,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(40);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with single period end smaller than now minus tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 5;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 30 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(5);
+                    expect(range.end).to.be.equal(10);
+                    clock.restore();
+                });
+
+                it('with two periods covering whole tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 20;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 20
+                    });
+
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with two periods and period start greater than 0', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 10;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 20;
+                    dummyRepTwo.adaptation.period.duration = 20;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 10,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 20,
+                        duration: 20
+                    });
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(10);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with two periods and period start greater than 0 and end infinite', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 50;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 10;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 20;
+                    dummyRepTwo.adaptation.period.duration = Number.POSITIVE_INFINITY;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 10,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 20,
+                        duration: Number.POSITIVE_INFINITY
+                    });
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(10);
+                    expect(range.end).to.be.equal(50);
+                    clock.restore();
+                });
+
+                it('with two periods and period end smaller than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 10;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 10
+                    });
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(20);
+                    clock.restore();
+                });
+
+                it('with two periods and period end out of the "normal" TSBD', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 20;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 20
+                    });
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 2000 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with two periods and last segments out of the "normal" TSBD', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 300;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 300
+                    });
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 2000 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(30);
+                    expect(range.end).to.be.equal(60);
+                    clock.restore();
+                });
+
+                it('with two periods and last segments out of the "normal" large TSBD', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 300;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 300;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 300
+                    });
+
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 2000 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(60);
+                    clock.restore();
+                });
+
+                it('with two periods no tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 300;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 300
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 300 * 1000),
+                            timeShiftBufferDepth: NaN
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(0);
+                    expect(range.end).to.be.equal(60);
+                    clock.restore();
+                });
+
+                it('with two periods start larger than now', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 30;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 40;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 50;
+                    dummyRepTwo.adaptation.period.duration = 300;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 40,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 50,
+                        duration: 300
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - tsbd * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(40);
+                    expect(range.end).to.be.equal(30);
+                    clock.restore();
+                });
+
+                it('with two periods end smaller than now minus tsbd', function () {
+                    const clock = sinon.useFakeTimers(new Date().getTime());
+                    const tsbd = 5;
+                    const dummyRep = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRep.adaptation.period.start = 0;
+                    dummyRep.adaptation.period.duration = 10;
+                    streamOneMock.setRepresentation(dummyRep);
+                    const dummyRepTwo = voHelper.getDummyTimelineRepresentation(testType);
+                    dummyRepTwo.adaptation.period.start = 10;
+                    dummyRepTwo.adaptation.period.duration = 10;
+                    streamTwoMock.setRepresentation(dummyRepTwo);
+
+                    streamOneMock.setStreamInfo({
+                        start: 0,
+                        duration: 10
+                    });
+                    streamTwoMock.setStreamInfo({
+                        start: 10,
+                        duration: 10
+                    });
+                    streamOneMock.setRegularPeriods([{
+                        mpd: {
+                            availabilityStartTime: new Date(new Date().getTime() - 30 * 1000),
+                            timeShiftBufferDepth: tsbd
+                        }
+                    }]);
+                    streams.push(streamOneMock, streamTwoMock);
+
+                    const range = timelineConverter.calcTimeShiftBufferWindow(streams, true);
+                    expect(range.start).to.be.equal(15);
+                    expect(range.end).to.be.equal(20);
+                    clock.restore();
+                });
+            });
         });
     });
 });
+
diff --git a/test/unit/helpers/MPDHelper.js b/test/unit/helpers/MPDHelper.js
index 237c17444d..260ea68de7 100644
--- a/test/unit/helpers/MPDHelper.js
+++ b/test/unit/helpers/MPDHelper.js
@@ -1,20 +1,22 @@
 import SpecHelper from './SpecHelper.js';
+import DashConstants from "../../../src/dash/constants/DashConstants";
 
 class MpdHelper {
     constructor() {
         this.SEGMENT_TEMPLATE = 0;
+        this.SEGMENT_TIMELINE = 1;
         this.idCounter = -1;
         this.baseUrl = 'https://dash.akamaized.net/envivio/dashpr/clear/Manifest.mpd';
         this.specHelper = new SpecHelper();
     }
 
-    getMpd(type) {
+    getMpd(type, segInfoType) {
         var mpd = {};
 
         mpd.type = type;
         mpd.minimumUpdatePeriod = 10;
         mpd.loadedTime = this.specHelper.getUnixTime();
-        mpd.Period_asArray = [this.composePeriod()];
+        mpd.Period_asArray = [this.composePeriod(segInfoType)];
 
         return mpd;
     }
@@ -69,10 +71,11 @@ class MpdHelper {
         return codecs;
     }
 
-    composePeriod() {
+    composePeriod(segInfoType) {
         var period = {};
+        let type = !isNaN(segInfoType) ? segInfoType : this.SEGMENT_TEMPLATE;
 
-        period.AdaptationSet_asArray = [this.getAdaptationForSegmentInfoType('video', this.SEGMENT_TEMPLATE)];
+        period.AdaptationSet_asArray = [this.getAdaptationForSegmentInfoType('video', type)];
 
         return period;
     }
@@ -191,6 +194,39 @@ class MpdHelper {
         return adaptation;
     }
 
+    addSegmentTimelineToAdaptation(adaptation) {
+        let objSegmentTemplate = {};
+        let reps = adaptation.Representation_asArray;
+        let ln = reps.length;
+        let i = 0;
+        let r;
+
+        objSegmentTemplate.__cnt = 6;
+        objSegmentTemplate.duration = 360000;
+        objSegmentTemplate.initialization = '$RepresentationID$/Header.m4s';
+        objSegmentTemplate.media = '$RepresentationID$/$Number$.m4s';
+        objSegmentTemplate.presentationTimeOffset = 0;
+        objSegmentTemplate.startNumber = 0;
+        objSegmentTemplate.timescale = 90000;
+        const S_asArray = [{
+            t: 0,
+            d: 180000,
+            r: 29
+        }];
+        objSegmentTemplate.SegmentTimeline_asArray= {S_asArray};
+        objSegmentTemplate.SegmentTimeline = {S_asArray};
+
+        adaptation.SegmentTemplate = objSegmentTemplate;
+        adaptation.SegmentTemplate_asArray = objSegmentTemplate;
+
+        for (i; i < ln; i++) {
+            r = reps[i];
+            r.SegmentTemplate = objSegmentTemplate;
+        }
+
+        return adaptation;
+    }
+
     getAdaptationForSegmentInfoType(type, segmentInfo) {
         var adaptation = this.composeAdaptation(type);
 
@@ -199,6 +235,10 @@ class MpdHelper {
                 adaptation = this.addSegmentTemplateToAdaptation(adaptation);
                 return adaptation;
             }
+            case this.SEGMENT_TIMELINE: {
+                adaptation = this.addSegmentTimelineToAdaptation(adaptation);
+                return adaptation;
+            }
             default: {
                 return null;
             }
diff --git a/test/unit/helpers/ObjectsHelper.js b/test/unit/helpers/ObjectsHelper.js
index 65e31684ea..a8bdd0308b 100644
--- a/test/unit/helpers/ObjectsHelper.js
+++ b/test/unit/helpers/ObjectsHelper.js
@@ -8,24 +8,34 @@ class ObjectsHelper {
 
         return {
             getType: () => type,
-            getCurrentTrack: () => {},
-            getStreamInfo: () => { return { id: 'DUMMY_STREAM-01', manifestInfo: {isDynamic: true} }; },
-            getMediaInfo: () => { return { bitrateList: [
-                                                { bandwidth: 1000000 },
-                                                { bandwidth: 2000000 },
-                                                { bandwidth: 3000000 },
-                                           ],
-                                           mimeType: "video/mp4" }}
+            getCurrentTrack: () => {
+            },
+            getStreamInfo: () => {
+                return {id: 'DUMMY_STREAM-01', manifestInfo: {isDynamic: true}};
+            },
+            getMediaInfo: () => {
+                return {
+                    bitrateList: [
+                        {bandwidth: 1000000},
+                        {bandwidth: 2000000},
+                        {bandwidth: 3000000},
+                    ],
+                    mimeType: "video/mp4"
+                }
+            }
         };
     }
 
     getDummyLogger() {
-        return (message) => { console.log(message); };
+        return (message) => {
+            console.log(message);
+        };
     }
 
     getDummyIndexHandler() {
         return {
-            updateRepresentation: () => {}
+            updateRepresentation: () => {
+            }
         };
     }
 
@@ -34,24 +44,42 @@ class ObjectsHelper {
         let end = undefined;
 
         return {
-            initialize: () => {},
-            reset: () => {},
-            getClientTimeOffset: () => {},
+            initialize: () => {
+            },
+            reset: () => {
+            },
+            getClientTimeOffset: () => {
+            },
             calcAvailabilityStartTimeFromPresentationTime: () => 0,
             calcAvailabilityEndTimeFromPresentationTime: () => 0,
             calcPeriodRelativeTimeFromMpdRelativeTime: () => NaN,
+            calcTimeShiftBufferWindow : () => {
+                return {start, end};
+            },
+            calcAvailabilityWindow  : () => {
+                return {start, end};
+            },
             calcMediaTimeFromPresentationTime: () => undefined,
-            calcSegmentAvailabilityRange: () =>  { return {start: start, end: end};},
-            isTimeSyncCompleted: () => {return true;},
-            setExpectedLiveEdge: () => {},
-            setRange: (range) => {start = range.start; end = range.end;}
+            calcSegmentAvailabilityWindowForRepresentation: () => {
+                return {start: start, end: end};
+            },
+            isTimeSyncCompleted: () => {
+                return true;
+            },
+            setExpectedLiveEdge: () => {
+            },
+            calcWallTimeForSegment: () => 0,
+            setRange: (range) => {
+                start = range.start;
+                end = range.end;
+            }
         };
     }
 
     getDummyBaseURLController() {
         return {
             resolve: () => {
-                return  {
+                return {
                     url: '',
                     serviceLocation: ''
                 };
@@ -61,7 +89,22 @@ class ObjectsHelper {
 
     getDummyBlacklistController() {
         return {
-            contains: () => {}
+            contains: () => {
+            }
+        };
+    }
+
+    getDummySegmentsController() {
+        return {
+            initialize: () => {
+
+            },
+            getSegmentByTime: () => {
+                return null;
+            },
+            getSegmentByIndex: () => {
+
+            }
         };
     }
 }
diff --git a/test/unit/helpers/VOHelper.js b/test/unit/helpers/VOHelper.js
index 67b42ae50f..a821ab935c 100644
--- a/test/unit/helpers/VOHelper.js
+++ b/test/unit/helpers/VOHelper.js
@@ -4,23 +4,25 @@ import MpdHelper from './MPDHelper';
 import SpecHelper from './SpecHelper';
 import Representation from '../../../src/dash/vo/Representation';
 import FragmentRequest from '../../../src/streaming/vo/FragmentRequest';
-import { HTTPRequest } from '../../../src/streaming/vo/metrics/HTTPRequest';
+import {HTTPRequest} from '../../../src/streaming/vo/metrics/HTTPRequest';
+import DashConstants from '../../../src/dash/constants/DashConstants';
 
 class VoHelper {
     constructor() {
         this.mpdHelper = new MpdHelper();
         this.specHelper = new SpecHelper();
         this.voRep = undefined;
+        this.voTimelineRep = undefined;
         this.voAdaptation = undefined;
         this.unixTime = this.specHelper.getUnixTime();
         this.adaptation = undefined;
         this.defaultMpdType = 'static';
     }
 
-    createMpd(type) {
+    createMpd(type, segInfoType) {
         var mpd = {};
 
-        mpd.manifest = this.mpdHelper.getMpd(type || this.defaultMpdType);
+        mpd.manifest = this.mpdHelper.getMpd(type || this.defaultMpdType, segInfoType);
         mpd.suggestedPresentationDelay = 0;
         mpd.availabilityStartTime = this.unixTime;
         mpd.availabilityEndTime = Number.POSITIVE_INFINITY;
@@ -30,10 +32,10 @@ class VoHelper {
         return mpd;
     }
 
-    createPeriod() {
+    createPeriod(segInfoType) {
         var period = {};
 
-        period.mpd = this.createMpd();
+        period.mpd = this.createMpd(this.defaultMpdType, segInfoType);
         period.start = 0;
 
         period.id = 'id1';
@@ -46,9 +48,9 @@ class VoHelper {
         return period;
     }
 
-    createAdaptation(type) {
+    createAdaptation(type, segInfoType) {
         var adaptation = {};
-        adaptation.period = this.createPeriod();
+        adaptation.period = this.createPeriod(segInfoType);
         adaptation.index = 0;
         adaptation.type = type;
 
@@ -69,9 +71,33 @@ class VoHelper {
         rep.indexRange = null;
         rep.range = null;
         rep.presentationTimeOffset = 10;
+        rep.segmentInfoType = DashConstants.SEGMENT_TEMPLATE;
         // Set the source buffer timeOffset to this
         rep.MSETimeOffset = NaN;
-        rep.segmentAvailabilityRange = null;
+        rep.segmentAvailabilityWindow = null;
+        rep.availableSegmentsNumber = 0;
+
+        return rep;
+    }
+
+    createTimelineRepresentation(type, index) {
+        var rep = new Representation();
+
+        rep.id = null;
+        rep.index = index || 0;
+        rep.adaptation = this.createAdaptation(type, 1);
+        rep.fragmentInfoType = null;
+        rep.initialization = 'https://dash.akamaized.net/envivio/dashpr/clear/video4/Header.m4s';
+        rep.segmentDuration = 1;
+        rep.timescale = 1;
+        rep.startNumber = 1;
+        rep.indexRange = null;
+        rep.range = null;
+        rep.presentationTimeOffset = 10;
+        rep.segmentInfoType = DashConstants.SEGMENT_TIMELINE;
+        // Set the source buffer timeOffset to this
+        rep.MSETimeOffset = NaN;
+        rep.segmentAvailabilityWindow = null;
         rep.availableSegmentsNumber = 0;
 
         return rep;
@@ -112,6 +138,10 @@ class VoHelper {
         return this.voRep || this.createRepresentation(type, index);
     }
 
+    getDummyTimelineRepresentation(type, index) {
+        return this.voTimelineRep || this.createTimelineRepresentation(type, index);
+    }
+
     getDummyMpd(type) {
         return this.createMpd(type);
     }
diff --git a/test/unit/mocks/AbrControllerMock.js b/test/unit/mocks/AbrControllerMock.js
index 828c6f2396..02bc5be06d 100644
--- a/test/unit/mocks/AbrControllerMock.js
+++ b/test/unit/mocks/AbrControllerMock.js
@@ -119,6 +119,8 @@ function AbrControllerMock () {
 
 
     this.getMinAllowedIndexFor = function () {};
+
+    this.clearDataForStream = function () {};
 }
 
 export default AbrControllerMock;
diff --git a/test/unit/mocks/AdapterMock.js b/test/unit/mocks/AdapterMock.js
index a8a485e9e6..529d682f6a 100644
--- a/test/unit/mocks/AdapterMock.js
+++ b/test/unit/mocks/AdapterMock.js
@@ -168,6 +168,16 @@ function AdapterMock () {
     this.getPatchLocation = function () {
         return null;
     };
+
+    this.getRegularPeriods = function () {
+        return this.regularPeriods || [];
+    };
+
+    this.setRegularPeriods = function (periods) {
+        this.regularPeriods = periods;
+    };
+
+
 }
 
 export default AdapterMock;
diff --git a/test/unit/mocks/CapabilitiesFilterMock.js b/test/unit/mocks/CapabilitiesFilterMock.js
index c3da376b33..904b677cb8 100644
--- a/test/unit/mocks/CapabilitiesFilterMock.js
+++ b/test/unit/mocks/CapabilitiesFilterMock.js
@@ -1,7 +1,7 @@
 class CapabilitiesFilterMock {
 
-    filterUnsupportedFeaturesOfPeriod() {
-
+    filterUnsupportedFeatures() {
+        return Promise.resolve();
     }
 }
 
diff --git a/test/unit/mocks/DashMetricsMock.js b/test/unit/mocks/DashMetricsMock.js
index ed2afdd170..ebe01172e6 100644
--- a/test/unit/mocks/DashMetricsMock.js
+++ b/test/unit/mocks/DashMetricsMock.js
@@ -79,6 +79,10 @@ function DashMetricsMock() {
     this.getLatestMPDRequestHeaderValueByID = function (/*id*/) {
         return null;
     };
+
+    this.addManifestUpdateStreamInfo = function () {
+        return true;
+    };
 }
 
 export default DashMetricsMock;
diff --git a/test/unit/mocks/MediaControllerMock.js b/test/unit/mocks/MediaControllerMock.js
index f0aa5a97e1..a3587b314b 100644
--- a/test/unit/mocks/MediaControllerMock.js
+++ b/test/unit/mocks/MediaControllerMock.js
@@ -84,18 +84,6 @@ class MediaControllerMock {
         return this.switchMode[type];
     }
 
-    /**
-     * @param {string} mode
-     * @memberof MediaController#
-     */
-    setSelectionModeForInitialTrack(mode) {
-        this.selectionMode = mode;
-    }
-
-    getSelectionModeForInitialTrack() {
-        return this.selectionMode;
-    }
-
     isMultiTrackSupportedByType(type) {
         return (type === 'audio' || type === 'video' || type === 'text' || type === 'fragmentedText');
     }
diff --git a/test/unit/mocks/PlaybackControllerMock.js b/test/unit/mocks/PlaybackControllerMock.js
index 3f64f29e7c..2ce404d1c2 100644
--- a/test/unit/mocks/PlaybackControllerMock.js
+++ b/test/unit/mocks/PlaybackControllerMock.js
@@ -101,8 +101,12 @@ class PlaybackControllerMock {
         return this.liveStartTime;
     }
 
-    computeLiveDelay() {
-        return 16;
+    computeAndSetLiveDelay() {
+        return 15;
+    }
+
+    getLiveDelay() {
+        return 15;
     }
 
     reset() {
@@ -115,6 +119,11 @@ class PlaybackControllerMock {
     getStreamStartTime() {
         return 0;
     }
+
+    getAvailabilityStartTime() {
+        return 0;
+    }
+
 }
 
 export default PlaybackControllerMock;
diff --git a/test/unit/mocks/ProtectionControllerMock.js b/test/unit/mocks/ProtectionControllerMock.js
index 595054336a..9c69f8c3ce 100644
--- a/test/unit/mocks/ProtectionControllerMock.js
+++ b/test/unit/mocks/ProtectionControllerMock.js
@@ -1,10 +1,15 @@
-function ProtectionControllerMock () {
+class ProtectionControllerMock {
 
-    this.setMediaElement = function (/*elt*/) {
-    };
+    setMediaElement() {
+    }
+
+    setProtectionData() {
+    }
+
+    clearMediaInfoArrayByStreamId() {
+
+    }
 
-    this.setProtectionData = function (/*protectionData*/) {
-    };
 }
 
-export default ProtectionControllerMock;
\ No newline at end of file
+export default ProtectionControllerMock;
diff --git a/test/unit/mocks/RulesContextMock.js b/test/unit/mocks/RulesContextMock.js
index 3cb1d15a59..73aa1af34d 100644
--- a/test/unit/mocks/RulesContextMock.js
+++ b/test/unit/mocks/RulesContextMock.js
@@ -52,8 +52,10 @@ function RulesContextMock () {
     };
 
     this.getStreamInfo = function () {
-
+        return {
+            id: 1
+        };
     };
 }
 
-export default RulesContextMock;
\ No newline at end of file
+export default RulesContextMock;
diff --git a/test/unit/mocks/SegmentsControllerMock.js b/test/unit/mocks/SegmentsControllerMock.js
new file mode 100644
index 0000000000..4041db188c
--- /dev/null
+++ b/test/unit/mocks/SegmentsControllerMock.js
@@ -0,0 +1,12 @@
+class SegmentsControllerMock {
+
+    updateInitData() {
+        return Promise.resolve();
+    }
+
+    updateSegmentData() {
+        return Promise.resolve();
+    }
+}
+
+export default SegmentsControllerMock;
diff --git a/test/unit/mocks/StreamControllerMock.js b/test/unit/mocks/StreamControllerMock.js
index 586d25591f..92790e9e0e 100644
--- a/test/unit/mocks/StreamControllerMock.js
+++ b/test/unit/mocks/StreamControllerMock.js
@@ -6,7 +6,7 @@ class StreamControllerMock {
     }
 
     setup() {
-        this.streamId = 'streamId';
+        this.streamId = 'DUMMY_STREAM-01';
         this.activeStream = new StreamMock();
     }
 
@@ -47,7 +47,7 @@ class StreamControllerMock {
 
     getActiveStreamInfo() {
         return {
-            id: 'streamId'
+            id: 'DUMMY_STREAM-01'
         };
     }
 
@@ -88,6 +88,11 @@ class StreamControllerMock {
     getActiveStream() {
         return this.activeStream;
     }
+
+    hasVideoTrack() {
+        return true;
+    }
+
 }
 
 export default StreamControllerMock;
diff --git a/test/unit/mocks/StreamMock.js b/test/unit/mocks/StreamMock.js
index fb9f575888..11ce23736c 100644
--- a/test/unit/mocks/StreamMock.js
+++ b/test/unit/mocks/StreamMock.js
@@ -1,32 +1,55 @@
+import AdapterMock from './AdapterMock';
 import StreamProcessorMock from './StreamProcessorMock';
 
 const TYPE_AUDIO = 'audio';
 const TYPE_VIDEO = 'video';
 
-function StreamMock () {
-
-    this.initialize = function (streamInfo) {
-        this.streamInfo = streamInfo;
-    };
-
+function StreamMock() {
+    this.streamInfo = {};
+    this.dashAdapter = new AdapterMock();
     this.streamProcessors = [
         new StreamProcessorMock(TYPE_VIDEO),
         new StreamProcessorMock(TYPE_AUDIO)
     ];
+}
 
-    this.getStreamInfo = function () {
-        return this.streamInfo ? this.streamInfo : {};
+StreamMock.prototype.initialize = function (streamInfo) {
+    this.streamInfo = streamInfo;
+};
+
+StreamMock.prototype.getStreamInfo = function () {
+    return this.streamInfo ? this.streamInfo : {};
+};
+
+StreamMock.prototype.setStreamInfo = function (streamInfo) {
+    this.streamInfo = streamInfo;
+};
+
+StreamMock.prototype.getFragmentController = function () {
+    return {
+        getModel: () => {
+            return {
+                setStreamProcessor: () => {
+                }
+            };
+        }
     };
+};
 
-    this.getFragmentController = function () {
-        return { getModel: () => {
-            return { setStreamProcessor: () => {} };
-        } };
-    };
+StreamMock.prototype.getAdapter = function () {
+    return this.dashAdapter;
+};
 
-    this.getProcessors = function () {
-        return this.streamProcessors;
-    };
-}
+StreamMock.prototype.setRegularPeriods = function (periods) {
+    this.dashAdapter.setRegularPeriods(periods);
+};
+
+StreamMock.prototype.setRepresentation = function (representation) {
+    this.dashAdapter.setRepresentation(representation);
+};
+
+StreamMock.prototype.getProcessors = function () {
+    return this.streamProcessors;
+};
 
 export default StreamMock;
diff --git a/test/unit/mocks/TextControllerMock.js b/test/unit/mocks/TextControllerMock.js
index 3a5d567ecc..b7de54791d 100644
--- a/test/unit/mocks/TextControllerMock.js
+++ b/test/unit/mocks/TextControllerMock.js
@@ -5,19 +5,33 @@ class TextControllerMock {
         this.textEnabled = false;
         this.buffers = [];
     }
+
     getTextSourceBuffer() {
         return new TextSourceBufferMock();
     }
+
     isTextEnabled() {
         return this.textEnabled;
     }
+
     enableText(state) {
         this.textEnabled = state;
     }
+
     getTextDefaultEnabled() {
         return true;
     }
-    addEmbeddedTrack() {}
+
+    addEmbeddedTrack() {
+    }
+
+    deactivateStream() {
+
+    }
+
+    initializeForStream() {
+
+    }
 }
 
 export default TextControllerMock;
diff --git a/test/unit/mocks/URIFragmentModelMock.js b/test/unit/mocks/URIFragmentModelMock.js
index dffd1e74a5..1e5c415ffc 100644
--- a/test/unit/mocks/URIFragmentModelMock.js
+++ b/test/unit/mocks/URIFragmentModelMock.js
@@ -10,6 +10,10 @@ class URIFragmentModelMock {
     setURIFragmentData(uri) {
         this.uriFragmentData = uri;
     }
+
+    reset() {
+        this.uriFragmentData = null;
+    }
 }
 
-export default URIFragmentModelMock;
\ No newline at end of file
+export default URIFragmentModelMock;
diff --git a/test/unit/mocks/VideoModelMock.js b/test/unit/mocks/VideoModelMock.js
index 4820bb9965..af9a43252c 100644
--- a/test/unit/mocks/VideoModelMock.js
+++ b/test/unit/mocks/VideoModelMock.js
@@ -126,6 +126,7 @@ class VideoModelMock {
 
     setCurrentTime(time) {
         this.time = time;
+        this.fireEvent('seeking', {});
     }
 
     getTime() {
diff --git a/test/unit/streaming.MediaPlayer.js b/test/unit/streaming.MediaPlayer.js
index 8ddeed3f6a..003af1fb0a 100644
--- a/test/unit/streaming.MediaPlayer.js
+++ b/test/unit/streaming.MediaPlayer.js
@@ -16,7 +16,6 @@ const expect = require('chai').expect;
 const ELEMENT_NOT_ATTACHED_ERROR = 'You must first call attachView() to set the video element before calling this method';
 const PLAYBACK_NOT_INITIALIZED_ERROR = 'You must first call initialize() and set a valid source and view before calling this method';
 const STREAMING_NOT_INITIALIZED_ERROR = 'You must first call initialize() and set a source before calling this method';
-const SOURCE_NOT_ATTACHED_ERROR = 'You must first call attachSource() with a valid source before calling this method';
 const MEDIA_PLAYER_NOT_INITIALIZED_ERROR = 'MediaPlayer not initialized!';
 
 describe('MediaPlayer', function () {
@@ -181,9 +180,6 @@ describe('MediaPlayer', function () {
                 expect(player.durationAsUTC).to.throw(PLAYBACK_NOT_INITIALIZED_ERROR);
             });
 
-            it('Method preload should throw an exception', function () {
-                expect(player.preload).to.throw(SOURCE_NOT_ATTACHED_ERROR);
-            });
         });
 
         describe('When it is initialized', function () {
@@ -560,7 +556,7 @@ describe('MediaPlayer', function () {
 
             it('should configure quality for type', function () {
                 let qualityFor = abrControllerMock.getQualityFor('video', {
-                    id: 'streamId'
+                    id: 'DUMMY_STREAM-01'
                 });
                 expect(qualityFor).to.equal(abrControllerMock.QUALITY_DEFAULT());
 
@@ -570,7 +566,7 @@ describe('MediaPlayer', function () {
                 player.setQualityFor('video', 10);
 
                 qualityFor = abrControllerMock.getQualityFor('video', {
-                    id: 'streamId'
+                    id: 'DUMMY_STREAM-01'
                 });
                 expect(qualityFor).to.equal(10);
 
@@ -601,50 +597,60 @@ describe('MediaPlayer', function () {
         });
 
         it('should configure LiveDelayFragmentCount', function () {
-            let liveDelayFragmentCount = player.getSettings().streaming.liveDelayFragmentCount;
+            let liveDelayFragmentCount = player.getSettings().streaming.delay.liveDelayFragmentCount;
             expect(liveDelayFragmentCount).to.be.NaN; // jshint ignore:line
 
-            player.updateSettings({'streaming': {'liveDelayFragmentCount': 5}});
+            player.updateSettings({ 'streaming': { 'delay': { 'liveDelayFragmentCount': 5 } } });
 
-            liveDelayFragmentCount = player.getSettings().streaming.liveDelayFragmentCount;
+            liveDelayFragmentCount = player.getSettings().streaming.delay.liveDelayFragmentCount;
             expect(liveDelayFragmentCount).to.equal(5);
         });
 
+        it('should configure liveDelay', function () {
+            let liveDelay = player.getSettings().streaming.delay.liveDelay;
+            expect(liveDelay).to.be.NaN; // jshint ignore:line
+
+            player.updateSettings({ 'streaming': { 'delay': { 'liveDelay': 10 } } });
+
+            liveDelay = player.getSettings().streaming.delay.liveDelay;
+            expect(liveDelay).to.equal(10);
+        });
+
         it('should configure useSuggestedPresentationDelay', function () {
-            let useSuggestedPresentationDelay = player.getSettings().streaming.useSuggestedPresentationDelay;
+            let useSuggestedPresentationDelay = player.getSettings().streaming.delay.useSuggestedPresentationDelay;
             expect(useSuggestedPresentationDelay).to.be.true; // jshint ignore:line
 
-            player.updateSettings({'streaming': {'useSuggestedPresentationDelay': false}});
+            player.updateSettings({ 'streaming': { 'delay': { 'useSuggestedPresentationDelay': false } } });
 
-            useSuggestedPresentationDelay = player.getSettings().streaming.useSuggestedPresentationDelay;
+            useSuggestedPresentationDelay = player.getSettings().streaming.delay.useSuggestedPresentationDelay;
             expect(useSuggestedPresentationDelay).to.be.false; // jshint ignore:line
         });
 
         it('should configure scheduleWhilePaused', function () {
-            let scheduleWhilePaused = player.getSettings().streaming.scheduleWhilePaused;
+            let scheduleWhilePaused = player.getSettings().streaming.scheduling.scheduleWhilePaused;
             expect(scheduleWhilePaused).to.be.true; // jshint ignore:line
 
-            player.updateSettings({'streaming': {'scheduleWhilePaused': false}});
+            player.updateSettings({ 'streaming': { scheduling: { 'scheduleWhilePaused': false } } });
 
-            scheduleWhilePaused = player.getSettings().streaming.scheduleWhilePaused;
+            scheduleWhilePaused = player.getSettings().streaming.scheduling.scheduleWhilePaused;
             expect(scheduleWhilePaused).to.be.false; // jshint ignore:line
         });
 
         it('should configure fastSwitchEnabled', function () {
-            let fastSwitchEnabled = player.getSettings().streaming.fastSwitchEnabled;
-            expect(fastSwitchEnabled).to.be.false; // jshint ignore:line
+            let fastSwitchEnabled = player.getSettings().streaming.buffer.fastSwitchEnabled;
+            expect(fastSwitchEnabled).to.be.true; // jshint ignore:line
 
-            player.updateSettings({'streaming': {'fastSwitchEnabled': true}});
+            player.updateSettings({ 'streaming': { 'buffer': { 'fastSwitchEnabled': false } } });
 
-            fastSwitchEnabled = player.getSettings().streaming.fastSwitchEnabled;
-            expect(fastSwitchEnabled).to.be.true; // jshint ignore:line
+            fastSwitchEnabled = player.getSettings().streaming.buffer.fastSwitchEnabled;
+            expect(fastSwitchEnabled).to.be.false; // jshint ignore:line
         });
 
         it('should configure useDefaultABRRules', function () {
             let useDefaultABRRules = player.getSettings().streaming.abr.useDefaultABRRules;
             expect(useDefaultABRRules).to.be.true; // jshint ignore:line
 
-            player.updateSettings({'streaming': {'abr': {'useDefaultABRRules': false}}});
+            player.updateSettings({ 'streaming': { 'abr': { 'useDefaultABRRules': false } } });
 
 
             useDefaultABRRules = player.getSettings().streaming.abr.useDefaultABRRules;
@@ -705,64 +711,64 @@ describe('MediaPlayer', function () {
             let useManifestDateHeaderTimeSource = player.getSettings().streaming.useManifestDateHeaderTimeSource;
             expect(useManifestDateHeaderTimeSource).to.be.true; // jshint ignore:line
 
-            player.updateSettings({'streaming': {'useManifestDateHeaderTimeSource': false}});
+            player.updateSettings({ 'streaming': { 'useManifestDateHeaderTimeSource': false } });
 
             useManifestDateHeaderTimeSource = player.getSettings().streaming.useManifestDateHeaderTimeSource;
             expect(useManifestDateHeaderTimeSource).to.be.false; // jshint ignore:line
         });
 
         it('should configure BufferToKeep', function () {
-            let BufferToKeep = player.getSettings().streaming.bufferToKeep;
+            let BufferToKeep = player.getSettings().streaming.buffer.bufferToKeep;
             expect(BufferToKeep).to.equal(20);
 
-            player.updateSettings({'streaming': {'bufferToKeep': 50}});
+            player.updateSettings({ 'streaming': { 'buffer': { 'bufferToKeep': 50 } } });
 
-            BufferToKeep = player.getSettings().streaming.bufferToKeep;
+            BufferToKeep = player.getSettings().streaming.buffer.bufferToKeep;
             expect(BufferToKeep).to.equal(50);
         });
 
         it('should configure BufferPruningInterval', function () {
-            let BufferPruningInterval = player.getSettings().streaming.bufferPruningInterval;
+            let BufferPruningInterval = player.getSettings().streaming.buffer.bufferPruningInterval;
             expect(BufferPruningInterval).to.equal(10);
 
-            player.updateSettings({'streaming': {'bufferPruningInterval': 50}});
+            player.updateSettings({ 'streaming': { 'buffer': { 'bufferPruningInterval': 50 } } });
 
-            BufferPruningInterval = player.getSettings().streaming.bufferPruningInterval;
+            BufferPruningInterval = player.getSettings().streaming.buffer.bufferPruningInterval;
             expect(BufferPruningInterval).to.equal(50);
         });
 
         it('should configure StableBufferTime', function () {
-            let StableBufferTime = player.getSettings().streaming.stableBufferTime;
+            let StableBufferTime = player.getSettings().streaming.buffer.stableBufferTime;
             expect(StableBufferTime).to.equal(12);
         });
 
         it('should configure BufferTimeAtTopQuality', function () {
-            let BufferTimeAtTopQuality = player.getSettings().streaming.bufferTimeAtTopQuality;
+            let BufferTimeAtTopQuality = player.getSettings().streaming.buffer.bufferTimeAtTopQuality;
             expect(BufferTimeAtTopQuality).to.equal(30);
 
-            player.updateSettings({'streaming': {'bufferTimeAtTopQuality': 50}});
+            player.updateSettings({ 'streaming': { 'buffer': { 'bufferTimeAtTopQuality': 50 } } });
 
-            BufferTimeAtTopQuality = player.getSettings().streaming.bufferTimeAtTopQuality;
+            BufferTimeAtTopQuality = player.getSettings().streaming.buffer.bufferTimeAtTopQuality;
             expect(BufferTimeAtTopQuality).to.equal(50);
         });
 
         it('should configure BufferTimeAtTopQualityLongForm', function () {
-            let bufferTimeAtTopQualityLongForm = player.getSettings().streaming.bufferTimeAtTopQualityLongForm;
+            let bufferTimeAtTopQualityLongForm = player.getSettings().streaming.buffer.bufferTimeAtTopQualityLongForm;
             expect(bufferTimeAtTopQualityLongForm).to.equal(60);
 
-            player.updateSettings({'streaming': {'bufferTimeAtTopQualityLongForm': 50}});
+            player.updateSettings({ 'streaming': { 'buffer': { 'bufferTimeAtTopQualityLongForm': 50 } } });
 
-            bufferTimeAtTopQualityLongForm = player.getSettings().streaming.bufferTimeAtTopQualityLongForm;
+            bufferTimeAtTopQualityLongForm = player.getSettings().streaming.buffer.bufferTimeAtTopQualityLongForm;
             expect(bufferTimeAtTopQualityLongForm).to.equal(50);
         });
 
         it('should configure LongFormContentDurationThreshold', function () {
-            let LongFormContentDurationThreshold = player.getSettings().streaming.longFormContentDurationThreshold;
+            let LongFormContentDurationThreshold = player.getSettings().streaming.buffer.longFormContentDurationThreshold;
             expect(LongFormContentDurationThreshold).to.equal(600);
 
-            player.updateSettings({'streaming': {'longFormContentDurationThreshold': 50}});
+            player.updateSettings({ 'streaming': { 'buffer': { 'longFormContentDurationThreshold': 50 } } });
 
-            LongFormContentDurationThreshold = player.getSettings().streaming.longFormContentDurationThreshold;
+            LongFormContentDurationThreshold = player.getSettings().streaming.buffer.longFormContentDurationThreshold;
             expect(LongFormContentDurationThreshold).to.equal(50);
         });
 
@@ -770,7 +776,7 @@ describe('MediaPlayer', function () {
             let cacheLoadThresholdForVideo = player.getSettings().streaming.cacheLoadThresholds[Constants.VIDEO];
             expect(cacheLoadThresholdForVideo).to.equal(50);
 
-            player.updateSettings({'streaming': {'cacheLoadThresholds': {'video': 10}}});
+            player.updateSettings({ 'streaming': { 'cacheLoadThresholds': { 'video': 10 } } });
 
             cacheLoadThresholdForVideo = player.getSettings().streaming.cacheLoadThresholds[Constants.VIDEO];
             expect(cacheLoadThresholdForVideo).to.equal(10);
@@ -778,35 +784,43 @@ describe('MediaPlayer', function () {
             let cacheLoadThresholdForAudio = player.getSettings().streaming.cacheLoadThresholds[Constants.AUDIO];
             expect(cacheLoadThresholdForAudio).to.equal(5);
 
-            player.updateSettings({'streaming': {'cacheLoadThresholds': {'audio': 2}}});
+            player.updateSettings({ 'streaming': { 'cacheLoadThresholds': { 'audio': 2 } } });
 
             cacheLoadThresholdForAudio = player.getSettings().streaming.cacheLoadThresholds[Constants.AUDIO];
             expect(cacheLoadThresholdForAudio).to.equal(2);
         });
 
         it('should configure jumpGap feature', function () {
-            let jumpGaps = player.getSettings().streaming.jumpGaps;
+            let jumpGaps = player.getSettings().streaming.gaps.jumpGaps;
             expect(jumpGaps).to.equal(true);
 
-            player.updateSettings({'streaming': {'jumpGaps': false}});
+            player.updateSettings({ 'streaming': { 'gaps': { 'jumpGaps': false } } });
 
-            jumpGaps = player.getSettings().streaming.jumpGaps;
+            jumpGaps = player.getSettings().streaming.gaps.jumpGaps;
             expect(jumpGaps).to.equal(false);
 
-            let smallGapLimit = player.getSettings().streaming.smallGapLimit;
+            let smallGapLimit = player.getSettings().streaming.gaps.smallGapLimit;
             expect(smallGapLimit).to.equal(1.5);
 
-            player.updateSettings({'streaming': {'smallGapLimit': 0.5}});
+            player.updateSettings({ 'streaming': { 'gaps': { 'smallGapLimit': 0.5 } } });
 
-            smallGapLimit = player.getSettings().streaming.smallGapLimit;
+            smallGapLimit = player.getSettings().streaming.gaps.smallGapLimit;
             expect(smallGapLimit).to.equal(0.5);
+
+            let jumpLargeGaps = player.getSettings().streaming.gaps.jumpLargeGaps;
+            expect(jumpLargeGaps).to.be.true;
+
+            player.updateSettings({ 'streaming': { 'gaps': { 'jumpLargeGaps': false } } });
+
+            jumpLargeGaps = player.getSettings().streaming.gaps.jumpLargeGaps;
+            expect(jumpLargeGaps).to.be.false;
         });
 
         it('should configure manifestUpdateRetryInterval', function () {
             let manifestUpdateRetryInterval = player.getSettings().streaming.manifestUpdateRetryInterval;
             expect(manifestUpdateRetryInterval).to.equal(100);
 
-            player.updateSettings({'streaming': {'manifestUpdateRetryInterval': 200}});
+            player.updateSettings({ 'streaming': { 'manifestUpdateRetryInterval': 200 } });
 
             manifestUpdateRetryInterval = player.getSettings().streaming.manifestUpdateRetryInterval;
             expect(manifestUpdateRetryInterval).to.equal(200);
@@ -865,17 +879,17 @@ describe('MediaPlayer', function () {
                 expect(player.setTextTrack).to.throw(PLAYBACK_NOT_INITIALIZED_ERROR);
             });
 
-            it('Method setTextDefaultLanguage should throw an invalid Arguments exception when lang is undefined', function () {
-                expect(player.setTextDefaultLanguage).to.throw(Constants.BAD_ARGUMENT_ERROR);
+            it('Method enableText should return false', function () {
+                const enabled = player.enableText();
+                expect(enabled).to.be.false; // jshint ignore:line
             });
 
-            it('Method setTextDefaultEnabled should throw an invalid Arguments exception when enable is undefined', function () {
-                expect(player.setTextDefaultEnabled).to.throw(Constants.BAD_ARGUMENT_ERROR);
+            it('Method isTextEnabled should return false', function () {
+                const enabled = player.isTextEnabled();
+                expect(enabled).to.be.false; // jshint ignore:line
             });
 
-            it('Method getTextDefaultEnabled should return false', function () {
-                expect(player.getTextDefaultEnabled()).to.be.false; // jshint ignore:line
-            });
+
         });
     });
 
@@ -982,22 +996,6 @@ describe('MediaPlayer', function () {
                 expect(player.getInitialMediaSettingsFor).to.throw(MEDIA_PLAYER_NOT_INITIALIZED_ERROR);
             });
 
-            it('Method getTrackSwitchModeFor should throw an exception', function () {
-                expect(player.getTrackSwitchModeFor).to.throw(MEDIA_PLAYER_NOT_INITIALIZED_ERROR);
-            });
-
-            it('Method setTrackSwitchModeFor should throw an exception', function () {
-                expect(player.setTrackSwitchModeFor).to.throw(MEDIA_PLAYER_NOT_INITIALIZED_ERROR);
-            });
-
-            it('Method setSelectionModeForInitialTrack should throw an exception', function () {
-                expect(player.setSelectionModeForInitialTrack).to.throw(MEDIA_PLAYER_NOT_INITIALIZED_ERROR);
-            });
-
-            it('Method getSelectionModeForInitialTrack should throw an exception', function () {
-                expect(player.getSelectionModeForInitialTrack).to.throw(MEDIA_PLAYER_NOT_INITIALIZED_ERROR);
-            });
-
             it('Method getCurrentLiveLatency should throw an exception', function () {
                 expect(player.getCurrentLiveLatency).to.throw(MEDIA_PLAYER_NOT_INITIALIZED_ERROR);
             });
@@ -1041,7 +1039,7 @@ describe('MediaPlayer', function () {
                 initialSettings = player.getInitialMediaSettingsFor('audio');
                 expect(initialSettings).to.equal('settings');
 
-                player.setInitialMediaSettingsFor('fragmentedText', {lang: 'en', role: 'caption'});
+                player.setInitialMediaSettingsFor('fragmentedText', { lang: 'en', role: 'caption' });
                 initialSettings = player.getInitialMediaSettingsFor('fragmentedText');
                 expect(initialSettings).to.exist; // jshint ignore:line
                 expect(initialSettings.lang).to.equal('en');
@@ -1058,26 +1056,6 @@ describe('MediaPlayer', function () {
                 currentTrack = mediaControllerMock.isCurrentTrack('audio');
                 expect(currentTrack).to.be.true; // jshint ignore:line
             });
-
-            it('should configure track switch mode', function () {
-                let trackSwitchMode = player.getTrackSwitchModeFor('audio');
-                expect(trackSwitchMode).to.not.exist; // jshint ignore:line
-
-                player.setTrackSwitchModeFor('audio', 'switch');
-
-                trackSwitchMode = player.getTrackSwitchModeFor('audio');
-                expect(trackSwitchMode).to.equal('switch');
-            });
-
-            it('should configure selection mode for initial track', function () {
-                let selectionMode = player.getSelectionModeForInitialTrack();
-                expect(selectionMode).to.not.exist; // jshint ignore:line
-
-                player.setSelectionModeForInitialTrack('mode');
-
-                selectionMode = player.getSelectionModeForInitialTrack();
-                expect(selectionMode).to.equal('mode');
-            });
         });
     });
 
diff --git a/test/unit/streaming.Stream.js b/test/unit/streaming.Stream.js
index 4e1ca85273..f2b576abad 100644
--- a/test/unit/streaming.Stream.js
+++ b/test/unit/streaming.Stream.js
@@ -16,16 +16,15 @@ import StreamMock from './mocks/StreamMock';
 import ManifestUpdaterMock from './mocks/ManifestUpdaterMock';
 import PlaybackControllerMock from './mocks/PlaybackControllerMock';
 import CapabilitiesMock from './mocks/CapabilitiesMock';
-import CapabilitiesFilterMock from './mocks/CapabilitiesFilterMock';
 import MediaControllerMock from './mocks/MediaControllerMock';
 import DashMetricsMock from './mocks/DashMetricsMock';
 import TextControllerMock from './mocks/TextControllerMock';
 import VideoModelMock from './mocks/VideoModelMock';
+import ProtectionControllerMock from './mocks/ProtectionControllerMock';
 
 import ObjectsHelper from './helpers/ObjectsHelper';
 
 const expect = require('chai').expect;
-const sinon = require('sinon');
 
 const context = {};
 const eventBus = EventBus(context).getInstance();
@@ -42,11 +41,11 @@ describe('Stream', function () {
     const manifestUpdaterMock = new ManifestUpdaterMock();
     const playbackControllerMock = new PlaybackControllerMock();
     const capabilitiesMock = new CapabilitiesMock();
-    const capabilitiesFilterMock = new CapabilitiesFilterMock();
     const mediaControllerMock = new MediaControllerMock();
     const dashMetricsMock = new DashMetricsMock();
     const textControllerMock = new TextControllerMock();
     const videoModelMock = new VideoModelMock();
+    const protectionControllerMock = new ProtectionControllerMock();
     const timelineConverter = objectsHelper.getDummyTimelineConverter();
     const streamInfo = {
         id: 'id',
@@ -68,14 +67,14 @@ describe('Stream', function () {
                 manifestUpdater: manifestUpdaterMock,
                 playbackController: playbackControllerMock,
                 capabilities: capabilitiesMock,
-                capabilitiesFilter: capabilitiesFilterMock,
                 mediaController: mediaControllerMock,
                 timelineConverter: timelineConverter,
                 dashMetrics: dashMetricsMock,
                 textController: textControllerMock,
-                protectionController: {},
+                protectionController: protectionControllerMock,
                 videoModel: videoModelMock,
-                settings: settings});
+                settings: settings
+            });
         });
 
         afterEach(function () {
@@ -83,7 +82,7 @@ describe('Stream', function () {
         });
 
         it('should return false when isActive is called', () => {
-            const isActive = stream.isActive();
+            const isActive = stream.getIsActive();
 
             expect(isActive).to.be.false; // jshint ignore:line
         });
@@ -136,10 +135,10 @@ describe('Stream', function () {
             expect(isCompatible).to.be.false; // jshint ignore:line
         });
 
-        it('should return null when isProtectionCompatible is called but stream attribute is undefined', () => {
+        it('should return true when isProtectionCompatible is called but new stream attribute is undefined', () => {
             stream.reset();
             const isCompatible = stream.isProtectionCompatible();
-            expect(isCompatible).to.be.false; // jshint ignore:line
+            expect(isCompatible).to.be.true; // jshint ignore:line
         });
 
         it('should return an empty array when getBitrateListFor is called but no stream processor is defined', () => {
@@ -156,22 +155,13 @@ describe('Stream', function () {
             expect(bitrateList).to.be.empty; // jshint ignore:line
         });
 
-        it('should not call STREAM_INITIALIZED event if initializeMedia has not been called when updateData is called', () => {
-            const spy = sinon.spy();
-
-            eventBus.on(Events.STREAM_INITIALIZED, spy);
-
-            stream.updateData(streamInfo);
-
-            expect(spy.notCalled).to.be.true; // jshint ignore:line
-
-            eventBus.off(Events.STREAM_INITIALIZED, spy);
-        });
-
         it('License expired behavior', function () {
             stream.initialize();
 
-            eventBus.trigger(Events.KEY_STATUSES_CHANGED, {data: null, error: new DashJSError(ProtectionErrors.KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE, ProtectionErrors.KEY_STATUS_CHANGED_EXPIRED_ERROR_MESSAGE)});
+            eventBus.trigger(Events.KEY_STATUSES_CHANGED, {
+                data: null,
+                error: new DashJSError(ProtectionErrors.KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE, ProtectionErrors.KEY_STATUS_CHANGED_EXPIRED_ERROR_MESSAGE)
+            });
 
             expect(errHandlerMock.errorCode).to.be.equal(ProtectionErrors.KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE); // jshint ignore:line
             expect(errHandlerMock.errorValue).to.be.equal(ProtectionErrors.KEY_STATUS_CHANGED_EXPIRED_ERROR_MESSAGE); // jshint ignore:line
@@ -180,7 +170,10 @@ describe('Stream', function () {
         it('No Licenser server url defined behavior', function () {
             stream.initialize();
 
-            eventBus.trigger(Events.LICENSE_REQUEST_COMPLETE, {data: null, error: new DashJSError(ProtectionErrors.MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE, ProtectionErrors.MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_MESSAGE)});
+            eventBus.trigger(Events.LICENSE_REQUEST_COMPLETE, {
+                data: null,
+                error: new DashJSError(ProtectionErrors.MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE, ProtectionErrors.MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_MESSAGE)
+            });
 
             expect(errHandlerMock.errorCode).to.be.equal(ProtectionErrors.MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE); // jshint ignore:line
             expect(errHandlerMock.errorValue).to.be.equal(ProtectionErrors.MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_MESSAGE); // jshint ignore:line
@@ -189,7 +182,10 @@ describe('Stream', function () {
         it('Licenser request error behavior', function () {
             stream.initialize();
 
-            eventBus.trigger(Events.LICENSE_REQUEST_COMPLETE, {data: null, error: new DashJSError(ProtectionErrors.MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE, ProtectionErrors.MEDIA_KEY_MESSAGE_LICENSER_ERROR_MESSAGE)});
+            eventBus.trigger(Events.LICENSE_REQUEST_COMPLETE, {
+                data: null,
+                error: new DashJSError(ProtectionErrors.MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE, ProtectionErrors.MEDIA_KEY_MESSAGE_LICENSER_ERROR_MESSAGE)
+            });
 
             expect(errHandlerMock.errorCode).to.be.equal(ProtectionErrors.MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE); // jshint ignore:line
             expect(errHandlerMock.errorValue).to.be.equal(ProtectionErrors.MEDIA_KEY_MESSAGE_LICENSER_ERROR_MESSAGE); // jshint ignore:line
@@ -198,7 +194,10 @@ describe('Stream', function () {
         it('CDM Access denied behavior', function () {
             stream.initialize();
 
-            eventBus.trigger(Events.KEY_SYSTEM_SELECTED, {data: null, error: new DashJSError(ProtectionErrors.KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE, ProtectionErrors.KEY_SYSTEM_ACCESS_DENIED_ERROR_MESSAGE)});
+            eventBus.trigger(Events.KEY_SYSTEM_SELECTED, {
+                data: null,
+                error: new DashJSError(ProtectionErrors.KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE, ProtectionErrors.KEY_SYSTEM_ACCESS_DENIED_ERROR_MESSAGE)
+            });
 
             expect(errHandlerMock.errorCode).to.be.equal(ProtectionErrors.KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE); // jshint ignore:line
             expect(errHandlerMock.errorValue).to.be.equal(ProtectionErrors.KEY_SYSTEM_ACCESS_DENIED_ERROR_MESSAGE); // jshint ignore:line
@@ -207,24 +206,31 @@ describe('Stream', function () {
         it('Unable to create key session behavior', function () {
             stream.initialize();
 
-            eventBus.trigger(Events.KEY_SESSION_CREATED, {data: null, error: new DashJSError(ProtectionErrors.KEY_SESSION_CREATED_ERROR_CODE, ProtectionErrors.KEY_SESSION_CREATED_ERROR_MESSAGE)});
+            eventBus.trigger(Events.KEY_SESSION_CREATED, {
+                data: null,
+                error: new DashJSError(ProtectionErrors.KEY_SESSION_CREATED_ERROR_CODE, ProtectionErrors.KEY_SESSION_CREATED_ERROR_MESSAGE)
+            });
 
             expect(errHandlerMock.errorCode).to.be.equal(ProtectionErrors.KEY_SESSION_CREATED_ERROR_CODE); // jshint ignore:line
             expect(errHandlerMock.errorValue).to.be.equal(ProtectionErrors.KEY_SESSION_CREATED_ERROR_MESSAGE); // jshint ignore:line
         });
 
-        it('should return preloaded to true after a call to preload without parameters', () => {
+        it('should return preloaded to true after a call to preload without parameters', (done) => {
             stream.initialize();
 
             let isPreloaded = stream.getPreloaded();
 
             expect(isPreloaded).to.be.false; // jshint ignore:line
 
-            stream.preload();
-
-            isPreloaded = stream.getPreloaded();
-
-            expect(isPreloaded).to.be.true; // jshint ignore:line
+            stream.startPreloading()
+                .then(() => {
+                    isPreloaded = stream.getPreloaded();
+                    expect(isPreloaded).to.be.true; // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should return undefined when getThumbnailController is called without a call to initializeMediaForType', () => {
diff --git a/test/unit/streaming.controllers.AbrController.js b/test/unit/streaming.controllers.AbrController.js
index a6eff03756..baa75294c5 100644
--- a/test/unit/streaming.controllers.AbrController.js
+++ b/test/unit/streaming.controllers.AbrController.js
@@ -42,6 +42,7 @@ describe('AbrController', function () {
             settings: settings,
             streamController: streamControllerMock
         });
+        abrCtrl.initialize();
         abrCtrl.registerStreamType(Constants.VIDEO, streamProcessor);
     });
 
@@ -51,7 +52,7 @@ describe('AbrController', function () {
     });
 
     it('should return null when attempting to get abandonment state when abandonmentStateDict array is empty', function () {
-        const state = abrCtrl.getAbandonmentStateFor(Constants.AUDIO);
+        const state = abrCtrl.getAbandonmentStateFor('1', Constants.AUDIO);
         expect(state).to.be.null;    // jshint ignore:line
     });
 
@@ -80,7 +81,7 @@ describe('AbrController', function () {
 
         abrCtrl.updateTopQualityIndex(dummyMediaInfo);
         abrCtrl.setPlaybackQuality(Constants.VIDEO, dummyMediaInfo.streamInfo, testQuality);
-        newQuality = abrCtrl.getQualityFor(Constants.VIDEO);
+        newQuality = abrCtrl.getQualityFor(Constants.VIDEO, dummyMediaInfo.streamInfo.id);
         expect(newQuality).to.be.equal(testQuality);
     });
 
@@ -145,93 +146,96 @@ describe('AbrController', function () {
 
     it('should return the appropriate max allowed index for the max allowed bitrate set', function () {
         // Max allowed bitrate in kbps, bandwidth is in bps
-        const s = { streaming: { abr: { maxBitrate: {}}}};
+
+        const s = {streaming: {abr: {maxBitrate: {}}}};
+        const streamId = streamProcessor.getStreamInfo().id;
         s.streaming.abr.maxBitrate[Constants.VIDEO] = streamProcessor.getMediaInfo().bitrateList[0].bandwidth / 1000;
         settings.update(s);
 
-        let maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        let maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(0);
 
         s.streaming.abr.maxBitrate[Constants.VIDEO] = streamProcessor.getMediaInfo().bitrateList[1].bandwidth / 1000;
         settings.update(s);
 
-        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(1);
 
         s.streaming.abr.maxBitrate[Constants.VIDEO] = streamProcessor.getMediaInfo().bitrateList[2].bandwidth / 1000;
         settings.update(s);
 
-        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(2);
 
         s.streaming.abr.maxBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[0].bandwidth / 1000) + 1;
         settings.update(s);
 
-        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(0);
 
         s.streaming.abr.maxBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[1].bandwidth / 1000) + 1;
         settings.update(s);
 
-        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(1);
 
         s.streaming.abr.maxBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[2].bandwidth / 1000) + 1;
         settings.update(s);
 
-        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(2);
 
         s.streaming.abr.maxBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[0].bandwidth / 1000) - 1;
         settings.update(s);
 
-        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO);
+        maxAllowedIndex = abrCtrl.getMaxAllowedIndexFor(Constants.VIDEO, streamId);
         expect(maxAllowedIndex).to.be.equal(0);
     });
 
     it('should return the appropriate min allowed index for the min allowed bitrate set', function () {
         // Min allowed bitrate in kbps, bandwidth is in bps
-        const s = { streaming: { abr: { minBitrate: {}}}};
+        const s = {streaming: {abr: {minBitrate: {}}}};
+        const streamId = streamProcessor.getStreamInfo().id;
         s.streaming.abr.minBitrate[Constants.VIDEO] = streamProcessor.getMediaInfo().bitrateList[0].bandwidth / 1000;
         settings.update(s);
 
-        let minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        let minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(0);
 
         s.streaming.abr.minBitrate[Constants.VIDEO] = streamProcessor.getMediaInfo().bitrateList[1].bandwidth / 1000;
         settings.update(s);
 
-        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(1);
 
         s.streaming.abr.minBitrate[Constants.VIDEO] = streamProcessor.getMediaInfo().bitrateList[2].bandwidth / 1000;
         settings.update(s);
 
-        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(2);
 
         s.streaming.abr.minBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[0].bandwidth / 1000) + 1;
         settings.update(s);
 
-        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(1);
 
         s.streaming.abr.minBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[1].bandwidth / 1000) + 1;
         settings.update(s);
 
-        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(2);
 
         s.streaming.abr.minBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[2].bandwidth / 1000) + 1;
         settings.update(s);
 
-        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(2);
 
         s.streaming.abr.minBitrate[Constants.VIDEO] = (streamProcessor.getMediaInfo().bitrateList[0].bandwidth / 1000) - 1;
         settings.update(s);
 
-        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO);
+        minAllowedIndex = abrCtrl.getMinAllowedIndexFor(Constants.VIDEO, streamId);
         expect(minAllowedIndex).to.be.equal(0);
     });
 
@@ -255,7 +259,7 @@ describe('AbrController', function () {
         expect(bitrateInfo.bitrate).to.be.equal(3000000);
         expect(bitrateInfo.qualityIndex).to.be.equal(2);
 
-        const s = { streaming: { abr: { limitBitrateByPortal: true }}};
+        const s = {streaming: {abr: {limitBitrateByPortal: true}}};
         settings.update(s);
 
         bitrateInfo = abrCtrl.getTopBitrateInfoFor(Constants.VIDEO);
@@ -266,7 +270,7 @@ describe('AbrController', function () {
 
     it('should return the appropriate top quality index when calling getTopQualityIndexFor', function () {
         videoModelMock.setClientWidth(899);
-        const s = { streaming: { abr: { limitBitrateByPortal: true }}};
+        const s = {streaming: {abr: {limitBitrateByPortal: true}}};
         settings.update(s);
         abrCtrl.updateTopQualityIndex({type: Constants.VIDEO, streamInfo: {id: 'test'}, representationCount: 5});
         let topQualityIndex = abrCtrl.getTopQualityIndexFor(Constants.VIDEO, 'test');
diff --git a/test/unit/streaming.controllers.BufferController.js b/test/unit/streaming.controllers.BufferController.js
index 3a333cde13..2305f45070 100644
--- a/test/unit/streaming.controllers.BufferController.js
+++ b/test/unit/streaming.controllers.BufferController.js
@@ -17,12 +17,13 @@ import TextControllerMock from './mocks/TextControllerMock';
 import RepresentationControllerMock from './mocks/RepresentationControllerMock';
 
 const chai = require('chai');
+const sinon = require('sinon');
 const expect = chai.expect;
 
 const context = {};
 const testType = 'video';
 const streamInfo = {
-    id: 'streamId'
+    id: 'DUMMY_STREAM-01'
 };
 const eventBus = EventBus(context).getInstance();
 // const objectUtils = ObjectUtils(context).getInstance();
@@ -44,7 +45,7 @@ describe('BufferController', function () {
     const representationControllerMock = new RepresentationControllerMock();
     let bufferController;
     let mediaSourceMock;
-    const mediaInfo = [{ codec: 'video/webm; codecs="vp8, vorbis"'}];
+    const mediaInfo = { codec: 'video/webm; codecs="vp8, vorbis"' };
 
     beforeEach(function () {
         global.navigator = {
@@ -84,22 +85,29 @@ describe('BufferController', function () {
     });
 
     describe('Method createBuffer/getBuffer', function () {
-        it('should not create a preBufferSink if mediaInfo is undefined', function () {
-            expect(bufferController.createBuffer()).to.be.null;  // jshint ignore:line
+        it('should not create a preBufferSink if mediaInfo is undefined', function (done) {
+            bufferController.createBufferSink()
+                .then((sink) => {
+                    expect(sink).to.be.null;  // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should create a preBufferSink if controller is initialized without a mediaSource', function () {
-            bufferController.initialize(null);
-            bufferController.createBuffer(mediaInfo);
-            expect(bufferController.getBuffer().discharge).to.be.a('function'); //Is of type PreBufferSink.
-        });
-
-        it('should create a sourceBufferSink and initialize it when given a mediaSource', function () {
+        it('should create a sourceBufferSink and initialize it when given a mediaSource', function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
-            const sink = bufferController.getBuffer();
-            expect(sink.getBuffer).to.be.a('function'); //Is of type SourceBufferSink
-            expect(sink.getBuffer()).to.equal(mediaSourceMock.buffers[0]);
+            bufferController.createBufferSink(mediaInfo)
+                .then((sink) => {
+                    expect(sink.getBuffer).to.be.a('function'); //Is of type SourceBufferSink
+                    expect(sink.getBuffer()).to.equal(mediaSourceMock.buffers[0]);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
+
         });
     });
 
@@ -111,9 +119,15 @@ describe('BufferController', function () {
     });
 
     describe('Method appendInitSegment', function () {
-        beforeEach(function () {
+        beforeEach(function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
+            bufferController.createBufferSink(mediaInfo)
+                .then(() => {
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should append init data to source buffer if data have been cached', function () {
@@ -129,35 +143,45 @@ describe('BufferController', function () {
 
             initCache.save(chunk);
 
-            bufferController.appendInitSegment('representationId');
+            bufferController.appendInitSegmentFromCache('representationId');
             expect(mediaSourceMock.buffers[0].chunk).to.equal(chunk.bytes);
         });
 
         it('should return false if no init data is cached', function () {
             // reset cache
             initCache.reset();
-            expect(bufferController.appendInitSegment('representationId')).to.equal(false);
+            expect(bufferController.appendInitSegmentFromCache('representationId')).to.equal(false);
         });
     });
 
     describe('Method reset', function () {
-        it('should reset buffer controller', function () {
+        it('should reset buffer controller', function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
-            const buffer = mediaSourceMock.buffers[0];
-            expect(buffer).to.exist; // jshint ignore:line
-
-            bufferController.reset();
-            expect(buffer.aborted).to.be.true; // jshint ignore:line
-            expect(mediaSourceMock.buffers[0]).to.not.exist; // jshint ignore:line
-            expect(bufferController.getBuffer()).to.not.exist; // jshint ignore:line
+            bufferController.createBufferSink(mediaInfo)
+                .then(() => {
+                    const buffer = mediaSourceMock.buffers[0];
+                    expect(buffer).to.exist; // jshint ignore:line
+
+                    bufferController.reset(false, false);
+                    expect(buffer.aborted).to.be.true; // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
     });
 
     describe('Event INIT_FRAGMENT_LOADED handler', function () {
-        beforeEach(function () {
+        beforeEach(function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
+            bufferController.createBufferSink(mediaInfo)
+                .then(() => {
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should append data to source buffer ', function (done) {
@@ -216,9 +240,15 @@ describe('BufferController', function () {
         });
     });
     describe('Event MEDIA_FRAGMENT_LOADED handler', function () {
-        beforeEach(function () {
+        beforeEach(function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
+            bufferController.createBufferSink(mediaInfo)
+                .then(() => {
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should append data to source buffer ', function (done) {
@@ -266,108 +296,73 @@ describe('BufferController', function () {
         });
     });
 
-    describe('Event MEDIA_FRAGMENT_LOADED handler', function () {
-        beforeEach(function () {
+    describe('Method updateBufferTimestampOffset', function () {
+        let adapterStub;
+
+        beforeEach(function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
-            bufferController.getRepresentationInfo = function (quality) {
-                return {
-                    MSETimeOffset: quality
-                };
-            };
+            bufferController.createBufferSink(mediaInfo)
+                .then(() => {
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
+
+            adapterStub = sinon.stub(adapterMock, 'convertDataToRepresentationInfo');
         });
 
-        it('should not update buffer timestamp offset - wrong quality', function () {
-
-            expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(1);
-
-            const event = {
-                newQuality: 0,
-                mediaType: testType,
-                streamInfo: {
-                    id: streamInfo.id
-                }
-            };
-
-            // send event
-            eventBus.trigger(Events.QUALITY_CHANGE_REQUESTED, event);
-            expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(1);
+        afterEach(function () {
+            adapterStub.restore();
+            adapterStub = null;
         });
 
-        it('should update buffer timestamp offset', function () {
+        it('should not update buffer timestamp offset if no representationInfo is provided', function (done) {
             expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(1);
 
-            const event = {
-                newQuality: 2,
-                mediaType: testType,
-                streamInfo: {
-                    id: streamInfo.id
-                }
-            };
-
             // send event
-            eventBus.trigger(Events.QUALITY_CHANGE_REQUESTED, event);
-            expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(2);
-        });
-    });
+            bufferController.updateBufferTimestampOffset()
+                .then(() => {
+                    expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(1);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
 
-    describe('Event PLAYBACK_SEEKING handler', function () {
-        beforeEach(function () {
-            bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
         });
 
-        it('should trigger BUFFER_LEVEL_UPDATED event', function (done) {
-            const buffer = mediaSourceMock.buffers[0];
-            const onBufferLevelUpdated = function (e) {
-                eventBus.off(Events.BUFFER_LEVEL_UPDATED, onBufferLevelUpdated, this);
-                expect(e.bufferLevel).to.equal(buffer.buffered.end(0) - buffer.buffered.start(0));
-
-                done();
-            };
-            eventBus.on(Events.BUFFER_LEVEL_UPDATED, onBufferLevelUpdated, this);
+        it('should  update buffer timestamp offset if  representationInfo is provided', function (done) {
+            expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(1);
 
+            const representationInfo = { MSETimeOffset: 2 };
             // send event
-            eventBus.trigger(Events.PLAYBACK_SEEKING);
-        });
+            bufferController.updateBufferTimestampOffset(representationInfo)
+                .then(() => {
+                    expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(2);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
 
-        /*
-        it('should trigger BUFFER_LEVEL_STATE_CHANGED event', function (done) {
-            const buffer = mediaSourceMock.buffers[0];
-            const onBufferStateChanged = function (e) {
-                eventBus.off(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferStateChanged, this);
-                expect(e.state).to.equal('bufferLoaded');
-
-                done();
-            };
-            eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferStateChanged, this);
-
-            // send event
-            eventBus.trigger(Events.PLAYBACK_SEEKING);
         });
-
-        it('should trigger BUFFER_LOADED event if enough buffer', function (done) {
-            const buffer = mediaSourceMock.buffers[0];
-            const onBufferLoaded = function () {
-                eventBus.off(Events.BUFFER_LOADED, onBufferLoaded, this);
-
-                done();
-            };
-            eventBus.on(Events.BUFFER_LOADED, onBufferLoaded, this);
-
-            // send event
-            eventBus.trigger(Events.PLAYBACK_SEEKING);
-        });*/
     });
 
     describe('Method getBufferRange', function () {
         let buffer;
-        beforeEach(function () {
+        beforeEach(function (done) {
             bufferController.initialize(mediaSourceMock);
-            bufferController.createBuffer(mediaInfo);
-            const sink = bufferController.getBuffer();
-            buffer = sink.getBuffer();
-            expect(mediaSourceMock.buffers).to.have.lengthOf(1);
+            bufferController.createBufferSink(mediaInfo)
+                .then(() => {
+                    const sink = bufferController.getBuffer();
+                    buffer = sink.getBuffer();
+                    expect(mediaSourceMock.buffers).to.have.lengthOf(1);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should return range of buffered data', function () {
diff --git a/test/unit/streaming.controllers.FragmentController.js b/test/unit/streaming.controllers.FragmentController.js
index a786667b2c..d72bb01d2f 100644
--- a/test/unit/streaming.controllers.FragmentController.js
+++ b/test/unit/streaming.controllers.FragmentController.js
@@ -24,7 +24,7 @@ describe('FragmentController', function () {
     Events.extend(MediaPlayerEvents);
 
     it('should create or return model for a given media type', function () {
-        videoFragmentModel = fragmentController.getModel('video');
+        videoFragmentModel = fragmentController.getModel('DUMMY_STREAM-01', 'video');
         expect(videoFragmentModel).to.exist; // jshint ignore:line
     });
 
@@ -32,11 +32,11 @@ describe('FragmentController', function () {
         const context1 = 1;
         const context2 = 2;
 
-        const model1 = fragmentController.getModel(context1);
-        const model2 = fragmentController.getModel(context2);
+        const model1 = fragmentController.getModel('DUMMY_STREAM-01', context1);
+        const model2 = fragmentController.getModel('DUMMY_STREAM-01', context2);
 
-        expect(fragmentController.getModel(context1)).to.be.equal(model1);
-        expect(fragmentController.getModel(context2)).to.be.equal(model2);
+        expect(fragmentController.getModel('DUMMY_STREAM-01', context1)).to.be.equal(model1);
+        expect(fragmentController.getModel('DUMMY_STREAM-01', context2)).to.be.equal(model2);
     });
 
     it('should trigger INIT_FRAGMENT_LOADED event when an init segment download is completed.', function (done) {
diff --git a/test/unit/streaming.controllers.MediaController.js b/test/unit/streaming.controllers.MediaController.js
index c7e3b4a874..bd516a824f 100644
--- a/test/unit/streaming.controllers.MediaController.js
+++ b/test/unit/streaming.controllers.MediaController.js
@@ -30,9 +30,8 @@ describe('MediaController', function () {
     });
 
     afterEach(function () {
+        settings.reset();
         mediaController.reset();
-        mediaController.setSwitchMode('video', Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-        mediaController.setSwitchMode('audio', Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE);
         mediaController = null;
     });
 
@@ -68,104 +67,6 @@ describe('MediaController', function () {
         });
     });
 
-    describe('Switch Mode', function () {
-        it('should not set switch mode if mode is not supported', function () {
-            let switchmode = mediaController.getSwitchMode('video');
-            expect(switchmode).to.equal(Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-
-            mediaController.setSwitchMode('video', 'unsupported');
-
-            switchmode = mediaController.getSwitchMode('video');
-            expect(switchmode).to.equal(Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-        });
-
-        it('should not set switch mode if type is not supported', function () {
-            let switchmode = mediaController.getSwitchMode('test');
-            expect(switchmode).to.not.exist; // jshint ignore:line
-
-            mediaController.setSwitchMode('test', Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-
-            switchmode = mediaController.getSwitchMode('test');
-            expect(switchmode).to.not.exist; // jshint ignore:line
-        });
-
-        it('should set and get switch mode for video', function () {
-            let switchmode = mediaController.getSwitchMode('video');
-            expect(switchmode).to.equal(Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-
-            mediaController.setSwitchMode('video', Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE);
-
-            switchmode = mediaController.getSwitchMode('video');
-
-            expect(switchmode).to.equal(Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE);
-
-        });
-
-        it('should set and get switch mode for audio', function () {
-            let switchmode = mediaController.getSwitchMode('audio');
-            expect(switchmode).to.equal(Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE);
-
-            mediaController.setSwitchMode('audio', Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-
-            switchmode = mediaController.getSwitchMode('audio');
-
-            expect(switchmode).to.equal(Constants.TRACK_SWITCH_MODE_NEVER_REPLACE);
-
-        });
-    });
-
-    describe('Selection Mode For Initial Track', function () {
-        it('should not set selection mode if mode is not supported', function () {
-            let mode = mediaController.getSelectionModeForInitialTrack();
-            expect(mode).to.equal(Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE);
-
-            mediaController.setSelectionModeForInitialTrack('unsupported');
-
-            mode = mediaController.getSelectionModeForInitialTrack();
-            expect(mode).to.equal(Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE);
-        });
-
-        it('should set and get selection mode', function () {
-            let mode = mediaController.getSelectionModeForInitialTrack();
-            expect(mode).to.equal(Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE);
-
-            mediaController.setSelectionModeForInitialTrack(Constants.TRACK_SELECTION_MODE_WIDEST_RANGE);
-
-            mode = mediaController.getSelectionModeForInitialTrack();
-            expect(mode).to.equal(Constants.TRACK_SELECTION_MODE_WIDEST_RANGE);
-        });
-    });
-
-    describe('Multi Track Supported', function () {
-        it('should return false if type is not supported', function () {
-
-            let supported = mediaController.isMultiTrackSupportedByType(null);
-            expect(supported).to.be.false; // jshint ignore:line
-
-            supported = mediaController.isMultiTrackSupportedByType(undefined);
-            expect(supported).to.be.false; // jshint ignore:line
-
-            supported = mediaController.isMultiTrackSupportedByType('toto');
-            expect(supported).to.be.false; // jshint ignore:line
-        });
-
-        it('should return true if type is supported', function () {
-
-            let supported = mediaController.isMultiTrackSupportedByType(Constants.AUDIO);
-            expect(supported).to.be.true; // jshint ignore:line
-
-            supported = mediaController.isMultiTrackSupportedByType(Constants.VIDEO);
-            expect(supported).to.be.true; // jshint ignore:line
-
-            supported = mediaController.isMultiTrackSupportedByType(Constants.TEXT);
-            expect(supported).to.be.true; // jshint ignore:line
-
-            supported = mediaController.isMultiTrackSupportedByType(Constants.FRAGMENTED_TEXT);
-            expect(supported).to.be.true; // jshint ignore:line
-        });
-
-    });
-
     describe('Track Equality', function () {
         it('should return false if track are not equals', function () {
 
@@ -293,7 +194,7 @@ describe('MediaController', function () {
 
             // check that track has been added
 
-            let trackList = mediaController.getTracksFor(trackType, streamInfo);
+            let trackList = mediaController.getTracksFor(trackType, streamInfo.id);
             expect(trackList).to.have.lengthOf(1);
             expect(objectUtils.areEqual(trackList[0], track)).to.be.true; // jshint ignore:line
         });
@@ -322,7 +223,7 @@ describe('MediaController', function () {
             mediaController.setTrack(track);
 
             // check that track has been added
-            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, track)).to.be.true; // jshint ignore:line
         });
 
@@ -403,7 +304,7 @@ describe('MediaController', function () {
             mediaController.setTrack(track1);
 
             // check that track has been added
-            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, track1)).to.be.true; // jshint ignore:line
 
             let onTrackChanged = function (e) {
@@ -445,21 +346,21 @@ describe('MediaController', function () {
 
             mediaController.addTrack(track);
 
-            let trackList = mediaController.getTracksFor(trackType, streamInfo);
+            let trackList = mediaController.getTracksFor(trackType, streamInfo.id);
             expect(trackList).to.have.lengthOf(1);
             expect(objectUtils.areEqual(trackList[0], track)).to.be.true; // jshint ignore:line
 
-            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, track)).to.be.false; // jshint ignore:line
 
-            // call to checkInitialMediaSettingsForType
+            // call to setInitialMediaSettingsForType
             mediaController.setInitialSettings(trackType, {
                 lang: 'fr',
                 viewpoint: 'viewpoint'
             });
-            mediaController.checkInitialMediaSettingsForType(trackType, streamInfo);
+            mediaController.setInitialMediaSettingsForType(trackType, streamInfo);
 
-            currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, track)).to.be.true; // jshint ignore:line
 
         });
@@ -480,21 +381,21 @@ describe('MediaController', function () {
 
             mediaController.addTrack(track);
 
-            let trackList = mediaController.getTracksFor(trackType, streamInfo);
+            let trackList = mediaController.getTracksFor(trackType, streamInfo.id);
             expect(trackList).to.have.lengthOf(1);
             expect(objectUtils.areEqual(trackList[0], track)).to.be.true; // jshint ignore:line
 
-            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, track)).to.be.false; // jshint ignore:line
 
-            // call to checkInitialMediaSettingsForType
+            // call to setInitialMediaSettingsForType
             mediaController.setInitialSettings(trackType, {
                 lang: 'fr|en|qtz',
                 viewpoint: 'viewpoint'
             });
-            mediaController.checkInitialMediaSettingsForType(trackType, streamInfo);
+            mediaController.setInitialMediaSettingsForType(trackType, streamInfo);
 
-            currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, track)).to.be.true; // jshint ignore:line
         });
 
@@ -524,23 +425,23 @@ describe('MediaController', function () {
             mediaController.addTrack(frTrack);
             mediaController.addTrack(qtzTrack);
 
-            let trackList = mediaController.getTracksFor(trackType, streamInfo);
+            let trackList = mediaController.getTracksFor(trackType, streamInfo.id);
             expect(trackList).to.have.lengthOf(2);
             expect(objectUtils.areEqual(trackList[0], frTrack)).to.be.true; // jshint ignore:line
             expect(objectUtils.areEqual(trackList[1], qtzTrack)).to.be.true; // jshint ignore:line
 
-            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            let currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, frTrack)).to.be.false; // jshint ignore:line
             expect(objectUtils.areEqual(currentTrack, qtzTrack)).to.be.false; // jshint ignore:line
 
-            // call to checkInitialMediaSettingsForType
+            // call to setInitialMediaSettingsForType
             mediaController.setInitialSettings(trackType, {
                 lang: /qtz|mis/,
                 viewpoint: 'viewpoint'
             });
-            mediaController.checkInitialMediaSettingsForType(trackType, streamInfo);
+            mediaController.setInitialMediaSettingsForType(trackType, streamInfo);
 
-            currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo);
+            currentTrack = mediaController.getCurrentTrackFor(trackType, streamInfo.id);
             expect(objectUtils.areEqual(currentTrack, qtzTrack)).to.be.true; // jshint ignore:line
         });
     });
@@ -560,7 +461,7 @@ describe('MediaController', function () {
 
         describe('"highestBitrate" mode', function () {
             beforeEach(function () {
-                mediaController.setSelectionModeForInitialTrack(Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE);
+                settings.update({ streaming: { selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE }});
             });
 
             it('should select track with highest bitrate', function () {
@@ -590,7 +491,7 @@ describe('MediaController', function () {
 
         describe('"firstTrack" mode', function () {
             beforeEach(function () {
-                mediaController.setSelectionModeForInitialTrack(Constants.TRACK_SELECTION_MODE_FIRST_TRACK);
+                settings.update({ streaming: { selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_FIRST_TRACK }});
             });
 
             it('should select first track', function () {
@@ -620,7 +521,7 @@ describe('MediaController', function () {
 
         describe('"highestEfficiency" mode', function () {
             beforeEach(function () {
-                mediaController.setSelectionModeForInitialTrack(Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY);
+                settings.update({ streaming: { selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY }});
             });
 
             it('should select video track with lowest bitrate among equal resolutions', function () {
@@ -658,7 +559,7 @@ describe('MediaController', function () {
 
         describe('"widestRange" mode', function () {
             beforeEach(function () {
-                mediaController.setSelectionModeForInitialTrack(Constants.TRACK_SELECTION_MODE_WIDEST_RANGE);
+                settings.update({ streaming: { selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_WIDEST_RANGE }});
             });
 
             it('should select track with most bitrates', function () {
diff --git a/test/unit/streaming.controllers.MediaSourceController.js b/test/unit/streaming.controllers.MediaSourceController.js
index 1c15db520c..51902050cf 100644
--- a/test/unit/streaming.controllers.MediaSourceController.js
+++ b/test/unit/streaming.controllers.MediaSourceController.js
@@ -21,17 +21,21 @@ describe('MediaSourceController', function () {
         }
 
         if (typeof MediaSource === 'undefined') {
-            global.MediaSource = function () {};
+            global.MediaSource = function () {
+                return {};
+            };
         }
 
         if (typeof WebKitMediaSource === 'undefined') {
-            global.WebKitMediaSource = function () {};
+            global.WebKitMediaSource = function () {
+                return {};
+            };
         }
     });
 
     afterEach(function () {
         delete global.window;
-        delete global.MediaSourc;
+        delete global.MediaSource;
         delete global.WebKitMediaSource;
     });
 
@@ -40,41 +44,28 @@ describe('MediaSourceController', function () {
     });
 
     afterEach(function () {
-        // mediaSourceController.reset();
         mediaSourceController = null;
     });
 
     describe('Method createMediaSource', function () {
+
         it('should return null if MediaSource is undefined', function () {
             expect(mediaSourceController.createMediaSource()).to.not.exist; // jshint ignore:line
         });
 
-        it('should return null if MediaSource API is MediaSource', function () {
-
-            window.MediaSource = 'MediaSource';
-            expect(mediaSourceController.createMediaSource()).to.be.instanceOf(MediaSource);
-        });
-
-        it('should return null if MediaSource API is WebkitMediaSource', function () {
-
-            window.WebKitMediaSource = 'WebKitMediaSource';
-            expect(mediaSourceController.createMediaSource()).to.be.instanceOf(WebKitMediaSource);
-        });
-
     });
 
     describe('Source management', function () {
-        it('should attach source to video model', function () {
 
+        it('should attach source to video model', function () {
             let videoModel = new VideoModelMock();
             expect(videoModel.getSource()).to.not.exist; // jshint ignore:line
 
-            mediaSourceController.attachMediaSource('source', videoModel);
-            expect(videoModel.getSource()).to.equal('source');
+            mediaSourceController.attachMediaSource(videoModel);
+            expect(videoModel.getSource()).to.not.be.null; // jshint ignore:line
         });
 
         it('should detach source from video model', function () {
-
             let videoModel = new VideoModelMock();
             expect(videoModel.getSource()).to.not.exist; // jshint ignore:line
             videoModel.setSource('source');
@@ -84,42 +75,65 @@ describe('MediaSourceController', function () {
             expect(videoModel.getSource()).to.not.exist; // jshint ignore:line
         });
 
+        it('should not update source duration if not in readyState open', function () {
+            window.MediaSource = 'MediaSource';
+            let source = mediaSourceController.createMediaSource();
+
+            source.readyState = 'closed';
+            source.sourceBuffers = [];
+
+            mediaSourceController.setDuration(8);
+            expect(source.duration).to.be.undefined; // jshint ignore:line
+        });
+
         it('should update source duration', function () {
+            window.MediaSource = 'MediaSource';
+            let source = mediaSourceController.createMediaSource();
 
-            let source = {
-                readyState: 'open',
-                sourceBuffers: [],
-                duration: NaN
-            };
-            mediaSourceController.setDuration(source, 'duration');
-            expect(source.duration).to.equal('duration');
+            source.readyState = 'open';
+            source.sourceBuffers = [];
 
+            mediaSourceController.setDuration(8);
+            expect(source.duration).to.equal(8);
         });
 
-        it('should update source seekable range', function () {
+        it('should not update source seekable range if not in readystate open', function () {
+            let source = mediaSourceController.createMediaSource();
 
-            class FakeSource {
-                constructor() {
-                    this.clearLiveSeekableRange();
-                    this.readyState = 'open';
-                }
+            source.readyState = 'closed';
+            source.start = 0;
+            source.end = 0;
 
-                clearLiveSeekableRange() {
-                    this.start = 0;
-                    this.end = 0;
-                }
+            source.clearLiveSeekableRange = function () {
+                this.start = 0;
+                this.end = 0;
+            };
+            source.setLiveSeekableRange = function (start, end) {
+                this.start = start;
+                this.end = end;
+            };
 
-                setLiveSeekableRange(start, end) {
-                    this.start = start;
-                    this.end = end;
-                }
-            }
+            mediaSourceController.setSeekable(1, 2);
+            expect(source.start).to.equal(0);
+            expect(source.end).to.equal(0);
+        });
 
-            let source = new FakeSource();
-            mediaSourceController.setSeekable(source, 1, 2);
+        it('should update source seekable range', function () {
+            let source = mediaSourceController.createMediaSource();
+
+            source.readyState = 'open';
+            source.clearLiveSeekableRange = function () {
+                this.start = 0;
+                this.end = 0;
+            };
+            source.setLiveSeekableRange = function (start, end) {
+                this.start = start;
+                this.end = end;
+            };
+
+            mediaSourceController.setSeekable(1, 2);
             expect(source.start).to.equal(1);
             expect(source.end).to.equal(2);
-
         });
     });
 
diff --git a/test/unit/streaming.controllers.PlaybackControllers.js b/test/unit/streaming.controllers.PlaybackControllers.js
index 20c14a603e..bf11644dba 100644
--- a/test/unit/streaming.controllers.PlaybackControllers.js
+++ b/test/unit/streaming.controllers.PlaybackControllers.js
@@ -327,199 +327,4 @@ describe('PlaybackController', function () {
             });
         });
     });
-
-    describe('start time', function () {
-        let expectedSeekTime;
-        let doneFn;
-
-        let staticStreamInfo = { manifestInfo: { isDynamic: false }, start: 10, duration: 600 };
-        let dynamicStreamInfo = { manifestInfo: { isDynamic: true }, start: 10, duration: Infinity };
-        let dvrWindowRange = { start: 70, end: 100 };
-        let liveStartTime = 85;
-
-        let onPlaybackSeeking = function (e) {
-            eventBus.off(Events.PLAYBACK_SEEKING, onPlaybackSeeking);
-            expect(e.seekTime).to.equal(expectedSeekTime);
-            doneFn();
-        };
-
-        beforeEach(function () {
-            videoModelMock.time = -1;
-            dashMetricsMock.addDVRInfo('video', Date.now(), null, dvrWindowRange);
-            eventBus.on(Events.PLAYBACK_SEEKING, onPlaybackSeeking, this);
-        });
-
-        it('should start static stream at period start', function (done) {
-            doneFn = done;
-
-            expectedSeekTime = staticStreamInfo.start;
-
-            playbackController.initialize(staticStreamInfo);
-            streamMock.initialize(staticStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {});
-        });
-
-        it('should start static stream at #t', function (done) {
-            doneFn = done;
-
-            let uriStartTime = 10;
-            uriFragmentModelMock.setURIFragmentData({t: uriStartTime.toString()});
-
-            expectedSeekTime = staticStreamInfo.start + uriStartTime;
-
-            playbackController.initialize(staticStreamInfo);
-            streamMock.initialize(staticStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {});
-        });
-
-        it('should start static stream at period start if #t is before period start', function (done) {
-            doneFn = done;
-
-            let uriStartTime = -20;
-            uriFragmentModelMock.setURIFragmentData({t: uriStartTime.toString()});
-
-            expectedSeekTime = staticStreamInfo.start;
-
-            playbackController.initialize(staticStreamInfo);
-            streamMock.initialize(staticStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {});
-        });
-
-        it('should start static stream at period start if #t is beyond period end', function (done) {
-            doneFn = done;
-
-            let uriStartTime = staticStreamInfo.duration + 100;
-            uriFragmentModelMock.setURIFragmentData({t: uriStartTime.toString()});
-
-            expectedSeekTime = staticStreamInfo.start;
-
-            playbackController.initialize(staticStreamInfo);
-            streamMock.initialize(staticStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {});
-        });
-
-        it('should start static stream at period start if #t=posix: notation is used', function (done) {
-            doneFn = done;
-
-            let uriStartTime = 10;
-            uriFragmentModelMock.setURIFragmentData({t: 'posix:' + uriStartTime.toString()});
-
-            expectedSeekTime = staticStreamInfo.start;
-
-            playbackController.initialize(staticStreamInfo);
-            streamMock.initialize(staticStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {});
-        });
-
-        it('should start static stream at period start if #t= is not a valid', function (done) {
-            doneFn = done;
-
-            uriFragmentModelMock.setURIFragmentData({t: 'abcd'});
-
-            expectedSeekTime = staticStreamInfo.start;
-
-            playbackController.initialize(staticStreamInfo);
-            streamMock.initialize(staticStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {});
-        });
-
-        it('should start dynamic stream at live start time', function (done) {
-            doneFn = done;
-
-            expectedSeekTime = liveStartTime;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at #t', function (done) {
-            doneFn = done;
-
-            let uriStartTime = 70;
-            uriFragmentModelMock.setURIFragmentData({t: uriStartTime.toString()});
-
-            expectedSeekTime = dynamicStreamInfo.start + uriStartTime;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at live start time if #t is before DVR window range', function (done) {
-            doneFn = done;
-
-            let uriStartTime = -10;
-            uriFragmentModelMock.setURIFragmentData({t: uriStartTime.toString()});
-
-            expectedSeekTime = dvrWindowRange.start;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at live start time if #t is not valid', function (done) {
-            doneFn = done;
-
-            uriFragmentModelMock.setURIFragmentData({t: 'abcd'});
-
-            expectedSeekTime = liveStartTime;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at #t=posix', function (done) {
-            doneFn = done;
-
-            let uriStartTime = dvrWindowRange.start + 10;
-            uriFragmentModelMock.setURIFragmentData({t: 'posix:' + uriStartTime.toString()});
-
-            expectedSeekTime = uriStartTime;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at DVR window start if #t=posix is before DVR window range', function (done) {
-            doneFn = done;
-
-            let uriStartTime = 0;
-            uriFragmentModelMock.setURIFragmentData({t: 'posix:' + uriStartTime.toString()});
-
-            expectedSeekTime = dvrWindowRange.start;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at live start time if #t=posix is beyond DVR window range', function (done) {
-            doneFn = done;
-
-            let uriStartTime = dvrWindowRange + 10;
-            uriFragmentModelMock.setURIFragmentData({t: 'posix:' + uriStartTime.toString()});
-
-            expectedSeekTime = liveStartTime;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-
-        it('should start dynamic stream at live start time if #t=posix is not valid', function (done) {
-            doneFn = done;
-
-            uriFragmentModelMock.setURIFragmentData({t: 'posix:abcd'});
-
-            expectedSeekTime = liveStartTime;
-
-            playbackController.initialize(dynamicStreamInfo);
-            streamMock.initialize(dynamicStreamInfo);
-            eventBus.trigger(Events.STREAM_INITIALIZED, {liveStartTime: liveStartTime});
-        });
-    });
 });
diff --git a/test/unit/streaming.controllers.SourceBufferSink.js b/test/unit/streaming.controllers.SourceBufferSink.js
index 27bd210982..97b03a1341 100644
--- a/test/unit/streaming.controllers.SourceBufferSink.js
+++ b/test/unit/streaming.controllers.SourceBufferSink.js
@@ -1,6 +1,4 @@
 import SourceBufferSink from '../../src/streaming/SourceBufferSink';
-import Events from '../../src/core/events/Events';
-import EventBus from '../../src/core/EventBus';
 import FactoryMaker from '../../src/core/FactoryMaker.js';
 import Errors from '../../src/core/errors/Errors';
 
@@ -12,15 +10,20 @@ import MediaSourceMock from './mocks/MediaSourceMock';
 const expect = require('chai').expect;
 const context = {};
 
-const eventBus = EventBus(context).getInstance();
 
 describe('SourceBufferSink', function () {
 
     let sink;
     let textControllerMock;
+    let streamInfo = {
+        id: '1'
+    };
+    let mediaSource;
 
     beforeEach(function () {
         textControllerMock = new TextControllerMock();
+        mediaSource = new MediaSourceMock();
+        sink = SourceBufferSink(context).create({ textController: textControllerMock, mediaSource });
         FactoryMaker.setSingletonInstance(context, 'TextController', textControllerMock);
     });
 
@@ -32,93 +35,118 @@ describe('SourceBufferSink', function () {
     });
 
     describe('Method createSourceBuffer', function () {
-        it('should create and return a buffer', function () {
+        it('should create and return a buffer', function (done) {
             let mediaInfo = {
                 codec: 'video/webm; codecs="vp8, vorbis"'
             };
 
-            let mediaSource = new MediaSourceMock();
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(sink.getBuffer()).to.be.instanceOf(MediaSourceBufferMock); // jshint ignore:line
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(sink.getBuffer()).to.be.instanceOf(MediaSourceBufferMock); // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should create and return a text buffer if codec is of type application/mp4;codecs="stpp"', function () {
+        it('should create and return a text buffer if codec is of type application/mp4;codecs="stpp"', function (done) {
             let mediaInfo = {
                 codec: 'application/mp4;codecs="stpp"'
             };
 
-            let mediaSource = new MediaSourceMock();
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock); // jshint ignore:line
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock); // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should create and return a text buffer if codec is of type application/mp4;codecs="wvtt"', function () {
+        it('should create and return a text buffer if codec is of type application/mp4;codecs="wvtt"', function (done) {
             let mediaInfo = {
                 codec: 'application/mp4;codecs="wvtt"'
             };
 
-            let mediaSource = new MediaSourceMock();
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock); // jshint ignore:line
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock); // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should create and return a text buffer if codec is of type text', function () {
+        it('should create and return a text buffer if codec is of type text', function (done) {
             let mediaInfo = {
                 codec: 'text',
                 isText: true
             };
 
-            let mediaSource = new MediaSourceMock();
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock); // jshint ignore:line
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock); // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should throw an error if codec is unknonw', function () {
+        it('should throw an error if codec is unknown', function (done) {
             let mediaInfo = {
                 codec: 'unknown'
             };
 
-            let mediaSource = new MediaSourceMock();
-            // http://chaijs.com/api/bdd/#method_throw
-            expect(function () {
-                SourceBufferSink(context).create(mediaSource, mediaInfo);
-            }).to.throw(Error, 'unknown');
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    done(new Error('Should reject creation'));
+                })
+                .catch(() => {
+                    done();
+                });
         });
     });
 
     describe('Method removeSourceBuffer', function () {
-        it('should remove a created buffer', function () {
+        it('should remove a created buffer', function (done) {
             let mediaInfo = {
                 codec: 'video/webm; codecs="vp8, vorbis"'
             };
 
-            let mediaSource = new MediaSourceMock();
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
-
-            sink.reset();
-            expect(mediaSource.buffers).to.have.lengthOf(0);
-
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(mediaSource.buffers).to.have.lengthOf(1);
+                    sink.reset();
+                    expect(mediaSource.buffers).to.have.lengthOf(0);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
     });
 
     describe('Method getAllBufferRanges', function () {
-        let sink;
         let buffer;
-        beforeEach(function () {
+
+        beforeEach(function (done) {
             let mediaInfo = {
                 codec: 'video/webm; codecs="vp8, vorbis"'
             };
 
-            let mediaSource = new MediaSourceMock();
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
-            buffer = mediaSource.buffers[0];
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(mediaSource.buffers).to.have.lengthOf(1);
+                    buffer = mediaSource.buffers[0];
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should return all range of buffered data', function () {
@@ -147,124 +175,124 @@ describe('SourceBufferSink', function () {
 
     describe('Method append', function () {
 
-        it('should append data to buffer', function (done) {
-
+        beforeEach(function (done) {
             let mediaInfo = {
                 codec: 'video/webm; codecs="vp8, vorbis"'
             };
-            let mediaSource = new MediaSourceMock();
 
-            function onAppend() {
-                expect(mediaSource.buffers[0].chunk).to.equal('toto');
-                done();
-            }
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppend);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
-
-            sink.append({bytes: 'toto'});
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(mediaSource.buffers).to.have.lengthOf(1);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should append data to text buffer', function (done) {
-
-            let mediaInfo = {
-                codec: 'text',
-                isText: true
-            };
-
-            let mediaSource = new MediaSourceMock();
-            function onAppend() {
-                expect(sink.getBuffer().chunk).to.equal('toto');
-                done();
-            }
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppend);
-            expect(sink.getBuffer()).to.be.instanceOf(TextSourceBufferMock);
-
-            sink.append({bytes: 'toto'});
+        it('should append data to buffer', function (done) {
+            sink.append({ bytes: 'toto' })
+                .then(() => {
+                    expect(mediaSource.buffers[0].chunk).to.equal('toto');
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
         it('should return an error if data to append is null or undefined', function (done) {
+            sink.append()
+                .then(() => {
+                    done(new Error('Should reject append'));
+                })
+                .catch((e) => {
+                    expect(e.error.code).to.equal(Errors.APPEND_ERROR_CODE);
+                    expect(e.error.message).to.equal('chunk is not defined');
+                    done();
+                });
 
-            let mediaInfo = {
-                codec: 'video/webm; codecs="vp8, vorbis"'
-            };
-            let mediaSource = new MediaSourceMock();
-            function onAppend(e) {
-                expect(e.error.code).to.equal(Errors.APPEND_ERROR_CODE);
-                expect(e.error.message).to.equal('chunk is not defined');
-                done();
-            }
-
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppend);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
-
-            sink.append();
         });
 
     });
 
     describe('Method remove', function () {
 
-        it('should remove data from buffer', function (done) {
-
+        beforeEach(function (done) {
             let mediaInfo = {
                 codec: 'video/webm; codecs="vp8, vorbis"'
             };
 
-            function onAppend() {
-                // remove data
-                sink.remove(0, 1);
-            }
-
-            let mediaSource = new MediaSourceMock();
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppend);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
-
-            function onRemoved() {
-                eventBus.off(Events.SOURCEBUFFER_REMOVE_COMPLETED, onAppend, this);
-                expect(mediaSource.buffers[0].chunk).to.be.null; // jshint ignore:line
-                done();
-            }
-            eventBus.on(Events.SOURCEBUFFER_REMOVE_COMPLETED, onRemoved, this);
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(mediaSource.buffers).to.have.lengthOf(1);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
+        });
 
-            sink.append({bytes: 'toto'});
+        it('should remove data from buffer', function (done) {
+            sink.append({ bytes: 'toto' })
+                .then(() => {
+                    expect(mediaSource.buffers[0].chunk).to.equal('toto');
+                    return sink.remove({ start: 0, end: 1 });
+                })
+                .then(() => {
+                    expect(mediaSource.buffers[0].chunk).to.be.null; // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
     });
 
     describe('Method abort', function () {
 
-        it('should abort', function () {
-
+        beforeEach(function (done) {
             let mediaInfo = {
                 codec: 'video/webm; codecs="vp8, vorbis"'
             };
 
-            let mediaSource = new MediaSourceMock();
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
+            sink.initializeForFirstUse(streamInfo, mediaInfo)
+                .then(() => {
+                    expect(mediaSource.buffers).to.have.lengthOf(1);
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
+        });
+
+        it('should abort', function (done) {
             let buffer = mediaSource.buffers[0];
 
             expect(buffer.aborted).to.be.false; // jshint ignore:line
-            sink.abort();
-            expect(buffer.aborted).to.be.true; // jshint ignore:line
+            sink.abort()
+                .then(() => {
+                    expect(buffer.aborted).to.be.true; // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
 
-        it('should not abort if media source is not opened', function () {
-
-            let mediaInfo = {
-                codec: 'video/webm; codecs="vp8, vorbis"'
-            };
-
-            let mediaSource = new MediaSourceMock();
+        it('should not abort if media source is not opened', function (done) {
             mediaSource.readyState = 'closed';
-            sink = SourceBufferSink(context).create(mediaSource, mediaInfo);
-            expect(mediaSource.buffers).to.have.lengthOf(1);
             let buffer = mediaSource.buffers[0];
 
             expect(buffer.aborted).to.be.false; // jshint ignore:line
-            sink.abort();
-            expect(buffer.aborted).to.be.false; // jshint ignore:line
+            sink.abort()
+                .then(() => {
+                    expect(buffer.aborted).to.be.false; // jshint ignore:line
+                    done();
+                })
+                .catch((e) => {
+                    done(e);
+                });
         });
     });
 
diff --git a/test/unit/streaming.controllers.StreamController.js b/test/unit/streaming.controllers.StreamController.js
index 53137aba28..127eb8cd54 100644
--- a/test/unit/streaming.controllers.StreamController.js
+++ b/test/unit/streaming.controllers.StreamController.js
@@ -15,15 +15,19 @@ import DashMetricsMock from './mocks/DashMetricsMock';
 import ProtectionControllerMock from './mocks/ProtectionControllerMock';
 import VideoModelMock from './mocks/VideoModelMock';
 import PlaybackControllerMock from './mocks/PlaybackControllerMock';
+import URIFragmentModelMock from './mocks/URIFragmentModelMock';
+import CapabilitiesFilterMock from './mocks/CapabilitiesFilterMock';
+import TextControllerMock from './mocks/TextControllerMock';
 
 const chai = require('chai');
 const spies = require('chai-spies');
+const sinon = require('sinon');
 
 chai.use(spies);
 const expect = chai.expect;
 
 const context = {};
-const streamController = StreamController(context).getInstance();
+let streamController = StreamController(context).getInstance();
 const eventBus = EventBus(context).getInstance();
 let settings = Settings(context).getInstance();
 
@@ -38,6 +42,9 @@ const protectionControllerMock = new ProtectionControllerMock();
 const videoModelMock = new VideoModelMock();
 const playbackControllerMock = new PlaybackControllerMock();
 const baseUrlControllerMock = new BaseURLControllerMock();
+const uriFragmentModelMock = new URIFragmentModelMock();
+const capabilitiesFilterMock = new CapabilitiesFilterMock();
+const textControllerMock = new TextControllerMock();
 
 Events.extend(ProtectionEvents);
 
@@ -54,13 +61,13 @@ describe('StreamController', function () {
         it('should return undefined if getStreamById is called without parameters', () => {
             const stream = streamController.getStreamById();
 
-            expect(stream).to.be.undefined; // jshint ignore:line
+            expect(stream).to.be.null; // jshint ignore:line
         });
 
-        it('should return undefined if getStreamById is called but no stream has been composed', () => {
+        it('should return null if getStreamById is called but no stream has been composed', () => {
             const stream = streamController.getStreamById('idx');
 
-            expect(stream).to.be.undefined; // jshint ignore:line
+            expect(stream).to.be.null; // jshint ignore:line
         });
 
         it('should return null if getActiveStreamInfo is called without parameters, activeStream is undefined', () => {
@@ -78,7 +85,7 @@ describe('StreamController', function () {
         });
 
         it('should throw an exception when attempting to call load while setConfig has not been called properly - empty manifestLoader object', function () {
-            streamController.setConfig({manifestLoader: {}});
+            streamController.setConfig({ manifestLoader: {} });
             expect(streamController.load.bind(streamController)).to.throw(Constants.MISSING_CONFIG_ERROR);
         });
 
@@ -115,17 +122,21 @@ describe('StreamController', function () {
     describe('Well initialized', () => {
 
         beforeEach(function () {
-            streamController.setConfig({adapter: adapterMock,
-                                        manifestLoader: manifestLoaderMock,
-                                        timelineConverter: timelineConverterMock,
-                                        manifestModel: manifestModelMock,
-                                        errHandler: errHandlerMock,
-                                        dashMetrics: dashMetricsMock,
-                                        protectionController: protectionControllerMock,
-                                        videoModel: videoModelMock,
-                                        playbackController: playbackControllerMock,
-                                        baseURLController: baseUrlControllerMock,
-                                        settings: settings});
+            streamController.setConfig({
+                adapter: adapterMock,
+                manifestLoader: manifestLoaderMock,
+                timelineConverter: timelineConverterMock,
+                manifestModel: manifestModelMock,
+                errHandler: errHandlerMock,
+                dashMetrics: dashMetricsMock,
+                protectionController: protectionControllerMock,
+                videoModel: videoModelMock,
+                playbackController: playbackControllerMock,
+                baseURLController: baseUrlControllerMock,
+                capabilitiesFilter: capabilitiesFilterMock,
+                textController: textControllerMock,
+                settings: settings
+            });
 
             streamController.initialize(false);
         });
@@ -134,7 +145,7 @@ describe('StreamController', function () {
             it('should trigger MANIFEST_UPDATED event when loadWithManifest is called', function () {
                 let spy = chai.spy();
                 eventBus.on(Events.MANIFEST_UPDATED, spy);
-                streamController.loadWithManifest({loadedTime: new Date()});
+                streamController.loadWithManifest({ loadedTime: new Date() });
                 expect(spy).to.have.been.called.exactly(1);
                 eventBus.off(Events.MANIFEST_UPDATED, spy);
             });
@@ -148,46 +159,42 @@ describe('StreamController', function () {
         describe('error management', () => {
 
             it('should throw an exception when attempting to composeStreams while no manifest has been parsed', function () {
-                let spy = chai.spy();
-                eventBus.on(Events.PROTECTION_CREATED, spy);
-
                 eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
-                expect(spy).to.have.been.called.exactly(1);
                 expect(errHandlerMock.errorValue).to.include('There are no streams');
             });
 
             it('should return the correct error when a playback error occurs : MEDIA_ERR_ABORTED', function () {
-                eventBus.trigger(Events.PLAYBACK_ERROR, {error: {code: 1}});
+                eventBus.trigger(Events.PLAYBACK_ERROR, { error: { code: 1 } });
 
                 expect(errHandlerMock.errorValue).to.include('MEDIA_ERR_ABORTED');
             });
 
             it('should return the correct error when a playback error occurs : MEDIA_ERR_NETWORK', function () {
-                eventBus.trigger(Events.PLAYBACK_ERROR, {error: {code: 2}});
+                eventBus.trigger(Events.PLAYBACK_ERROR, { error: { code: 2 } });
 
                 expect(errHandlerMock.errorValue).to.include('MEDIA_ERR_NETWORK');
             });
 
             it('should return the correct error when a playback error occurs : MEDIA_ERR_DECODE', function () {
-                eventBus.trigger(Events.PLAYBACK_ERROR, {error: {code: 3}});
+                eventBus.trigger(Events.PLAYBACK_ERROR, { error: { code: 3 } });
 
                 expect(errHandlerMock.errorValue).to.include('MEDIA_ERR_DECODE');
             });
 
             it('should return the correct error when a playback error occurs : MEDIA_ERR_SRC_NOT_SUPPORTED', function () {
-                eventBus.trigger(Events.PLAYBACK_ERROR, {error: {code: 4}});
+                eventBus.trigger(Events.PLAYBACK_ERROR, { error: { code: 4 } });
 
                 expect(errHandlerMock.errorValue).to.include('MEDIA_ERR_SRC_NOT_SUPPORTED');
             });
 
             it('should return the correct error when a playback error occurs : MEDIA_ERR_ENCRYPTED', function () {
-                eventBus.trigger(Events.PLAYBACK_ERROR, {error: {code: 5}});
+                eventBus.trigger(Events.PLAYBACK_ERROR, { error: { code: 5 } });
 
                 expect(errHandlerMock.errorValue).to.include('MEDIA_ERR_ENCRYPTED');
             });
 
             it('should return the correct error when a playback error occurs : UNKNOWN', function () {
-                eventBus.trigger(Events.PLAYBACK_ERROR, {error: {code: 6}});
+                eventBus.trigger(Events.PLAYBACK_ERROR, { error: { code: 6 } });
 
                 expect(errHandlerMock.errorValue).to.include('UNKNOWN');
             });
@@ -196,9 +203,245 @@ describe('StreamController', function () {
                 let spy = chai.spy();
                 eventBus.on(Events.STREAM_TEARDOWN_COMPLETE, spy);
 
-                eventBus.trigger(Events.MANIFEST_UPDATED, {error: {}});
+                eventBus.trigger(Events.MANIFEST_UPDATED, { error: {} });
                 expect(spy).to.have.been.called.exactly(1);
             });
         });
+
+        describe('start time', function () {
+
+            let expectedStartTime;
+            let doneFn;
+            let getStreamsInfoStub;
+            let getIsDynamicStub;
+
+            let staticStreamInfo = { manifestInfo: { isDynamic: false }, start: 10, duration: 600, id: '1' };
+            let dynamicStreamInfo = {
+                manifestInfo: { isDynamic: true, DVRWindowSize: 30, minBufferTime: 4 },
+                start: 10,
+                duration: Infinity,
+                id: '1'
+            };
+            let dvrWindowRange = { start: 70, end: 100 };
+            let liveStartTime = 85;
+
+            let onInitialStreamSwitch = function (e) {
+                try {
+                    eventBus.off(Events.INITIAL_STREAM_SWITCH, onInitialStreamSwitch);
+                    expect(e.startTime).to.equal(expectedStartTime);
+                    doneFn();
+                } catch (e) {
+                    doneFn(e);
+                }
+            };
+
+            beforeEach(function () {
+                videoModelMock.time = -1;
+                dashMetricsMock.addDVRInfo('video', Date.now(), null, dvrWindowRange);
+                streamController.setConfig({
+                    adapter: adapterMock,
+                    manifestLoader: manifestLoaderMock,
+                    timelineConverter: timelineConverterMock,
+                    manifestModel: manifestModelMock,
+                    errHandler: errHandlerMock,
+                    dashMetrics: dashMetricsMock,
+                    protectionController: protectionControllerMock,
+                    videoModel: videoModelMock,
+                    playbackController: playbackControllerMock,
+                    baseURLController: baseUrlControllerMock,
+                    settings: settings,
+                    uriFragmentModel: uriFragmentModelMock
+                });
+
+                streamController.initialize(false);
+                getStreamsInfoStub = sinon.stub(adapterMock, 'getStreamsInfo');
+                getIsDynamicStub = sinon.stub(adapterMock, 'getIsDynamic');
+                eventBus.on(Events.INITIAL_STREAM_SWITCH, onInitialStreamSwitch, this);
+            });
+
+            afterEach(function () {
+                streamController.reset();
+                getStreamsInfoStub.restore();
+                getIsDynamicStub.restore();
+                getStreamsInfoStub = null;
+                getIsDynamicStub = null;
+                eventBus.off(Events.INITIAL_STREAM_SWITCH, onInitialStreamSwitch);
+                uriFragmentModelMock.reset();
+            });
+
+            describe('static streams', function () {
+
+                beforeEach(function () {
+                    getIsDynamicStub.returns(false);
+                });
+
+
+                it('should start static stream at period start', function (done) {
+                    doneFn = done;
+
+                    expectedStartTime = staticStreamInfo.start;
+                    getStreamsInfoStub.returns([staticStreamInfo]);
+
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start static stream at #t', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = 10;
+                    uriFragmentModelMock.setURIFragmentData({ t: uriStartTime.toString() });
+
+                    expectedStartTime = staticStreamInfo.start + uriStartTime;
+
+                    getStreamsInfoStub.returns([staticStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start static stream at period start if #t is before period start', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = -20;
+                    uriFragmentModelMock.setURIFragmentData({ t: uriStartTime.toString() });
+
+                    expectedStartTime = staticStreamInfo.start;
+
+                    getStreamsInfoStub.returns([staticStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start static stream at period start if #t is beyond period end', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = staticStreamInfo.duration + 100;
+                    uriFragmentModelMock.setURIFragmentData({ t: uriStartTime.toString() });
+
+                    expectedStartTime = staticStreamInfo.start;
+
+                    getStreamsInfoStub.returns([staticStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start static stream at period start if #t=posix: notation is used', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = 10;
+                    uriFragmentModelMock.setURIFragmentData({ t: 'posix:' + uriStartTime.toString() });
+
+                    expectedStartTime = staticStreamInfo.start;
+
+                    getStreamsInfoStub.returns([staticStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start static stream at period start if #t= is not a valid', function (done) {
+                    doneFn = done;
+
+                    uriFragmentModelMock.setURIFragmentData({ t: 'abcd' });
+
+                    expectedStartTime = staticStreamInfo.start;
+
+                    getStreamsInfoStub.returns([staticStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+            });
+
+            describe('dynamic streams', function () {
+
+                beforeEach(function () {
+                    getIsDynamicStub.returns(true);
+                });
+
+                it('should start dynamic stream at live start time', function (done) {
+                    doneFn = done;
+
+                    expectedStartTime = liveStartTime;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at #t', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = 70;
+                    uriFragmentModelMock.setURIFragmentData({ t: uriStartTime.toString() });
+
+                    expectedStartTime = dynamicStreamInfo.start + uriStartTime;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at live start time if #t is before DVR window range', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = -10;
+                    uriFragmentModelMock.setURIFragmentData({ t: uriStartTime.toString() });
+
+                    expectedStartTime = dvrWindowRange.start;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at live start time if #t is not valid', function (done) {
+                    doneFn = done;
+
+                    uriFragmentModelMock.setURIFragmentData({ t: 'abcd' });
+
+                    expectedStartTime = liveStartTime;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at #t=posix', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = dvrWindowRange.start + 10;
+                    uriFragmentModelMock.setURIFragmentData({ t: 'posix:' + uriStartTime.toString() });
+
+                    expectedStartTime = uriStartTime;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at DVR window start if #t=posix is before DVR window range', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = 0;
+                    uriFragmentModelMock.setURIFragmentData({ t: 'posix:' + uriStartTime.toString() });
+
+                    expectedStartTime = dvrWindowRange.start;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at live start time if #t=posix is beyond DVR window range', function (done) {
+                    doneFn = done;
+
+                    let uriStartTime = dvrWindowRange + 10;
+                    uriFragmentModelMock.setURIFragmentData({ t: 'posix:' + uriStartTime.toString() });
+
+                    expectedStartTime = liveStartTime;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+
+                it('should start dynamic stream at live start time if #t=posix is not valid', function (done) {
+                    doneFn = done;
+
+                    uriFragmentModelMock.setURIFragmentData({ t: 'posix:abcd' });
+
+                    expectedStartTime = liveStartTime;
+
+                    getStreamsInfoStub.returns([dynamicStreamInfo]);
+                    eventBus.trigger(Events.TIME_SYNCHRONIZATION_COMPLETED);
+                });
+            });
+        });
     });
 });
diff --git a/test/unit/streaming.models.FragmentModel.js b/test/unit/streaming.models.FragmentModel.js
index abfa1ba0f2..871813dfe9 100644
--- a/test/unit/streaming.models.FragmentModel.js
+++ b/test/unit/streaming.models.FragmentModel.js
@@ -3,7 +3,7 @@ import VoHelper from './helpers/VOHelper';
 import EventBus from '../../src/core/EventBus';
 import Events from '../../src/core/events/Events';
 import FragmentModel from '../../src/streaming/models/FragmentModel';
-import { HTTPRequest } from '../../src/streaming/vo/metrics/HTTPRequest';
+import {HTTPRequest} from '../../src/streaming/vo/metrics/HTTPRequest';
 import Debug from '../../src/core/Debug';
 
 import DashMetricsMock from './mocks/DashMetricsMock';
@@ -21,7 +21,6 @@ describe('FragmentModel', function () {
     const initRequest = voHelper.getInitRequest();
     const mediaRequest = voHelper.getMediaRequest();
     const completeInitRequest = voHelper.getCompleteRequest(HTTPRequest.INIT_SEGMENT_TYPE);
-    const completeMediaRequest = voHelper.getCompleteRequest(HTTPRequest.MEDIA_SEGMENT_TYPE);
     const context = {};
     const debug = Debug(context).getInstance();
     const eventBus = EventBus(context).getInstance();
@@ -31,16 +30,17 @@ describe('FragmentModel', function () {
         dashMetrics: new DashMetricsMock(),
         eventBus: eventBus,
         events: Events,
-        debug: debug});
+        debug: debug
+    });
 
     it('should not have any loading, executed, canceled or failed requests', function () {
         const expectedValue = 0;
 
         expect(fragmentModel.getRequests().length).to.be.equal(expectedValue);
-        expect(fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_LOADING}).length).to.be.equal(expectedValue);
-        expect(fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_EXECUTED}).length).to.be.equal(expectedValue);
-        expect(fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_CANCELED}).length).to.be.equal(expectedValue);
-        expect(fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_FAILED}).length).to.be.equal(expectedValue);
+        expect(fragmentModel.getRequests({ state: FragmentModel.FRAGMENT_MODEL_LOADING }).length).to.be.equal(expectedValue);
+        expect(fragmentModel.getRequests({ state: FragmentModel.FRAGMENT_MODEL_EXECUTED }).length).to.be.equal(expectedValue);
+        expect(fragmentModel.getRequests({ state: FragmentModel.FRAGMENT_MODEL_CANCELED }).length).to.be.equal(expectedValue);
+        expect(fragmentModel.getRequests({ state: FragmentModel.FRAGMENT_MODEL_FAILED }).length).to.be.equal(expectedValue);
     });
 
     it('should return false when isFragmentLoaded is called and request is undefined', () => {
@@ -57,105 +57,68 @@ describe('FragmentModel', function () {
         fragmentModel.reset();
     });
 
-    describe('when a request has been added', function () {
-        it('should fire streamCompleted event for a complete request', function () {
-            const spy = chai.spy();
-
-            eventBus.on(Events.STREAM_COMPLETED, spy);
-
-            fragmentModel.executeRequest(completeMediaRequest);
-            expect(fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_LOADING}).length).to.be.equal(0);
-            expect(fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_EXECUTED}).length).to.be.equal(1);
-            expect(spy).to.have.been.called.exactly(1);
-
-            eventBus.off(Events.STREAM_COMPLETED, spy);
-        });
-
-        describe('when a request has been passed for executing', function () {
-            const loader = { load: () => {}, abort: () => {}, reset: () => {}};
-            const delay = specHelper.getExecutionDelay();
-            let clock;
-
-            beforeEach(function () {
-                fragmentModel = FragmentModel(context).create({
-                    streamInfo: { id: 'streamId' },
-                    type: 'video',
-                    dashMetrics: new DashMetricsMock(),
-                    fragmentLoader: loader,
-                    eventBus: eventBus,
-                    events: Events,
-                    debug: debug
-                });
-                clock = sinon.useFakeTimers();
-
-                setTimeout(function () {
-                    fragmentModel.executeRequest(initRequest);
-                    fragmentModel.executeRequest(mediaRequest);
-                }, delay);
-            });
-
-            afterEach(function () {
-                clock.restore();
-                fragmentModel.reset();
-            });
-
-            it('should fire loadingStarted event a request', function () {
-                const spy = chai.spy();
-
-                eventBus.on(Events.FRAGMENT_LOADING_STARTED, spy);
-
-                clock.tick(delay + 1);
-                eventBus.off(Events.FRAGMENT_LOADING_STARTED, spy);
-
-                expect(spy).to.have.been.called();
-            });
-
-            it('should add the request to loading requests', function () {
-                clock.tick(delay + 1);
-
-                const loadingRequests = fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_LOADING});
-
-                expect(loadingRequests.length).to.be.equal(2);
-            });
-
-            it('should be able to abort loading requests', function () {
-                clock.tick(delay + 1);
-
-                fragmentModel.abortRequests();
-                const loadingRequests = fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_LOADING});
 
-                expect(loadingRequests.length).to.be.equal(0);
+    describe('when a request has been passed for executing', function () {
+        const loader = {
+            load: () => {
+            }, abort: () => {
+            }, reset: () => {
+            }
+        };
+        const delay = specHelper.getExecutionDelay();
+        let clock;
+
+        beforeEach(function () {
+            fragmentModel = FragmentModel(context).create({
+                streamInfo: { id: 'streamId' },
+                type: 'video',
+                dashMetrics: new DashMetricsMock(),
+                fragmentLoader: loader,
+                eventBus: eventBus,
+                events: Events,
+                debug: debug
             });
+            clock = sinon.useFakeTimers();
 
-            it('should return an array of size equals to 1, when removeExecutedRequestsBeforeTime function has been called', function () {
-                fragmentModel.executeRequest(completeMediaRequest);
-                fragmentModel.executeRequest(completeInitRequest);
+            setTimeout(function () {
+                fragmentModel.executeRequest(initRequest);
+                fragmentModel.executeRequest(mediaRequest);
+            }, delay);
+        });
 
-                let executedRequests = fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_EXECUTED});
+        afterEach(function () {
+            clock.restore();
+            fragmentModel.reset();
+        });
 
-                expect(executedRequests.length).to.be.equal(2);
+        it('should fire loadingStarted event a request', function () {
+            const spy = chai.spy();
 
-                fragmentModel.removeExecutedRequestsBeforeTime();
+            eventBus.on(Events.FRAGMENT_LOADING_STARTED, spy);
 
-                executedRequests = fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_EXECUTED});
+            clock.tick(delay + 1);
+            eventBus.off(Events.FRAGMENT_LOADING_STARTED, spy);
 
-                expect(executedRequests.length).to.be.equal(1);
-            });
+            expect(spy).to.have.been.called();
+        });
 
-            it('should return an array of size equals to 1, when syncExecutedRequestsWithBufferedRange function has been called with an empty bufferedRanges', function () {
-                fragmentModel.executeRequest(completeMediaRequest);
-                fragmentModel.executeRequest(completeInitRequest);
+        it('should add the request to loading requests', function () {
+            clock.tick(delay + 1);
 
-                let executedRequests = fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_EXECUTED});
+            const loadingRequests = fragmentModel.getRequests({ state: FragmentModel.FRAGMENT_MODEL_LOADING });
 
-                expect(executedRequests.length).to.be.equal(2);
+            expect(loadingRequests.length).to.be.equal(2);
+        });
 
-                fragmentModel.syncExecutedRequestsWithBufferedRange();
+        it('should be able to abort loading requests', function () {
+            clock.tick(delay + 1);
 
-                executedRequests = fragmentModel.getRequests({state: FragmentModel.FRAGMENT_MODEL_EXECUTED});
+            fragmentModel.abortRequests();
+            const loadingRequests = fragmentModel.getRequests({ state: FragmentModel.FRAGMENT_MODEL_LOADING });
 
-                expect(executedRequests.length).to.be.equal(1);
-            });
+            expect(loadingRequests.length).to.be.equal(0);
         });
+
     });
+
 });
diff --git a/test/unit/streaming.models.MediaPlayerModel.js b/test/unit/streaming.models.MediaPlayerModel.js
index 34e75ddeaf..9fc0149953 100644
--- a/test/unit/streaming.models.MediaPlayerModel.js
+++ b/test/unit/streaming.models.MediaPlayerModel.js
@@ -131,7 +131,7 @@ describe('MediaPlayerModel', function () {
     });
 
     it('should configure StableBufferTime', function () {
-        const s = { streaming: { stableBufferTime: 50 } };
+        const s = { streaming: { buffer: { stableBufferTime: 50 } } };
         settings.update(s);
 
         let StableBufferTime = mediaPlayerModel.getStableBufferTime();
@@ -143,7 +143,13 @@ describe('MediaPlayerModel', function () {
         let liveCatchupLatencyThreshold = mediaPlayerModel.getLiveCatchupLatencyThreshold();
         expect(liveCatchupLatencyThreshold).to.be.NaN; // jshint ignore:line
 
-        settings.update({ streaming: { lowLatencyEnabled: true, liveDelay: 3, liveCatchup: { minDrift: 3 } } });
+        settings.update({
+            streaming: {
+                lowLatencyEnabled: true,
+                delay: { liveDelay: 3 },
+                liveCatchup: { minDrift: 3 }
+            }
+        });
 
         liveCatchupLatencyThreshold = mediaPlayerModel.getLiveCatchupLatencyThreshold();
         expect(liveCatchupLatencyThreshold).to.equal(24);
diff --git a/test/unit/streaming.rules.abr.InsufficientBufferRule.js b/test/unit/streaming.rules.abr.InsufficientBufferRule.js
index 120dcd4b17..eb3b864f82 100644
--- a/test/unit/streaming.rules.abr.InsufficientBufferRule.js
+++ b/test/unit/streaming.rules.abr.InsufficientBufferRule.js
@@ -35,10 +35,21 @@ describe('InsufficientBufferRule', function () {
     it('should return an empty switch request when bufferState is empty', function () {
         const dashMetricsMock = new DashMetricsMock();
         const rulesContextMock = {
-            getMediaInfo: function () {},
-            getMediaType: function () { return 'video'; },
-            getAbrController: function () {},
-            getRepresentationInfo: function () { return { fragmentDuration: 4 };}
+            getMediaInfo: function () {
+            },
+            getMediaType: function () {
+                return 'video';
+            },
+            getAbrController: function () {
+            },
+            getStreamInfo: function () {
+                return {
+                    id: 'DUMMY_STREAM-01'
+                };
+            },
+            getRepresentationInfo: function () {
+                return {fragmentDuration: 4};
+            }
         };
         const rule = InsufficientBufferRule(context).create({
             dashMetrics: dashMetricsMock
@@ -54,10 +65,21 @@ describe('InsufficientBufferRule', function () {
             state: 'bufferStalled'
         };
         const rulesContextMock = {
-            getMediaInfo: function () {},
-            getMediaType: function () { return 'video'; },
-            getAbrController: function () {},
-            getRepresentationInfo: function () { return { fragmentDuration: 4 };}
+            getMediaInfo: function () {
+            },
+            getMediaType: function () {
+                return 'video';
+            },
+            getAbrController: function () {
+            },
+            getStreamInfo: function () {
+                return {
+                    id: 'DUMMY_STREAM-01'
+                };
+            },
+            getRepresentationInfo: function () {
+                return {fragmentDuration: 4};
+            }
         };
         const rule = InsufficientBufferRule(context).create({
             dashMetrics: dashMetricsMock
@@ -73,10 +95,21 @@ describe('InsufficientBufferRule', function () {
             state: 'bufferLoaded'
         };
         const rulesContextMock = {
-            getMediaInfo: function () {},
-            getMediaType: function () { return 'video'; },
-            getAbrController: function () {},
-            getRepresentationInfo: function () { return { fragmentDuration: NaN };}
+            getMediaInfo: function () {
+            },
+            getMediaType: function () {
+                return 'video';
+            },
+            getAbrController: function () {
+            },
+            getStreamInfo: function () {
+                return {
+                    id: 'DUMMY_STREAM-01'
+                };
+            },
+            getRepresentationInfo: function () {
+                return {fragmentDuration: NaN};
+            }
         };
         const rule = InsufficientBufferRule(context).create({
             dashMetrics: dashMetricsMock
@@ -90,13 +123,24 @@ describe('InsufficientBufferRule', function () {
         let bufferState = {
             state: 'bufferLoaded'
         };
-        let representationInfo = { fragmentDuration: NaN };
+        let representationInfo = {fragmentDuration: NaN};
         const dashMetricsMock = new DashMetricsMock();
         const rulesContextMock = {
-            getMediaInfo: function () {},
-            getMediaType: function () { return 'video'; },
-            getAbrController: function () {},
-            getRepresentationInfo: function () { return representationInfo;}
+            getMediaInfo: function () {
+            },
+            getMediaType: function () {
+                return 'video';
+            },
+            getAbrController: function () {
+            },
+            getStreamInfo: function () {
+                return {
+                    id: 'DUMMY_STREAM-01'
+                };
+            },
+            getRepresentationInfo: function () {
+                return representationInfo;
+            }
         };
 
         dashMetricsMock.addBufferState('video', bufferState);
@@ -105,10 +149,10 @@ describe('InsufficientBufferRule', function () {
             dashMetrics: dashMetricsMock
         });
 
-        let e = { mediaType: 'video', startTime: 0 };
+        let e = {mediaType: 'video', startTime: 0};
         eventBus.trigger(Events.BYTES_APPENDED_END_FRAGMENT, e);
 
-        e = { mediaType: 'video', startTime: 4 };//Event objects can't be reused because they get annotated by eventBus.
+        e = {mediaType: 'video', startTime: 4};//Event objects can't be reused because they get annotated by eventBus.
         eventBus.trigger(Events.BYTES_APPENDED_END_FRAGMENT, e);
 
         bufferState.state = 'bufferStalled';
@@ -122,15 +166,26 @@ describe('InsufficientBufferRule', function () {
         const bufferState = {
             state: 'bufferStalled'
         };
-        const representationInfo = { fragmentDuration: 4 };
+        const representationInfo = {fragmentDuration: 4};
         const dashMetricsMock = new DashMetricsMock();
         dashMetricsMock.addBufferState('video', bufferState);
 
         const rulesContextMock = {
-            getMediaInfo: function () {},
-            getMediaType: function () { return 'video'; },
-            getAbrController: function () {},
-            getRepresentationInfo: function () { return representationInfo;}
+            getMediaInfo: function () {
+            },
+            getMediaType: function () {
+                return 'video';
+            },
+            getAbrController: function () {
+            },
+            getRepresentationInfo: function () {
+                return representationInfo;
+            },
+            getStreamInfo: function () {
+                return {
+                    id: 'DUMMY_STREAM-01'
+                };
+            }
         };
 
         const rule = InsufficientBufferRule(context).create({
@@ -140,12 +195,12 @@ describe('InsufficientBufferRule', function () {
         let maxIndexRequest = rule.getMaxIndex(rulesContextMock);
         expect(maxIndexRequest.quality).to.be.equal(-1);
 
-        let e = { mediaType: 'video', startTime: 0 };
+        let e = {mediaType: 'video', startTime: 0};
         eventBus.trigger(Events.BYTES_APPENDED_END_FRAGMENT, e);
         maxIndexRequest = rule.getMaxIndex(rulesContextMock);
         expect(maxIndexRequest.quality).to.be.equal(-1);
 
-        e = { mediaType: 'video', startTime: 4 };
+        e = {mediaType: 'video', startTime: 4};
         eventBus.trigger(Events.BYTES_APPENDED_END_FRAGMENT, e);
         maxIndexRequest = rule.getMaxIndex(rulesContextMock);
         expect(maxIndexRequest.quality).to.be.equal(0);
diff --git a/test/unit/streaming.rules.scheduling.BufferLevelRule.js b/test/unit/streaming.rules.scheduling.BufferLevelRule.js
index 130a40c4bd..1789a8759d 100644
--- a/test/unit/streaming.rules.scheduling.BufferLevelRule.js
+++ b/test/unit/streaming.rules.scheduling.BufferLevelRule.js
@@ -61,7 +61,7 @@ describe('BufferLevelRule', function () {
 
     it('should return 15 (value returns by getCurrentBufferLevel of DashMetricsMock) if streamProcessor is defined and current representation is audio and videoTrackPresent is true', function () {
         const result = bufferLevelRule.getBufferTarget(testAudioType, representationInfo, true);
-        expect(result).to.be.equal(15); // jshint ignore:line
+        expect(result).to.be.equal(16); // jshint ignore:line
     });
 
     it('should return 12 (DEFAULT_MIN_BUFFER_TIME of MediaPlayerModelMock) if streamProcessor is defined and current representation is audio and videoTrackPresent is false', function () {
diff --git a/test/unit/streaming.text.NotFragmentedTextBufferController.js b/test/unit/streaming.text.NotFragmentedTextBufferController.js
index ec3ad55ceb..a4877fc32c 100644
--- a/test/unit/streaming.text.NotFragmentedTextBufferController.js
+++ b/test/unit/streaming.text.NotFragmentedTextBufferController.js
@@ -2,6 +2,7 @@ import NotFragmentedTextBufferController from '../../src/streaming/text/NotFragm
 import ObjectUtils from '../../src/streaming/utils/ObjectUtils';
 import EventBus from '../../src/core/EventBus';
 import Events from '../../src/core/events/Events';
+import Settings from '../../src/core/Settings';
 
 import ErrorHandlerMock from './mocks/ErrorHandlerMock';
 import StreamProcessorMock from './mocks/StreamProcessorMock';
@@ -20,11 +21,12 @@ const objectUtils = ObjectUtils(context).getInstance();
 
 describe('NotFragmentedTextBufferController', function () {
 
+    let settings = Settings(context).getInstance();
     let streamProcessorMock = new StreamProcessorMock(testType, streamInfo);
     let errorHandlerMock = new ErrorHandlerMock();
     let mediaSourceMock;
     let notFragmentedTextBufferController;
-    let mockMediaInfoArr = [{ isText: false, codec: '' }];
+    let mockMediaInfo = { isText: false, codec: '' };
 
     beforeEach(function () {
         mediaSourceMock = new MediaSourceMock();
@@ -32,7 +34,8 @@ describe('NotFragmentedTextBufferController', function () {
             streamInfo: streamInfo,
             type: testType,
             errHandler: errorHandlerMock,
-            streamProcessor: streamProcessorMock
+            streamProcessor: streamProcessorMock,
+            settings
         });
         notFragmentedTextBufferController.initialize(mediaSourceMock);
     });
@@ -51,19 +54,18 @@ describe('NotFragmentedTextBufferController', function () {
 
     describe('when initialized', function () {
         describe('Method createSourceBuffer', function () {
-            it('should create a sourceBuffer and initialize it', function () {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
-                const buffer = notFragmentedTextBufferController.getBuffer();
-                expect(buffer).to.exist; // jshint ignore:line
+            it('should create a sourceBuffer and initialize it', function (done) {
+                notFragmentedTextBufferController.createBufferSink(mockMediaInfo)
+                    .then(() => {
+                        const buffer = notFragmentedTextBufferController.getBuffer();
+                        expect(buffer).to.exist; // jshint ignore:line
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
 
-            it('should notify error handler if an error occurs', function () {
-                mediaSourceMock.forceError = true;
-                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
-                const buffer = notFragmentedTextBufferController.getBuffer();
-                expect(buffer).to.not.exist; // jshint ignore:line
-                expect(errorHandlerMock.errorValue).to.equal('Error creating source buffer of type : ' + testType);
-            });
         });
 
         describe('Method getType', function () {
@@ -74,10 +76,16 @@ describe('NotFragmentedTextBufferController', function () {
         });
 
         describe('Method getBuffer', function () {
-            it('should return created buffer', function () {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
-                let buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
-                expect(objectUtils.areEqual(buffer, mediaSourceMock.buffers[0])).to.be.true; // jshint ignore:line
+            it('should return created buffer', function (done) {
+                notFragmentedTextBufferController.createBufferSink(mockMediaInfo)
+                    .then(() => {
+                        let buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
+                        expect(objectUtils.areEqual(buffer, mediaSourceMock.buffers[0])).to.be.true; // jshint ignore:line
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
         });
 
@@ -97,8 +105,14 @@ describe('NotFragmentedTextBufferController', function () {
         });
 
         describe('Method reset', function () {
-            beforeEach(function () {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
+            beforeEach(function (done) {
+                notFragmentedTextBufferController.createBufferSink(mockMediaInfo)
+                    .then(() => {
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
 
             it('should not abort buffer if there is an error', function () {
@@ -125,77 +139,64 @@ describe('NotFragmentedTextBufferController', function () {
             });
         });
 
-        describe('Event DATA_UPDATE_COMPLETED Handler', function () {
-
-            it('should trigger INIT_FRAGMENT_NEEDED', function (done) {
-
-                let event = {
-                    sender: {
-                        getType: function () { return testType; },
-                        getStreamId: function () { return streamInfo.id; },
-                        getCurrentRepresentation: function () { return { id: 0}; }
-                    },
-                    streamId: streamInfo.id,
-                    mediaType: testType,
-                    currentRepresentation: { id: 0}
-                };
-
-                let onEvent = function () {
-                    eventBus.off(Events.INIT_FRAGMENT_NEEDED, onEvent);
-                    done();
-                };
-                eventBus.on(Events.INIT_FRAGMENT_NEEDED, onEvent, this);
-                eventBus.trigger(Events.DATA_UPDATE_COMPLETED, event);
-            });
-        });
 
         describe('Event INIT_FRAGMENT_LOADED Handler', function () {
 
             it('should not append data to buffer - no bytes', function (done) {
 
-                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
-                const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
-
-                let event = {
-                    chunk: {
-                        streamId: 'id',
-                        mediaInfo: {
-                            type: testType
-                        }
-                    }
-                };
-
-                let onEvent = function () {
-                    eventBus.off(Events.INIT_FRAGMENT_LOADED, onEvent);
-                    expect(buffer.chunk).to.not.exist; // jshint ignore:line
-
-                    done();
-                };
-                eventBus.on(Events.INIT_FRAGMENT_LOADED, onEvent, this);
-                eventBus.trigger(Events.INIT_FRAGMENT_LOADED, event);
+                notFragmentedTextBufferController.createBufferSink(mockMediaInfo)
+                    .then(() => {
+                        const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
+
+                        let event = {
+                            chunk: {
+                                streamId: 'id',
+                                mediaInfo: {
+                                    type: testType
+                                }
+                            }
+                        };
+
+                        let onEvent = function () {
+                            eventBus.off(Events.INIT_FRAGMENT_LOADED, onEvent);
+                            expect(buffer.chunk).to.not.exist; // jshint ignore:line
+                            done();
+                        };
+                        eventBus.on(Events.INIT_FRAGMENT_LOADED, onEvent, this);
+                        eventBus.trigger(Events.INIT_FRAGMENT_LOADED, event);
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
 
             it('should append data to buffer', function (done) {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
-                const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
-                let event = {
-                    chunk: {
-                        streamId: 'id',
-                        mediaInfo: {
-                            type: testType
-                        },
-                        bytes: 'data'
-                    }
-                };
-
-                let onEvent = function () {
-                    eventBus.off(Events.INIT_FRAGMENT_LOADED, onEvent);
-                    expect(buffer.chunk).to.equal(event.chunk.bytes);
-
-                    done();
-                };
-                eventBus.on(Events.INIT_FRAGMENT_LOADED, onEvent, this);
-                eventBus.trigger(Events.INIT_FRAGMENT_LOADED, event);
+                notFragmentedTextBufferController.createBufferSink(mockMediaInfo)
+                    .then(() => {
+                        const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
+                        let event = {
+                            chunk: {
+                                streamId: 'id',
+                                mediaInfo: {
+                                    type: testType
+                                },
+                                bytes: 'data'
+                            }
+                        };
+
+                        let onEvent = function () {
+                            eventBus.off(Events.INIT_FRAGMENT_LOADED, onEvent);
+                            expect(buffer.chunk).to.equal(event.chunk.bytes);
+
+                            done();
+                        };
+                        eventBus.on(Events.INIT_FRAGMENT_LOADED, onEvent, this);
+                        eventBus.trigger(Events.INIT_FRAGMENT_LOADED, event);
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
+
             });
         });
     });
diff --git a/test/unit/streaming.text.TextBufferController.js b/test/unit/streaming.text.TextBufferController.js
deleted file mode 100644
index d1ad3b6e61..0000000000
--- a/test/unit/streaming.text.TextBufferController.js
+++ /dev/null
@@ -1,36 +0,0 @@
-import TextBufferController from '../../src/streaming/text/TextBufferController';
-
-const chai = require('chai');
-const expect = chai.expect;
-
-const context = {};
-
-const streamInfo = {
-    id: 'streamId'
-};
-
-describe('TextBufferController', function () {
-
-    let textBufferController;
-
-    it('should create a buffer of type "BufferController" if type is "fragmentedText"', function () {
-
-
-        textBufferController = TextBufferController(context).create({
-            streamInfo: streamInfo,
-            type: 'fragmentedText'
-        });
-
-        expect(textBufferController.getBufferControllerType()).to.equal('BufferController');
-    });
-
-    it('should create a buffer of type "NotFragmentedTextBufferController" if type is not "fragmentedText"', function () {
-
-        textBufferController = TextBufferController(context).create({
-            streamInfo: streamInfo,
-            type: 'other'
-        });
-
-        expect(textBufferController.getBufferControllerType()).to.equal('NotFragmentedTextBufferController');
-    });
-});
diff --git a/test/unit/streaming.text.TextController.js b/test/unit/streaming.text.TextController.js
index a3b6d53422..f8fb573990 100644
--- a/test/unit/streaming.text.TextController.js
+++ b/test/unit/streaming.text.TextController.js
@@ -1,28 +1,22 @@
 import TextController from '../../src/streaming/text/TextController';
-import TextTracks from '../../src/streaming/text/TextTracks';
-import TextSourceBuffer from '../../src/streaming/text/TextSourceBuffer';
-import ObjectUtils from '../../src/streaming/utils/ObjectUtils';
-import EventBus from '../../src/core/EventBus';
-import Events from '../../src/core/events/Events';
+import VoHelper from './helpers/VOHelper';
 import Constants from '../../src/streaming/constants/Constants';
-
 import VideoModelMock from './mocks/VideoModelMock';
-import StreamControllerMock from './mocks/StreamControllerMock';
 import MediaControllerMock from './mocks/MediaControllerMock';
+import AdapterMock from './mocks/AdapterMock';
 
 
 const expect = require('chai').expect;
 const context = {};
 
-const objectUtils = ObjectUtils(context).getInstance();
-const eventBus = EventBus(context).getInstance();
 
 describe('TextController', function () {
 
     let videoModelMock = new VideoModelMock();
-    let streamControllerMock = new StreamControllerMock();
+    const voHelper = new VoHelper();
+    const streamInfo = voHelper.getDummyStreamInfo();
     let mediaControllerMock = new MediaControllerMock();
-    let textTracks;
+    let dashAdapterMock = new AdapterMock();
     let textController;
 
     beforeEach(function () {
@@ -40,6 +34,9 @@ describe('TextController', function () {
         if (typeof window === 'undefined') {
             global.window = {};
         }
+        if (typeof navigator === 'undefined') {
+            global.navigator = {};
+        }
     });
 
     afterEach(function () {
@@ -47,87 +44,48 @@ describe('TextController', function () {
             delete global.document;
         }
         delete global.window;
+        delete global.navigator;
     });
 
     beforeEach(function () {
-        textTracks = TextTracks(context).getInstance();
-        textTracks.setConfig({
-            videoModel: videoModelMock
-        });
-
-        textController = TextController(context).getInstance();
-        textController.setConfig({
+        textController = TextController(context).create({
             videoModel: videoModelMock,
-            streamController: streamControllerMock,
-            mediaController: mediaControllerMock
-        });
+            mediaController: mediaControllerMock,
+            adapter: dashAdapterMock,
+            streamInfo
+        });
+
+        textController.initializeForStream(streamInfo);
+
+        const mediaInfo = {
+            lang: 'ger',
+            label: 'ger',
+            labels: '',
+            roles: ['main'],
+            id: 'track1',
+            mimeType: 'codecs="stpp',
+            isEmbedded: false
+        };
+        const mediaInfo2 = {
+            lang: 'eng',
+            label: 'eng',
+            labels: '',
+            roles: ['alternate'],
+            id: 'track2',
+            mimeType: 'codecs="stpp',
+            isEmbedded: false
+        };
+
+        textController.addMediaInfosToBuffer(streamInfo, [mediaInfo, mediaInfo2], mediaInfo.mimeType, null);
+        textController.createTracks(streamInfo);
     });
 
     afterEach(function () {
         textController.reset();
-        textTracks.deleteAllTextTracks();
     });
 
-    it('should return TextSourceBuffer instance', function () {
-        let textSourceBuffer = textController.getTextSourceBuffer();
-        let textSourceBufferSingleton = TextSourceBuffer(context).getInstance();
-
-        expect(objectUtils.areEqual(textSourceBuffer, textSourceBufferSingleton)).to.be.true; // jshint ignore:line
-    });
-
-    describe('Method setTextDefaultLanguage', function () {
-        it('should not set text default language if language is not a string', function () {
-            expect(textController.setTextDefaultLanguage.bind(textController, -1)).to.throw(Constants.BAD_ARGUMENT_ERROR);
-            expect(textController.getTextDefaultLanguage()).to.equal(''); // jshint ignore:line
-
-            expect(textController.setTextDefaultLanguage.bind(textController)).to.throw(Constants.BAD_ARGUMENT_ERROR);
-            expect(textController.getTextDefaultLanguage()).to.equal(''); // jshint ignore:line
-        });
-
-        it('should set text default language if language is a string', function () {
-            textController.setTextDefaultLanguage('lang');
-            expect(textController.getTextDefaultLanguage()).to.equal('lang'); // jshint ignore:line
-        });
-
-    });
-
-    describe('Method setTextDefaultEnabled', function () {
-        it('should not set text default enabled if enable is not a boolean', function () {
-            expect(textController.setTextDefaultEnabled.bind(textController, -1)).to.throw(Constants.BAD_ARGUMENT_ERROR);
-            expect(textController.getTextDefaultEnabled()).to.equal(false); // jshint ignore:line
-
-            expect(textController.setTextDefaultEnabled.bind(textController)).to.throw(Constants.BAD_ARGUMENT_ERROR);
-            expect(textController.getTextDefaultEnabled()).to.equal(false); // jshint ignore:line
-        });
-
-        it('should set text default enabled if enable is a boolean', function () {
-            textController.setTextDefaultEnabled(false);
-            expect(textController.getTextDefaultEnabled()).to.equal(false); // jshint ignore:line
-
-            textController.setTextDefaultEnabled(true);
-            expect(textController.getTextDefaultEnabled()).to.equal(true); // jshint ignore:line
-        });
-
-    });
 
     describe('Method enableText', function () {
-        beforeEach(function () {
-            textTracks.addTextTrack({
-                index: 0,
-                kind: 'subtitles',
-                label: 'eng',
-                defaultTrack: true,
-                isTTML: true
-            }, 2);
-
-            textTracks.addTextTrack({
-                index: 1,
-                kind: 'subtitles',
-                label: 'fr',
-                defaultTrack: false,
-                isTTML: true
-            }, 2);
-        });
 
         it('should not enable text if enable is not a boolean', function () {
 
@@ -139,7 +97,7 @@ describe('TextController', function () {
             expect(textController.enableText.bind(textController)).to.throw(Constants.BAD_ARGUMENT_ERROR);
             expect(textController.isTextEnabled()).to.equal(textEnabled); // jshint ignore:line
 
-            expect(textController.enableText.bind(textController,'toto')).to.throw(Constants.BAD_ARGUMENT_ERROR);
+            expect(textController.enableText.bind(textController, 'toto')).to.throw(Constants.BAD_ARGUMENT_ERROR);
             expect(textController.isTextEnabled()).to.equal(textEnabled); // jshint ignore:line
         });
 
@@ -147,43 +105,13 @@ describe('TextController', function () {
 
             let textEnabled = textController.isTextEnabled();
 
-            textController.enableText(textEnabled);
+            textController.enableText(streamInfo.id, textEnabled);
             expect(textController.isTextEnabled()).to.equal(textEnabled); // jshint ignore:line
         });
-
-        it('should enable/disable text', function () {
-
-            let textEnabled = textController.isTextEnabled();
-            expect(textEnabled).to.equal(false); // jshint ignore:line
-
-            textController.enableText(true);
-            expect(textController.isTextEnabled()).to.equal(true); // jshint ignore:line
-
-            textController.enableText(false);
-            expect(textController.isTextEnabled()).to.equal(false); // jshint ignore:line
-        });
     });
 
     describe('Method setTextTrack', function () {
 
-        beforeEach(function () {
-            textTracks.addTextTrack({
-                index: 0,
-                kind: 'subtitles',
-                label: 'eng',
-                defaultTrack: true,
-                isTTML: true
-            }, 2);
-
-            textTracks.addTextTrack({
-                index: 1,
-                kind: 'subtitles',
-                label: 'fr',
-                defaultTrack: false,
-                isTTML: true
-            }, 2);
-        });
-
         it('should set text tracks - no track showing', function () {
             videoModelMock.tracks = [{
                 id: 'track1'
@@ -191,7 +119,7 @@ describe('TextController', function () {
                 id: 'track2'
             }];
 
-            textController.setTextTrack(-1);
+            textController.setTextTrack(streamInfo.id, -1);
             expect(textController.getAllTracksAreDisabled()).to.be.true; // jshint ignore:line
         });
 
@@ -203,122 +131,9 @@ describe('TextController', function () {
                 id: 'track2'
             }];
 
-            textController.setTextTrack(0);
+            textController.setTextTrack(streamInfo.id, 0);
             expect(textController.getAllTracksAreDisabled()).to.be.false; // jshint ignore:line
         });
     });
 
-    describe('Handle event TEXT_TRACKS_QUEUE_INITIALIZED', function () {
-        var textTracksQueue;
-        var initialIndex;
-
-        beforeEach(function () {
-            textTracksQueue = [];
-            initialIndex = 0;
-
-            textTracksQueue.push({
-                index: 0,
-                roles: ['subtitles'],
-                label: 'sub_en',
-                lang: 'eng'
-            });
-
-            textTracksQueue.push({
-                index: 1,
-                roles: ['subtitles'],
-                label: 'sub_fr',
-                lang: 'fr'
-            });
-
-            textTracksQueue.push({
-                index: 2,
-                roles: ['captions'],
-                label: 'sub_fr_hoh',
-                lang: 'fr'
-            });
-        });
-
-        it('should send TEXT_TRACKS_ADDED event', function (done) {
-            // init test
-            textController.setTextDefaultLanguage('');
-
-            const event = {
-                index: initialIndex,
-                tracks: textTracksQueue
-            };
-            const onTracksAdded = function (e) {
-                expect(e.index).to.equal(initialIndex); // jshint ignore:line
-                expect(e.tracks.length).to.equal(textTracksQueue.length); // jshint ignore:line
-
-                eventBus.off(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-                done();
-            };
-            eventBus.on(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-
-            // send event
-            eventBus.trigger(Events.TEXT_TRACKS_QUEUE_INITIALIZED, event);
-        });
-
-        it('should choose language according to default language', function (done) {
-            // init test
-            textController.setTextDefaultLanguage('fr');
-
-            const event = {
-                index: initialIndex,
-                tracks: textTracksQueue
-            };
-            const onTracksAdded = function (e) {
-                expect(e.index).to.equal(1); // jshint ignore:line
-                expect(e.tracks.length).to.equal(textTracksQueue.length); // jshint ignore:line
-                eventBus.off(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-                done();
-            };
-            eventBus.on(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-
-            // send event
-            eventBus.trigger(Events.TEXT_TRACKS_QUEUE_INITIALIZED, event);
-        });
-
-        it('should enable text according to default enable', function (done) {
-            // init test
-            textController.setTextDefaultEnabled(false);
-
-            const event = {
-                index: initialIndex,
-                tracks: textTracksQueue
-            };
-            const onTracksAdded = function (e) {
-                expect(e.index).to.equal(1); // jshint ignore:line
-                expect(e.tracks.length).to.equal(textTracksQueue.length); // jshint ignore:line
-                expect(e.enabled).to.equal(false);
-                eventBus.off(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-                done();
-            };
-            eventBus.on(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-
-            // send event
-            eventBus.trigger(Events.TEXT_TRACKS_QUEUE_INITIALIZED, event);
-        });
-
-        it('should choose track according to default settings', function (done) {
-            // init test
-            textController.setInitialSettings({ lang: 'fr', role: 'captions' });
-
-            const event = {
-                index: initialIndex,
-                tracks: textTracksQueue
-            };
-            const onTracksAdded = function (e) {
-                expect(e.index).to.equal(2); // jshint ignore:line
-                expect(e.tracks.length).to.equal(textTracksQueue.length); // jshint ignore:line
-                eventBus.off(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-                done();
-            };
-            eventBus.on(Events.TEXT_TRACKS_ADDED, onTracksAdded, this);
-
-            // send event
-            eventBus.trigger(Events.TEXT_TRACKS_QUEUE_INITIALIZED, event);
-        });
-    });
-
 });
diff --git a/test/unit/streaming.text.TextSourceBuffer.js b/test/unit/streaming.text.TextSourceBuffer.js
index 026f71473e..4802d75bc0 100644
--- a/test/unit/streaming.text.TextSourceBuffer.js
+++ b/test/unit/streaming.text.TextSourceBuffer.js
@@ -2,7 +2,6 @@ import TextSourceBuffer from '../../src/streaming/text/TextSourceBuffer';
 import TTMLParser from '../../src/streaming/utils/TTMLParser';
 import Errors from '../../src/core/errors/Errors';
 
-import StreamControllerMock from './mocks/StreamControllerMock';
 import ErrorHandlerMock from './mocks/ErrorHandlerMock';
 import AdapterMock from './mocks/AdapterMock';
 
@@ -10,22 +9,27 @@ const chai = require('chai');
 const expect = chai.expect;
 
 const context = {};
-const streamControllerMock = new StreamControllerMock();
 const adapterMock = new AdapterMock();
 const errorHandlerMock = new ErrorHandlerMock();
 const ttmlParser = TTMLParser(context).getInstance();
 
 describe('TextSourceBuffer', function () {
 
-    let textSourceBuffer = TextSourceBuffer(context).getInstance();
-    textSourceBuffer.setConfig({streamController: streamControllerMock,
-                                adapter: adapterMock,
-                                errHandler: errorHandlerMock,
-                                ttmlParser: ttmlParser});
+    let textSourceBuffer = TextSourceBuffer(context).create({
+        adapter: adapterMock,
+        errHandler: errorHandlerMock,
+        ttmlParser: ttmlParser
+    });
 
     it('call to append function with invalid tttml data should triggered a parse error', function () {
         const buffer = new ArrayBuffer(8);
-        textSourceBuffer.append(buffer, {mediaInfo: {type: 'text', mimeType: 'application/ttml+xml', codec: 'application/ttml+xml;codecs=\'undefined\''}});
+        textSourceBuffer.append(buffer, {
+            mediaInfo: {
+                type: 'text',
+                mimeType: 'application/ttml+xml',
+                codec: 'application/ttml+xml;codecs=\'undefined\''
+            }
+        });
         expect(errorHandlerMock.errorCode).to.equal(Errors.TIMED_TEXT_ERROR_ID_PARSE_CODE);
     });
 });
diff --git a/test/unit/streaming.text.TextTracks.js b/test/unit/streaming.text.TextTracks.js
index 3859239af3..c3258ceae3 100644
--- a/test/unit/streaming.text.TextTracks.js
+++ b/test/unit/streaming.text.TextTracks.js
@@ -1,8 +1,7 @@
 import TextTracks from '../../src/streaming/text/TextTracks';
-import Constants from '../../src/streaming/constants/Constants';
 import EventBus from '../../src/core/EventBus';
 import Events from '../../src/core/events/Events';
-
+import VoHelper from './helpers/VOHelper';
 import VideoModelMock from './mocks/VideoModelMock';
 
 const SUBTITLE_DATA = 'subtitle lign 1';
@@ -13,7 +12,9 @@ const eventBus = EventBus(context).getInstance();
 
 describe('TextTracks', function () {
 
+    const voHelper = new VoHelper();
     let videoModelMock = new VideoModelMock();
+    const streamInfo = voHelper.getDummyStreamInfo();
     let textTracks;
 
     beforeEach(function () {
@@ -55,9 +56,9 @@ describe('TextTracks', function () {
     });
 
     beforeEach(function () {
-        textTracks = TextTracks(context).getInstance();
-        textTracks.setConfig({
-            videoModel: videoModelMock
+        textTracks = TextTracks(context).create({
+            videoModel: videoModelMock,
+            streamInfo
         });
         textTracks.initialize();
     });
@@ -75,14 +76,6 @@ describe('TextTracks', function () {
         });
     });
 
-    describe('Method setDisplayCConTop', function () {
-        it('should throw an error if setDisplayCConTop is called with a wrong parameter type', function () {
-            expect(textTracks.setDisplayCConTop.bind(textTracks, 1)).to.throw(Constants.BAD_ARGUMENT_ERROR);
-            expect(textTracks.setDisplayCConTop.bind(textTracks, 'cc')).to.throw(Constants.BAD_ARGUMENT_ERROR);
-            expect(textTracks.setDisplayCConTop.bind(textTracks)).to.throw(Constants.BAD_ARGUMENT_ERROR);
-        });
-    });
-
     describe('Method addTextTrack', function () {
         it('should trigger TEXT_TRACK_ADDED and TEXT_TRACKS_QUEUE_INITIALIZED events when a call to addTextTrackfunction is made', function () {
             const spyTrackAdded = chai.spy();
@@ -98,6 +91,7 @@ describe('TextTracks', function () {
                 defaultTrack: true,
                 isTTML: true}, 1);
 
+            textTracks.createTracks();
             const currrentTrackIdx = textTracks.getCurrentTrackIdx();
             expect(currrentTrackIdx).to.equal(0); // jshint ignore:line
             expect(spyTrackAdded).to.have.been.called();
@@ -117,6 +111,7 @@ describe('TextTracks', function () {
                 defaultTrack: true,
                 isTTML: true}, 1);
 
+            textTracks.createTracks();
             let track = videoModelMock.getTextTrack('subtitles', 'eng');
 
             textTracks.addCaptions(0, 0, [{type: 'noHtml', data: SUBTITLE_DATA, start: 0, end: 2}]);
diff --git a/test/unit/streaming.thumbnail.ThumbnailController.js b/test/unit/streaming.thumbnail.ThumbnailController.js
index 35f5a872ce..7813c68d00 100644
--- a/test/unit/streaming.thumbnail.ThumbnailController.js
+++ b/test/unit/streaming.thumbnail.ThumbnailController.js
@@ -15,6 +15,24 @@ const streamInfo = {
     id: 'id'
 };
 
+const sampleAdaptation = {
+    index: 0,
+    period: {
+        index: 0,
+        mpd: {
+            manifest: {
+                Period_asArray: [{
+                    AdaptationSet_asArray: [{
+                        Representation_asArray: [{
+                            SegmentTemplate: {}
+                        }]
+                    }]
+                }]
+            }
+        }
+    }
+};
+
 const sampleRepresentation = {
     id: 'rep_id',
     segmentInfoType: 'SegmentTemplate',
@@ -22,6 +40,8 @@ const sampleRepresentation = {
     width: 3200,
     height: 180,
     startNumber: 1,
+    adaptation: sampleAdaptation,
+    index: 0,
     segmentDuration: 100,
     timescale: 1,
     media: 'http://media/$RepresentationID$/$Number$.jpg',
@@ -38,6 +58,8 @@ const sampleRepresentation2 = {
     width: 1024,
     height: 1152,
     startNumber: 1,
+    adaptation: sampleAdaptation,
+    index: 0,
     segmentDuration: 634.566,
     timescale: 1,
     media: 'http://media/$RepresentationID$/$Number$.jpg',
@@ -54,6 +76,8 @@ const sampleRepresentation3 = {
     width: 1024,
     height: 1152,
     startNumber: 1,
+    adaptation: sampleAdaptation,
+    index: 0,
     segmentDuration: 634.566,
     timescale: 1,
     media: 'http://media/$RepresentationID$/$Number$.jpg',
@@ -74,6 +98,7 @@ describe('Thumbnails', function () {
                 streamInfo: streamInfo,
                 adapter: adapter,
                 baseURLController: objectsHelper.getDummyBaseURLController(),
+                timelineConverter: objectsHelper.getDummyTimelineConverter(),
                 debug: Debug(context).getInstance(),
                 eventBus: EventBus(context).getInstance(),
                 events: Events,
@@ -105,11 +130,13 @@ describe('Thumbnails', function () {
                 streamInfo: streamInfo,
                 adapter: adapter,
                 baseURLController: objectsHelper.getDummyBaseURLController(),
+                timelineConverter: objectsHelper.getDummyTimelineConverter(),
                 debug: Debug(context).getInstance(),
                 eventBus: EventBus(context).getInstance(),
                 events: Events,
                 dashConstants: DashConstants
             });
+            thumbnailController.initialize();
         });
 
         afterEach(function () {
@@ -181,11 +208,13 @@ describe('Thumbnails', function () {
                 streamInfo: streamInfo,
                 adapter: adapter,
                 baseURLController: objectsHelper.getDummyBaseURLController(),
+                timelineConverter: objectsHelper.getDummyTimelineConverter(),
                 debug: Debug(context).getInstance(),
                 eventBus: EventBus(context).getInstance(),
                 events: Events,
                 dashConstants: DashConstants
             });
+            thumbnailController.initialize();
         });
 
         afterEach(function () {
@@ -233,6 +262,7 @@ describe('Thumbnails', function () {
                 streamInfo: streamInfo,
                 adapter: adapter,
                 baseURLController: objectsHelper.getDummyBaseURLController(),
+                timelineConverter: objectsHelper.getDummyTimelineConverter(),
                 debug: Debug(context).getInstance(),
                 eventBus: EventBus(context).getInstance(),
                 events: Events,
@@ -263,7 +293,6 @@ describe('Thumbnails', function () {
                 events: Events,
                 dashConstants: DashConstants
             });
-            thumbnailTracks.initialize();
             const tracks = thumbnailTracks.getTracks();
             expect(tracks).to.be.empty; // jshint ignore:line
         });
@@ -280,7 +309,7 @@ describe('Thumbnails', function () {
                 timescale: 1,
                 media: 'http://media/$RepresentationID$/$Number$.jpg'
             });
-            thumbnailTracks.initialize();
+            thumbnailTracks.addTracks();
             const tracks = thumbnailTracks.getTracks();
 
             expect(tracks).to.have.lengthOf(1);
@@ -295,7 +324,7 @@ describe('Thumbnails', function () {
 
         it('should parse representations and its essential properties', function () {
             adapter.setRepresentation(sampleRepresentation);
-            thumbnailTracks.initialize();
+            thumbnailTracks.addTracks();
             const tracks = thumbnailTracks.getTracks();
 
             expect(tracks).to.have.lengthOf(1);
@@ -310,7 +339,7 @@ describe('Thumbnails', function () {
 
         it('should empty tracks after a reset', function () {
             adapter.setRepresentation(sampleRepresentation);
-            thumbnailTracks.initialize();
+            thumbnailTracks.addTracks();
             expect(thumbnailTracks.getTracks()).to.have.lengthOf(1);
             thumbnailTracks.reset();
             expect(thumbnailTracks.getTracks()).to.have.lengthOf(0);
@@ -318,7 +347,7 @@ describe('Thumbnails', function () {
 
         it('tracks selection', function () {
             adapter.setRepresentation(sampleRepresentation);
-            thumbnailTracks.initialize();
+            thumbnailTracks.addTracks();
             thumbnailTracks.setTrackByIndex(0);
             expect(thumbnailTracks.getCurrentTrackIndex()).to.equal(0);
             expect(thumbnailTracks.getCurrentTrack()).to.be.not.null; // jshint ignore:line
@@ -353,7 +382,7 @@ describe('Thumbnails', function () {
         it('should support CR URI schema', function () {
             adapter.setRepresentation(sampleRepresentation3);
 
-            thumbnailTracks.initialize();
+            thumbnailTracks.addTracks();
             const tracks = thumbnailTracks.getTracks();
 
             expect(tracks[0].tilesHor).to.equal(50);
diff --git a/test/unit/streaming.utils.CapabilitiesFilter.js b/test/unit/streaming.utils.CapabilitiesFilter.js
index 5d0803a43d..f96f045729 100644
--- a/test/unit/streaming.utils.CapabilitiesFilter.js
+++ b/test/unit/streaming.utils.CapabilitiesFilter.js
@@ -11,12 +11,15 @@ let settings;
 let capabilitiesMock;
 
 describe('CapabilitiesFilter', function () {
-
-
     beforeEach(function () {
         adapterMock = new AdapterMock();
+        adapterMock.getIsTypeOf = function (as, type) {
+            return type === 'audio' && as.mimeType === 'audio/mp4';
+        };
+
         settings = Settings({}).getInstance();
         capabilitiesMock = new CapabilitiesMock();
+
         capabilitiesFilter = CapabilitiesFilter({}).getInstance();
         capabilitiesFilter.setConfig({
             adapter: adapterMock,
@@ -25,7 +28,7 @@ describe('CapabilitiesFilter', function () {
         });
     });
 
-    describe('filterUnsupportedFeaturesOfPeriod', function () {
+    describe('filterUnsupportedFeatures', function () {
 
         describe('filter codecs', function () {
 
@@ -33,96 +36,111 @@ describe('CapabilitiesFilter', function () {
                 settings.update({ streaming: { filterUnsupportedEssentialProperties: false } });
             });
 
-            it('should not filter AdaptationSets and Representations', function () {
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000'
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000'
-                            }
-                        ]
+            it('should not filter AdaptationSets and Representations', function (done) {
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000'
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000'
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
 
-                prepareAdapterMock(periodAsArray);
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
-
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(1);
-                expect(periodAsArray.AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(1);
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
 
             });
 
-            it('should filter AdaptationSets', function () {
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000'
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000'
-                            }
-                        ]
+            it('should filter AdaptationSets', function (done) {
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000'
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000'
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
 
-                prepareAdapterMock(periodAsArray);
                 prepareCapabilitiesMock({
                     name: 'supportsCodec', definition: function () {
                         return false;
                     }
                 });
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
-
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(0);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(0);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
 
-            it('should filter Representations', function () {
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.1',
-                                audioSamplingRate: '48000'
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000'
-                            }
-                        ]
+            it('should filter Representations', function (done) {
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.1',
+                                    audioSamplingRate: '48000'
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000'
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
 
-                prepareAdapterMock(periodAsArray);
                 prepareCapabilitiesMock({
-                    name: 'supportsCodec', definition: function (codec) {
-                        return codec === 'audio/mp4;codecs="mp4a.40.2"';
+                    name: 'supportsCodec', definition: function (config) {
+                        return config.codec === 'audio/mp4;codecs="mp4a.40.2"';
                     }
                 });
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
-
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(1);
-                expect(periodAsArray.AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(1);
 
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(1);
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(1);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
         });
 
@@ -132,167 +150,193 @@ describe('CapabilitiesFilter', function () {
                 settings.update({ streaming: { filterUnsupportedEssentialProperties: true } });
             });
 
-            it('should not filter AdaptationSets and Representations if filterUnsupportedEssentialProperties is disabled', function () {
+            it('should not filter AdaptationSets and Representations if filterUnsupportedEssentialProperties is disabled', function (done) {
                 settings.update({ streaming: { filterUnsupportedEssentialProperties: false } });
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            }
-                        ]
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
 
-                prepareAdapterMock(periodAsArray);
                 prepareCapabilitiesMock({
                     name: 'supportsEssentialProperty', definition: function () {
                         return true;
                     }
                 });
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
 
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(1);
-                expect(periodAsArray.AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(1);
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
+
             });
 
-            it('should not filter AdaptationSets and Representations if EssentialProperties value is supported', function () {
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            }
-                        ]
+            it('should not filter AdaptationSets and Representations if EssentialProperties value is supported', function (done) {
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
-
-                prepareAdapterMock(periodAsArray);
                 prepareCapabilitiesMock({
                     name: 'supportsEssentialProperty', definition: function () {
                         return true;
                     }
                 });
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
 
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(1);
-                expect(periodAsArray.AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(1);
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
+
             });
 
-            it('should filter AdaptationSets if EssentialProperty value is not supported', function () {
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            }
-                        ]
+            it('should filter AdaptationSets if EssentialProperty value is not supported', function (done) {
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
 
-                prepareAdapterMock(periodAsArray);
                 prepareCapabilitiesMock({
                     name: 'supportsEssentialProperty', definition: function () {
                         return false;
                     }
                 });
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(0);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
+
 
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(0);
             });
 
-            it('should filter a single Representation if EssentialProperty value is not supported', function () {
-                const periodAsArray = {
-                    AdaptationSet_asArray: [{
-                        mimeType: 'audio/mp4',
-                        Representation_asArray: [
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000',
-                                EssentialProperty_asArray: [{
-                                    schemeIdUri: 'http://dashif.org/thumbnail_tile',
-                                    value: 'somevalue'
-                                }]
-                            },
-                            {
-                                mimeType: 'audio/mp4',
-                                codecs: 'mp4a.40.2',
-                                audioSamplingRate: '48000'
-                            }
-                        ]
+            it('should filter a single Representation if EssentialProperty value is not supported', function (done) {
+                const manifest = {
+                    Period_asArray: [{
+                        AdaptationSet_asArray: [{
+                            mimeType: 'audio/mp4',
+                            Representation_asArray: [
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000',
+                                    EssentialProperty_asArray: [{
+                                        schemeIdUri: 'http://dashif.org/thumbnail_tile',
+                                        value: 'somevalue'
+                                    }]
+                                },
+                                {
+                                    mimeType: 'audio/mp4',
+                                    codecs: 'mp4a.40.2',
+                                    audioSamplingRate: '48000'
+                                }
+                            ]
+                        }]
                     }]
                 };
-                const streamInfo = { index: 0 };
 
-                prepareAdapterMock(periodAsArray);
                 prepareCapabilitiesMock({
                     name: 'supportsEssentialProperty', definition: function () {
                         return false;
                     }
                 });
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
-
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(1);
-                expect(periodAsArray.AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(1);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(1);
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(1);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
             });
         });
 
         describe('custom filters', function () {
 
-            it('should use provided custom filters', function () {
-                const periodAsArray = {
+            it('should use provided custom filters', function (done) {
+                const manifest = {
+                    Period_asArray: [{
                     AdaptationSet_asArray: [{
                         mimeType: 'video/mp4',
                         Representation_asArray: [
@@ -310,17 +354,23 @@ describe('CapabilitiesFilter', function () {
                             }
                         ]
                     }]
-                };
-                const streamInfo = { index: 0 };
+                }]};
 
-                prepareAdapterMock(periodAsArray);
                 capabilitiesFilter.setCustomCapabilitiesFilters([function (representation) {
                     return representation.height <= 720;
                 }]);
-                capabilitiesFilter.filterUnsupportedFeaturesOfPeriod(streamInfo);
 
-                expect(periodAsArray.AdaptationSet_asArray).to.have.lengthOf(1);
-                expect(periodAsArray.AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                capabilitiesFilter.filterUnsupportedFeatures(manifest)
+                    .then(() => {
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray).to.have.lengthOf(1);
+                        expect(manifest.Period_asArray[0].AdaptationSet_asArray[0].Representation_asArray).to.have.lengthOf(2);
+                        done();
+                    })
+                    .catch((e) => {
+                        done(e);
+                    });
+
+
             });
         });
 
@@ -328,12 +378,6 @@ describe('CapabilitiesFilter', function () {
     });
 });
 
-function prepareAdapterMock(periodAsArray) {
-    adapterMock.getRealPeriodByIndex = function () {
-        return periodAsArray;
-    };
-}
-
 function prepareCapabilitiesMock(data) {
     capabilitiesMock[data.name] = data.definition;
 }
diff --git a/test/unit/streaming.utils.LiveEdgeFinder.js b/test/unit/streaming.utils.LiveEdgeFinder.js
deleted file mode 100644
index c5dffea96d..0000000000
--- a/test/unit/streaming.utils.LiveEdgeFinder.js
+++ /dev/null
@@ -1,19 +0,0 @@
-import LiveEdgeFinder from '../../src/streaming/utils/LiveEdgeFinder';
-import Constants from '../../src/streaming/constants/Constants';
-
-const expect = require('chai').expect;
-
-const context = {};
-let liveEdgeFinder;
-
-describe('LiveEdgeFinder', function () {
-    it('should throw an error when getLiveEdge is called and config object has not been set properly', function () {
-        liveEdgeFinder = LiveEdgeFinder(context).create();
-        expect(liveEdgeFinder.getLiveEdge.bind()).to.be.throw(Constants.MISSING_CONFIG_ERROR);
-    });
-
-    it('should throw an error when getLiveEdge is called and config object has not been set properly', function () {
-        liveEdgeFinder = LiveEdgeFinder(context).create({});
-        expect(liveEdgeFinder.getLiveEdge.bind()).to.be.throw(Constants.MISSING_CONFIG_ERROR);
-    });
-});
\ No newline at end of file