From f7d4d7cec2a707b39f10d8798c8d0f6c0c400a14 Mon Sep 17 00:00:00 2001
From: Bertrand Berthelot <bertrand.berthelot@orange.com>
Date: Wed, 3 Jun 2020 14:52:10 +0200
Subject: [PATCH] [Code refactoring] remove circular dependencies (#3256)

* Code refactoring: remove circular dependencies from/to StreamController and StreamProcessor

* Code refactoring: update unit tests

* Code refactoring: fix BufferController events listeners

* Code refactoring:
- rename BufferController.switchInitData() by appendInitSegment()
- add method BufferController.replaceBuffer() for replacing buffer when switching track (replace resetBufferInProgress mechanism)

* Code refactoring: fix scheduler start after track switch

* Code refactoring: fix unit tests

* remove some logs

* use mimeType (and not type) when whecking if text track

* code refactoring: fix TIMED_TEXT_REQUESTED event listener

* code refactoring: fix current representation info update for scheduleController (to update fragmentDuration for example in case of SegmentTimeline)

* code comment

* Fix unit tests

* ScheduleController: fix hasVideoTrack initiailization

* add buffer level metrics in StreamProcessor
---
 src/core/events/CoreEvents.js                 |   4 +-
 src/dash/DashMetrics.js                       |   2 +-
 .../controllers/RepresentationController.js   |   6 +-
 src/mss/MssHandler.js                         |  11 +-
 src/streaming/Stream.js                       |  35 +-
 src/streaming/StreamProcessor.js              | 384 +++++++++++++++---
 src/streaming/controllers/BufferController.js | 211 ++++------
 .../controllers/PlaybackController.js         |   9 +-
 .../controllers/ScheduleController.js         | 364 ++++-------------
 src/streaming/controllers/StreamController.js |  56 +--
 .../rules/scheduling/BufferLevelRule.js       |  17 +-
 .../text/NotFragmentedTextBufferController.js |  44 +-
 src/streaming/text/TextBufferController.js    |  32 +-
 src/streaming/text/TextSourceBuffer.js        |  37 +-
 test/unit/Streaming.StreamProcessor.js        |  62 ++-
 test/unit/mocks/AdapterMock.js                |   2 +-
 test/unit/mocks/StreamProcessorMock.js        |   2 +-
 test/unit/streaming.Stream.js                 |  72 ++--
 .../streaming.controllers.BufferController.js |  74 ++--
 ...treaming.controllers.ScheduleController.js | 106 -----
 .../streaming.controllers.StreamController.js |  24 +-
 ...eaming.rules.scheduling.BufferLevelRule.js |  37 +-
 ....text.NotFragmentedTextBufferController.js |  62 ++-
 test/unit/streaming.text.TextSourceBuffer.js  |  10 +-
 24 files changed, 769 insertions(+), 894 deletions(-)
 delete mode 100644 test/unit/streaming.controllers.ScheduleController.js

diff --git a/src/core/events/CoreEvents.js b/src/core/events/CoreEvents.js
index 23771fe21e..079c8f0807 100644
--- a/src/core/events/CoreEvents.js
+++ b/src/core/events/CoreEvents.js
@@ -52,7 +52,7 @@ class CoreEvents extends EventsBase {
         this.INBAND_EVENTS = 'inbandEvents';
         this.INITIALIZATION_LOADED = 'initializationLoaded';
         this.INIT_FRAGMENT_LOADED = 'initFragmentLoaded';
-        this.INIT_REQUESTED = 'initRequested';
+        this.INIT_FRAGMENT_NEEDED = 'initFragmentNeeded';
         this.INTERNAL_MANIFEST_LOADED = 'internalManifestLoaded';
         this.ORIGINAL_MANIFEST_LOADED = 'originalManifestLoaded';
         this.LIVE_EDGE_SEARCH_COMPLETED = 'liveEdgeSearchCompleted';
@@ -62,6 +62,7 @@ class CoreEvents extends EventsBase {
         this.LOADING_ABANDONED = 'loadingAborted';
         this.MANIFEST_UPDATED = 'manifestUpdated';
         this.MEDIA_FRAGMENT_LOADED = 'mediaFragmentLoaded';
+        this.MEDIA_FRAGMENT_NEEDED = 'mediaFragmentNeeded';
         this.QUOTA_EXCEEDED = 'quotaExceeded';
         this.REPRESENTATION_UPDATE_STARTED = 'representationUpdateStarted';
         this.REPRESENTATION_UPDATE_COMPLETED = 'representationUpdateCompleted';
@@ -82,6 +83,7 @@ class CoreEvents extends EventsBase {
         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/DashMetrics.js b/src/dash/DashMetrics.js
index 4836a23ec5..c35c21019e 100644
--- a/src/dash/DashMetrics.js
+++ b/src/dash/DashMetrics.js
@@ -466,7 +466,7 @@ function DashMetrics(config) {
             playListTraceMetrics.representationid = representationId;
             playListTraceMetrics.start = new Date();
             playListTraceMetrics.mstart = mediaStartTime;
-            playListTraceMetrics.playbackspeed = speed;
+            playListTraceMetrics.playbackspeed = speed !== null ? speed.toString() : null;
         }
     }
 
diff --git a/src/dash/controllers/RepresentationController.js b/src/dash/controllers/RepresentationController.js
index 0c1e9b92f6..581aceb7a4 100644
--- a/src/dash/controllers/RepresentationController.js
+++ b/src/dash/controllers/RepresentationController.js
@@ -62,8 +62,7 @@ function RepresentationController(config) {
     }
 
     function checkConfig() {
-        if (!abrController || !dashMetrics || !playbackController ||
-            !timelineConverter) {
+        if (!abrController || !dashMetrics || !playbackController || !timelineConverter) {
             throw new Error(Constants.MISSING_CONFIG_ERROR);
         }
     }
@@ -237,8 +236,7 @@ function RepresentationController(config) {
             err,
             repSwitch;
 
-        if (r.adaptation.period.mpd.manifest.type === dashConstants.DYNAMIC && !r.adaptation.period.mpd.manifest.ignorePostponeTimePeriod)
-        {
+        if (r.adaptation.period.mpd.manifest.type === dashConstants.DYNAMIC && !r.adaptation.period.mpd.manifest.ignorePostponeTimePeriod) {
             let segmentAvailabilityTimePeriod = r.segmentAvailabilityRange.end - r.segmentAvailabilityRange.start;
             // We must put things to sleep unless till e.g. the startTime calculation in ScheduleController.onLiveEdgeSearchCompleted fall after the segmentAvailabilityRange.start
             let liveDelay = playbackController.computeLiveDelay(currentVoRepresentation.segmentDuration, streamInfo.manifestInfo.DVRWindowSize);
diff --git a/src/mss/MssHandler.js b/src/mss/MssHandler.js
index 6745d5b95f..ee3f1089c0 100644
--- a/src/mss/MssHandler.js
+++ b/src/mss/MssHandler.js
@@ -36,6 +36,7 @@ import MssFragmentProcessor from './MssFragmentProcessor';
 import MssParser from './parser/MssParser';
 import MssErrors from './errors/MssErrors';
 import DashJSError from '../streaming/vo/DashJSError';
+import InitCache from '../streaming/utils/InitCache';
 
 function MssHandler(config) {
 
@@ -62,10 +63,12 @@ function MssHandler(config) {
     });
     let mssParser,
         fragmentInfoControllers,
+        initCache,
         instance;
 
     function setup() {
         fragmentInfoControllers = [];
+        initCache = InitCache(context).getInstance();
     }
 
     function getStreamProcessor(type) {
@@ -128,8 +131,8 @@ function MssHandler(config) {
         fragmentInfoControllers = [];
     }
 
-    function onInitializationRequested(e) {
-        let streamProcessor = getStreamProcessor(e.mediaType);
+    function onInitFragmentNeeded(e) {
+        let streamProcessor = getStreamProcessor(e.sender.getType());
         if (!streamProcessor) return;
 
         // Create init segment request
@@ -208,7 +211,7 @@ function MssHandler(config) {
     }
 
     function registerEvents() {
-        eventBus.on(events.INIT_REQUESTED, onInitializationRequested, instance, dashjs.FactoryMaker.getSingletonFactoryByName(eventBus.getClassName()).EVENT_PRIORITY_HIGH); /* jshint ignore:line */
+        eventBus.on(events.INIT_FRAGMENT_NEEDED, onInitFragmentNeeded, instance, dashjs.FactoryMaker.getSingletonFactoryByName(eventBus.getClassName()).EVENT_PRIORITY_HIGH); /* jshint ignore:line */
         eventBus.on(events.PLAYBACK_PAUSED, onPlaybackPaused, instance, dashjs.FactoryMaker.getSingletonFactoryByName(eventBus.getClassName()).EVENT_PRIORITY_HIGH); /* jshint ignore:line */
         eventBus.on(events.PLAYBACK_SEEK_ASKED, onPlaybackSeekAsked, instance, dashjs.FactoryMaker.getSingletonFactoryByName(eventBus.getClassName()).EVENT_PRIORITY_HIGH); /* jshint ignore:line */
         eventBus.on(events.FRAGMENT_LOADING_COMPLETED, onSegmentMediaLoaded, instance, dashjs.FactoryMaker.getSingletonFactoryByName(eventBus.getClassName()).EVENT_PRIORITY_HIGH); /* jshint ignore:line */
@@ -216,7 +219,7 @@ function MssHandler(config) {
     }
 
     function reset() {
-        eventBus.off(events.INIT_REQUESTED, onInitializationRequested, this);
+        eventBus.off(events.INIT_FRAGMENT_NEEDED, onInitFragmentNeeded, this);
         eventBus.off(events.PLAYBACK_PAUSED, onPlaybackPaused, this);
         eventBus.off(events.PLAYBACK_SEEK_ASKED, onPlaybackSeekAsked, this);
         eventBus.off(events.FRAGMENT_LOADING_COMPLETED, onSegmentMediaLoaded, this);
diff --git a/src/streaming/Stream.js b/src/streaming/Stream.js
index b542636e93..3769421309 100644
--- a/src/streaming/Stream.js
+++ b/src/streaming/Stream.js
@@ -71,6 +71,8 @@ function Stream(config) {
         isStreamActivated,
         isMediaInitialized,
         streamInfo,
+        hasVideoTrack,
+        hasAudioTrack,
         updateError,
         isUpdating,
         protectionController,
@@ -225,6 +227,8 @@ function Stream(config) {
     function resetInitialSettings() {
         deactivate();
         streamInfo = null;
+        hasVideoTrack = false;
+        hasAudioTrack = false;
         updateError = {};
         isUpdating = false;
     }
@@ -265,6 +269,14 @@ function Stream(config) {
         return streamInfo;
     }
 
+    function getHasAudioTrack () {
+        return hasAudioTrack;
+    }
+
+    function getHasVideoTrack () {
+        return hasVideoTrack;
+    }
+
     function getThumbnailController() {
         return thumbnailController;
     }
@@ -343,7 +355,7 @@ function Stream(config) {
         logger.info('Stream -  Process track changed at current time ' + currentTime);
 
         logger.debug('Stream -  Update stream controller');
-        if (manifest.refreshManifestOnSwitchTrack) {
+        if (manifest.refreshManifestOnSwitchTrack) { // Applies only for MSS streams
             logger.debug('Stream -  Refreshing manifest for switch track');
             trackChangedEvent = e;
             manifestUpdater.refreshManifest();
@@ -379,14 +391,13 @@ function Stream(config) {
             abrController: abrController,
             playbackController: playbackController,
             mediaController: mediaController,
-            streamController: config.streamController,
             textController: textController,
             errHandler: errHandler,
             settings: settings,
             boxParser: boxParser
         });
 
-        streamProcessor.initialize(mediaSource);
+        streamProcessor.initialize(mediaSource, hasVideoTrack);
         abrController.updateTopQualityIndex(mediaInfo);
 
         if (optionalSettings) {
@@ -426,6 +437,14 @@ function Stream(config) {
             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];
 
@@ -592,9 +611,7 @@ function Stream(config) {
         if (error) {
             errHandler.error(error);
         } else {
-            eventBus.trigger(Events.STREAM_INITIALIZED, {
-                streamInfo: streamInfo
-            });
+            eventBus.trigger(Events.STREAM_INITIALIZED, { streamInfo: streamInfo });
         }
     }
 
@@ -624,9 +641,7 @@ function Stream(config) {
     }
 
     function onBufferingCompleted(e) {
-        if (e.streamInfo !== streamInfo) {
-            return;
-        }
+        if (e.streamId !== streamInfo.id) return;
 
         let processors = getProcessors();
         const ln = processors.length;
@@ -856,6 +871,8 @@ function Stream(config) {
         getStartTime: getStartTime,
         getId: getId,
         getStreamInfo: getStreamInfo,
+        getHasAudioTrack: getHasAudioTrack,
+        getHasVideoTrack: getHasVideoTrack,
         preload: preload,
         getThumbnailController: getThumbnailController,
         getBitrateListFor: getBitrateListFor,
diff --git a/src/streaming/StreamProcessor.js b/src/streaming/StreamProcessor.js
index f255241d8f..e5c3d504c5 100644
--- a/src/streaming/StreamProcessor.js
+++ b/src/streaming/StreamProcessor.js
@@ -30,10 +30,13 @@
  */
 import Constants from './constants/Constants';
 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 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';
@@ -44,6 +47,9 @@ import DashJSError from './vo/DashJSError';
 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';
 
 function StreamProcessor(config) {
 
@@ -62,7 +68,6 @@ function StreamProcessor(config) {
     let fragmentModel = config.fragmentModel;
     let abrController = config.abrController;
     let playbackController = config.playbackController;
-    let streamController = config.streamController;
     let mediaController = config.mediaController;
     let textController = config.textController;
     let dashMetrics = config.dashMetrics;
@@ -70,21 +75,32 @@ function StreamProcessor(config) {
     let boxParser = config.boxParser;
 
     let instance,
+        isDynamic,
         mediaInfo,
         mediaInfoArr,
         bufferController,
         scheduleController,
         representationController,
-        indexHandler;
+        liveEdgeFinder,
+        indexHandler,
+        streamInitialized;
 
     function setup() {
         resetInitialSettings();
 
-        eventBus.on(Events.BUFFER_LEVEL_UPDATED, onBufferLevelUpdated, instance);
+        eventBus.on(Events.STREAM_INITIALIZED, onStreamInitialized, instance);
         eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, instance);
+        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.SEEK_TARGET, onSeekTarget, instance);
     }
 
-    function initialize(mediaSource) {
+    function initialize(mediaSource, hasVideoTrack) {
         indexHandler = DashHandler(context).create({
             streamInfo: streamInfo,
             type: type,
@@ -105,44 +121,59 @@ function StreamProcessor(config) {
             urlUtils: URLUtils(context).getInstance()
         });
 
-        // initialize controllers
-        indexHandler.initialize(playbackController.getIsDynamic());
+        // 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);
         abrController.registerStreamType(type, instance);
 
+        representationController = RepresentationController(context).create({
+            streamId: streamInfo.id,
+            type: type,
+            abrController: abrController,
+            dashMetrics: dashMetrics,
+            playbackController: playbackController,
+            timelineConverter: timelineConverter,
+            dashConstants: DashConstants,
+            events: Events,
+            eventBus: eventBus,
+            errors: Errors
+        });
+
         bufferController = createBufferControllerForType(type);
+        if (bufferController) {
+            bufferController.initialize(mediaSource);
+        }
+
         scheduleController = ScheduleController(context).create({
             streamId: streamInfo.id,
             type: type,
             mimeType: mimeType,
             adapter: adapter,
             dashMetrics: dashMetrics,
-            timelineConverter: timelineConverter,
             mediaPlayerModel: mediaPlayerModel,
             fragmentModel: fragmentModel,
             abrController: abrController,
             playbackController: playbackController,
-            streamController: streamController,
             textController: textController,
-            streamProcessor: instance,
             mediaController: mediaController,
+            bufferController: bufferController,
             settings: settings
         });
-        representationController = RepresentationController(context).create({
-            streamId: streamInfo.id,
-            type: type,
-            abrController: abrController,
-            dashMetrics: dashMetrics,
-            playbackController: playbackController,
-            timelineConverter: timelineConverter,
-            dashConstants: DashConstants,
-            events: Events,
-            eventBus: eventBus,
-            errors: Errors
-        });
-        if (bufferController) {
-            bufferController.initialize(mediaSource);
+
+        if (adapter && adapter.getIsTextTrack(mimeType)) {
+            eventBus.on(Events.TIMED_TEXT_REQUESTED, onTimedTextRequested, this);
         }
-        scheduleController.initialize();
+
+        scheduleController.initialize(hasVideoTrack);
+
+        streamInitialized = false;
     }
 
     function resetInitialSettings() {
@@ -151,7 +182,9 @@ function StreamProcessor(config) {
     }
 
     function reset(errored, keepBuffers) {
-        indexHandler.reset();
+        if (indexHandler) {
+            indexHandler.reset();
+        }
 
         if (bufferController) {
             bufferController.reset(errored, keepBuffers);
@@ -168,12 +201,29 @@ function StreamProcessor(config) {
             representationController = null;
         }
 
+        if (liveEdgeFinder) {
+            liveEdgeFinder.reset();
+            liveEdgeFinder = null;
+        }
+
         if (abrController) {
             abrController.unRegisterStreamType(type);
         }
 
-        eventBus.off(Events.BUFFER_LEVEL_UPDATED, onBufferLevelUpdated, instance);
+        eventBus.off(Events.STREAM_INITIALIZED, onStreamInitialized, instance);
         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);
+
+        if (adapter && adapter.getIsTextTrack(mimeType)) {
+            eventBus.off(Events.TIMED_TEXT_REQUESTED, onTimedTextRequested, this);
+        }
 
         resetInitialSettings();
         type = null;
@@ -184,20 +234,76 @@ function StreamProcessor(config) {
         return representationController ? representationController.isUpdating() : false;
     }
 
+    function onStreamInitialized(e) {
+        if (!e.streamInfo || streamInfo.id !== e.streamInfo.id) return;
+
+        if (!streamInitialized) {
+            streamInitialized = true;
+            if (isDynamic) {
+                timelineConverter.setTimeSyncCompleted(true);
+                setLiveEdgeSeekTarget();
+            } else {
+                const seekTarget = playbackController.getStreamStartTime(false);
+                bufferController.setSeekStartTime(seekTarget);
+                scheduleController.setCurrentRepresentation(getRepresentationInfo());
+                scheduleController.setSeekTarget(seekTarget);
+            }
+        }
+
+        scheduleController.start();
+    }
+
     function onDataUpdateCompleted(e) {
-        if (e.sender.getType() !== getType() || e.sender.getStreamId() !== streamInfo.id || !e.error || e.error.code !== Errors.SEGMENTS_UPDATE_FAILED_ERROR_CODE) return;
+        if (e.sender.getType() !== getType() || e.sender.getStreamId() !== streamInfo.id) return;
 
-        addDVRMetric();
+        if (!e.error) {
+            scheduleController.setCurrentRepresentation(adapter.convertDataToRepresentationInfo(e.currentRepresentation));
+        } else if (e.error.code !== Errors.SEGMENTS_UPDATE_FAILED_ERROR_CODE) {
+            addDVRMetric();
+        }
+    }
+
+    function onQualityChanged(e) {
+        if (type !== e.mediaType || streamInfo.id !== e.streamInfo.id) return;
+        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());
     }
 
     function onBufferLevelUpdated(e) {
-        if (e.sender.getStreamProcessor() !== instance) return;
-        let manifest = manifestModel.getValue();
-        if (!manifest.doNotUpdateDVRWindowOnBufferUpdated) {
+        if (e.streamId !== streamInfo.id || e.mediaType !== type) return;
+
+        dashMetrics.addBufferLevel(type, new Date(), e.bufferLevel * 1000);
+
+        if (!manifestModel.getValue().doNotUpdateDVRWindowOnBufferUpdated) {
             addDVRMetric();
         }
     }
 
+    function onBufferLevelStateChanged(e) {
+        if (e.streamId !== streamInfo.id || e.mediaType !== type) return;
+
+        dashMetrics.addBufferState(type, e.state, scheduleController.getBufferTarget());
+        if (e.state === MetricsConstants.BUFFER_EMPTY && !playbackController.isSeeking()) {
+            // logger.info('Buffer is empty! Stalling!');
+            dashMetrics.pushPlayListTraceMetrics(new Date(), PlayListTrace.REBUFFERING_REASON);
+        }
+    }
+
+    function onBufferCleared(e) {
+        if (e.streamId !== streamInfo.id || e.mediaType !== type) return;
+
+        if (e.unintended) {
+            // There was an unintended buffer remove, probably creating a gap in the buffer, remove every saved request
+            fragmentModel.removeExecutedRequestsAfterTime(e.from);
+        } else {
+            fragmentModel.syncExecutedRequestsWithBufferedRange(
+                bufferController.getBuffer().getAllBufferRanges(),
+                streamInfo.duration);
+        }
+    }
+
     function addDVRMetric() {
         const manifestInfo = streamInfo.manifestInfo;
         const isDynamic = manifestInfo.isDynamic;
@@ -296,7 +402,7 @@ function StreamProcessor(config) {
     }
 
     function setMediaSource(mediaSource) {
-        bufferController.setMediaSource(mediaSource, getMediaInfo());
+        bufferController.setMediaSource(mediaSource, getMediaInfoArr());
     }
 
     function dischargePreBuffer() {
@@ -333,14 +439,155 @@ function StreamProcessor(config) {
         return bufferController ? bufferController.getBufferLevel() : 0;
     }
 
-    function switchInitData(representationId, bufferResetEnabled) {
+    function onInitFragmentNeeded(e) {
+        if (!e.sender || e.sender.getType() !== type || e.sender.getStreamId() !== streamInfo.id) 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) {
+        if (e.sender.getType() !== type || e.sender.getStreamId() !== streamInfo.id) return;
+
+        let request;
+
+        // Don't schedule next fragments while pruning to avoid buffer inconsistencies
+        if (!bufferController.getIsPruningInProgress()) {
+            request = findNextRequest(e.seekTarget, e.replacement);
+            scheduleController.setSeekTarget(NaN);
+            if (request && !e.replacement) {
+                if (!isNaN(request.startTime + request.duration)) {
+                    setIndexHandlerTime(request.startTime + request.duration);
+                }
+                request.delayLoadingTime = new Date().getTime() + scheduleController.getTimeToLoadDelay();
+                scheduleController.setTimeToLoadDelay(0);
+            }
+        }
+
+        scheduleController.processMediaRequest(request);
+    }
+
+    function findNextRequest(seekTarget, requestToReplace) {
+        const representationInfo = getRepresentationInfo();
+        const hasSeekTarget = !isNaN(seekTarget);
+        const currentTime = playbackController.getNormalizedTime();
+        let time = hasSeekTarget ? seekTarget : getIndexHandlerTime();
+        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) {
-            bufferController.switchInitData(streamInfo.id, representationId, bufferResetEnabled);
+            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
+            request = getFragmentRequest(representationInfo,
+                hasSeekTarget || bufferIsDivided ? time : undefined, {
+                keepIdx: !hasSeekTarget && !bufferIsDivided
+            });
+
+            // 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 onTimedTextRequested(e) {
+        if (e.streamId !== streamInfo.id) return;
+
+        //if subtitles are disabled, do not download subtitles file.
+        if (textController.isTextEnabled()) {
+            const representation = representationController ? representationController.getRepresentationForQuality(e.index) : null;
+            const request = indexHandler ? indexHandler.getInitRequest(getMediaInfo(), representation) : null;
+            scheduleController.processInitRequest(request);
+        }
+    }
+
+    function onMediaFragmentLoaded(e) {
+        const chunk = e.chunk;
+        if (chunk.streamId !== streamInfo.id || chunk.mediaInfo.type != type) return;
+
+        const bytes = chunk.bytes;
+        const quality = chunk.quality;
+        const currentRepresentation = getRepresentationInfo(quality);
+
+        // Update current representation info (to update fragmentDuration for example in case of SegmentTimeline)
+        scheduleController.setCurrentRepresentation(currentRepresentation);
+
+        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.ADD_INBAND_EVENTS_REQUESTED, { sender: instance, events: events });
         }
     }
 
+    function handleInbandEvents(data, request, mediaInbandEvents, trackInbandEvents) {
+        const fragmentStartTime = Math.max(!request || isNaN(request.startTime) ? 0 : request.startTime, 0);
+        const eventStreams = [];
+        const events = [];
+
+        /* Extract the possible schemeIdUri : If a DASH client detects an event message box with a scheme that is not defined in MPD, the client is expected to ignore it */
+        const inbandEvents = mediaInbandEvents.concat(trackInbandEvents);
+        for (let i = 0, ln = inbandEvents.length; i < ln; i++) {
+            eventStreams[inbandEvents[i].schemeIdUri + '/' + inbandEvents[i].value] = inbandEvents[i];
+        }
+
+        const isoFile = BoxParser(context).getInstance().parse(data);
+        const eventBoxes = isoFile.getBoxes('emsg');
+
+        for (let i = 0, ln = eventBoxes.length; i < ln; i++) {
+            const event = adapter.getEvent(eventBoxes[i], eventStreams, fragmentStartTime);
+
+            if (event) {
+                events.push(event);
+            }
+        }
+
+        return events;
+    }
+
     function createBuffer(previousBuffers) {
-        return (getBuffer() || bufferController ? bufferController.createBuffer(mediaInfo, previousBuffers) : null);
+        return (getBuffer() || bufferController ? bufferController.createBuffer(mediaInfoArr, previousBuffers) : null);
     }
 
     function switchTrackAsked() {
@@ -357,39 +604,35 @@ function StreamProcessor(config) {
 
         if (type === Constants.VIDEO || type === Constants.AUDIO) {
             controller = BufferController(context).create({
-                streamId: streamInfo.id,
+                streamInfo: streamInfo,
                 type: type,
-                dashMetrics: dashMetrics,
                 mediaPlayerModel: mediaPlayerModel,
                 manifestModel: manifestModel,
                 fragmentModel: fragmentModel,
                 errHandler: errHandler,
-                streamController: streamController,
                 mediaController: mediaController,
+                representationController: representationController,
                 adapter: adapter,
                 textController: textController,
                 abrController: abrController,
                 playbackController: playbackController,
-                streamProcessor: instance,
                 settings: settings
             });
         } else {
             controller = TextBufferController(context).create({
-                streamId: streamInfo.id,
+                streamInfo: streamInfo,
                 type: type,
                 mimeType: mimeType,
-                dashMetrics: dashMetrics,
                 mediaPlayerModel: mediaPlayerModel,
                 manifestModel: manifestModel,
                 fragmentModel: fragmentModel,
                 errHandler: errHandler,
-                streamController: streamController,
                 mediaController: mediaController,
+                representationController: representationController,
                 adapter: adapter,
                 textController: textController,
                 abrController: abrController,
                 playbackController: playbackController,
-                streamProcessor: instance,
                 settings: settings
             });
         }
@@ -397,6 +640,53 @@ function StreamProcessor(config) {
         return controller;
     }
 
+    function setLiveEdgeSeekTarget() {
+        if (!liveEdgeFinder) return;
+
+        const currentRepresentationInfo = getRepresentationInfo();
+        const liveEdge = liveEdgeFinder.getLiveEdge(currentRepresentationInfo);
+        const startTime = liveEdge - playbackController.computeLiveDelay(currentRepresentationInfo.fragmentDuration, currentRepresentationInfo.mediaInfo.streamInfo.manifestInfo.DVRWindowSize);
+        const request = getFragmentRequest(currentRepresentationInfo, startTime, {
+            ignoreIsFinished: true
+        });
+
+        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) {
+                const liveStartTime = request.duration < mediaPlayerModel.getLiveDelay() ? request.startTime : request.startTime + request.duration - mediaPlayerModel.getLiveDelay();
+                playbackController.setLiveStartTime(liveStartTime);
+            } else {
+                playbackController.setLiveStartTime(request.startTime);
+            }
+        }
+
+        const seekTarget = playbackController.getStreamStartTime(false, liveEdge);
+        bufferController.setSeekStartTime(seekTarget);
+        scheduleController.setCurrentRepresentation(currentRepresentationInfo);
+        scheduleController.setSeekTarget(seekTarget);
+        scheduleController.start();
+
+        // For multi periods stream, if the startTime is beyond current period then seek to corresponding period (see StreamController::onPlaybackSeeking)
+        if (seekTarget > (currentRepresentationInfo.mediaInfo.streamInfo.start + currentRepresentationInfo.mediaInfo.streamInfo.duration)) {
+            playbackController.seek(seekTarget);
+        }
+
+        dashMetrics.updateManifestUpdateInfo({
+            currentTime: seekTarget,
+            presentationStartTime: liveEdge,
+            latency: liveEdge - seekTarget,
+            clientTimeOffset: timelineConverter.getClientTimeOffset()
+        });
+    }
+
+    function onSeekTarget(e) {
+        if (e.mediaType !== type || e.streamId !== streamInfo.id) return;
+
+        setIndexHandlerTime(e.time);
+        scheduleController.setSeekTarget(e.time);
+    }
+
     function setIndexHandlerTime(value) {
         if (indexHandler) {
             indexHandler.setCurrentTime(value);
@@ -415,9 +705,7 @@ function StreamProcessor(config) {
 
     function getInitRequest(quality) {
         checkInteger(quality);
-
         const representation = representationController ? representationController.getRepresentationForQuality(quality) : null;
-
         return indexHandler ? indexHandler.getInitRequest(getMediaInfo(), representation) : null;
     }
 
@@ -439,6 +727,10 @@ function StreamProcessor(config) {
         return fragRequest;
     }
 
+    function finalisePlayList(time, reason) {
+        dashMetrics.pushPlayListTraceMetrics(time, reason);
+    }
+
     instance = {
         initialize: initialize,
         isUpdating: isUpdating,
@@ -449,7 +741,6 @@ function StreamProcessor(config) {
         getRepresentationController: getRepresentationController,
         getRepresentationInfo: getRepresentationInfo,
         getBufferLevel: getBufferLevel,
-        switchInitData: switchInitData,
         isBufferingCompleted: isBufferingCompleted,
         createBuffer: createBuffer,
         updateStreamInfo: updateStreamInfo,
@@ -469,6 +760,7 @@ function StreamProcessor(config) {
         resetIndexHandler: resetIndexHandler,
         getInitRequest: getInitRequest,
         getFragmentRequest: getFragmentRequest,
+        finalisePlayList: finalisePlayList,
         reset: reset
     };
 
diff --git a/src/streaming/controllers/BufferController.js b/src/streaming/controllers/BufferController.js
index 7d3532aaef..f2def53dda 100644
--- a/src/streaming/controllers/BufferController.js
+++ b/src/streaming/controllers/BufferController.js
@@ -37,7 +37,6 @@ import AbrController from './AbrController';
 import MediaController from './MediaController';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
-import BoxParser from '../utils/BoxParser';
 import FactoryMaker from '../../core/FactoryMaker';
 import Debug from '../../core/Debug';
 import InitCache from '../utils/InitCache';
@@ -57,18 +56,16 @@ function BufferController(config) {
     config = config || {};
     const context = this.context;
     const eventBus = EventBus(context).getInstance();
-    const dashMetrics = config.dashMetrics;
     const errHandler = config.errHandler;
     const fragmentModel = config.fragmentModel;
-    const streamController = config.streamController;
+    const representationController = config.representationController;
     const mediaController = config.mediaController;
     const adapter = config.adapter;
     const textController = config.textController;
     const abrController = config.abrController;
     const playbackController = config.playbackController;
-    const streamId = config.streamId;
+    const streamInfo = config.streamInfo;
     const type = config.type;
-    const streamProcessor = config.streamProcessor;
     const settings = config.settings;
 
     let instance,
@@ -91,7 +88,7 @@ function BufferController(config) {
         seekStartTime,
         seekClearedBufferingCompleted,
         pendingPruningRanges,
-        bufferResetInProgress,
+        replacingBuffer,
         mediaChunk;
 
 
@@ -128,8 +125,13 @@ function BufferController(config) {
         eventBus.on(Events.SOURCEBUFFER_REMOVE_COMPLETED, onRemoved, this);
     }
 
-    function createBuffer(mediaInfo, oldBuffers) {
-        if (!initCache || !mediaInfo || !streamProcessor) return null;
+    function getRepresentationInfo(quality) {
+        return adapter.convertDataToRepresentationInfo(representationController.getRepresentationForQuality(quality));
+    }
+
+    function createBuffer(mediaInfoArr, oldBuffers) {
+        if (!initCache || !mediaInfoArr) return null;
+        const mediaInfo = mediaInfoArr[0];
         if (mediaSource) {
             try {
                 if (oldBuffers && oldBuffers[type]) {
@@ -138,7 +140,7 @@ function BufferController(config) {
                     buffer = SourceBufferSink(context).create(mediaSource, mediaInfo, onAppended.bind(this), settings.get().streaming.useAppendWindowEnd);
                 }
                 if (typeof buffer.getBuffer().initialize === 'function') {
-                    buffer.getBuffer().initialize(type, streamProcessor);
+                    buffer.getBuffer().initialize(type, streamInfo, mediaInfoArr, fragmentModel);
                 }
             } catch (e) {
                 logger.fatal('Caught error on create SourceBuffer: ' + e);
@@ -147,7 +149,7 @@ function BufferController(config) {
         } else {
             buffer = PreBufferSink(context).create(onAppended.bind(this));
         }
-        updateBufferTimestampOffset(streamProcessor.getRepresentationInfo(requiredQuality).MSETimeOffset);
+        updateBufferTimestampOffset(this.getRepresentationInfo(requiredQuality));
         return buffer;
     }
 
@@ -184,12 +186,8 @@ function BufferController(config) {
         }
     }
 
-    function isActive() {
-        return streamProcessor && streamController && streamProcessor.getStreamInfo();
-    }
-
     function onInitFragmentLoaded(e) {
-        if (e.chunk.streamId !== streamId || e.chunk.mediaInfo.type !== type) return;
+        if (e.chunk.streamId !== streamInfo.id || e.chunk.mediaInfo.type !== type) return;
 
         logger.info('Init fragment finished loading saving to', type + '\'s init cache');
         initCache.save(e.chunk);
@@ -197,41 +195,26 @@ function BufferController(config) {
         appendToBuffer(e.chunk);
     }
 
-    function switchInitData(streamId, representationId, bufferResetEnabled) {
-        const chunk = initCache.extract(streamId, representationId);
-        bufferResetInProgress = bufferResetEnabled === true ? bufferResetEnabled : false;
-        if (chunk) {
-            logger.info('Append Init fragment', type, ' with representationId:', chunk.representationId, ' and quality:', chunk.quality, ', data size:', chunk.bytes.byteLength);
-            appendToBuffer(chunk);
-        } else {
-            eventBus.trigger(Events.INIT_REQUESTED, { mediaType: type, sender: instance });
+    function appendInitSegment(representationId) {
+        // Get init segment from cache
+        const chunk = initCache.extract(streamInfo.id, representationId);
+
+        if (!chunk) {
+            // Init segment not in cache, shall be requested
+            return false;
         }
+
+        // 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);
+        return true;
     }
 
     function onMediaFragmentLoaded(e) {
-        if (e.chunk.streamId !== streamId || e.chunk.mediaInfo.type !== type) return;
-
         const chunk = e.chunk;
-        const bytes = chunk.bytes;
-        const quality = chunk.quality;
-        const currentRepresentation = streamProcessor.getRepresentationInfo(quality);
-        const representationController = streamProcessor.getRepresentationController();
-        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, { sender: instance, streamInfo: streamProcessor.getStreamInfo(), events: events });
-        }
+        if (chunk.streamId !== streamInfo.id || chunk.mediaInfo.type != type) return;
 
-        if (bufferResetInProgress) {
+        if (replacingBuffer) {
             mediaChunk = chunk;
             const ranges = buffer && buffer.getAllBufferRanges();
             if (ranges && ranges.length > 0 && playbackController.getTimeToStreamEnd() > STALL_THRESHOLD) {
@@ -251,7 +234,7 @@ function BufferController(config) {
         buffer.append(chunk);
 
         if (chunk.mediaInfo.type === Constants.VIDEO) {
-            eventBus.trigger(Events.VIDEO_CHUNK_RECEIVED, { chunk: chunk });
+            triggerEvent(Events.VIDEO_CHUNK_RECEIVED, { chunk: chunk });
         }
     }
 
@@ -281,7 +264,7 @@ function BufferController(config) {
             }
             if (e.error.code === QUOTA_EXCEEDED_ERROR_CODE || !hasEnoughSpaceToAppend()) {
                 logger.warn('Clearing playback buffer to overcome quota exceed situation');
-                eventBus.trigger(Events.QUOTA_EXCEEDED, { sender: instance, criticalBufferLevel: criticalBufferLevel }); //Tells ScheduleController to stop scheduling.
+                triggerEvent(Events.QUOTA_EXCEEDED, { criticalBufferLevel: criticalBufferLevel }); //Tells ScheduleController to stop scheduling.
                 pruneAllSafely(); // Then we clear the buffer and onCleared event will tell ScheduleController to start scheduling again.
             }
             return;
@@ -299,32 +282,27 @@ function BufferController(config) {
             showBufferRanges(ranges);
             onPlaybackProgression();
         } else {
-            if (bufferResetInProgress) {
+            if (replacingBuffer) {
                 const currentTime = playbackController.getTime();
                 logger.debug('AppendToBuffer seek target should be ' + currentTime);
-                streamProcessor.getScheduleController().setSeekTarget(currentTime);
-                streamProcessor.setIndexHandlerTime(currentTime);
+                triggerEvent(Events.SEEK_TARGET, {time: currentTime});
             }
         }
 
-        const dataEvent = {
-            sender: instance,
-            quality: appendedBytesInfo.quality,
-            startTime: appendedBytesInfo.start,
-            index: appendedBytesInfo.index,
-            bufferedRanges: ranges
-        };
-        if (appendedBytesInfo && !appendedBytesInfo.endFragment) {
-            eventBus.trigger(Events.BYTES_APPENDED, dataEvent);
-        } else if (appendedBytesInfo) {
-            eventBus.trigger(Events.BYTES_APPENDED_END_FRAGMENT, dataEvent);
+        if (appendedBytesInfo) {
+            triggerEvent(appendedBytesInfo.endFragment ? Events.BYTES_APPENDED_END_FRAGMENT : Events.BYTES_APPENDED, {
+                quality: appendedBytesInfo.quality,
+                startTime: appendedBytesInfo.start,
+                index: appendedBytesInfo.index,
+                bufferedRanges: ranges
+            });
         }
     }
 
     function onQualityChanged(e) {
-        if (requiredQuality === e.newQuality || type !== e.mediaType || streamProcessor.getStreamInfo().id !== e.streamInfo.id) return;
+        if (e.streamInfo.id != streamInfo.id || e.mediaType !== type || requiredQuality === e.newQuality) return;
 
-        updateBufferTimestampOffset(streamProcessor.getRepresentationInfo(e.newQuality).MSETimeOffset);
+        updateBufferTimestampOffset(this.getRepresentationInfo(e.newQuality));
         requiredQuality = e.newQuality;
     }
 
@@ -441,9 +419,8 @@ function BufferController(config) {
     }
 
     function onPlaybackProgression() {
-        if (!bufferResetInProgress || (type === Constants.FRAGMENTED_TEXT && textController.isTextEnabled())) {
+        if (!replacingBuffer || (type === Constants.FRAGMENTED_TEXT && textController.isTextEnabled())) {
             updateBufferLevel();
-            addBufferMetrics();
         }
     }
 
@@ -525,23 +502,17 @@ function BufferController(config) {
     function updateBufferLevel() {
         if (playbackController) {
             bufferLevel = getBufferLength(getWorkingTime() || 0);
-            eventBus.trigger(Events.BUFFER_LEVEL_UPDATED, { sender: instance, bufferLevel: bufferLevel });
+            triggerEvent(Events.BUFFER_LEVEL_UPDATED, { bufferLevel: bufferLevel });
             checkIfSufficientBuffer();
         }
     }
 
-    function addBufferMetrics() {
-        if (!isActive()) return;
-        dashMetrics.addBufferState(type, bufferState, streamProcessor.getScheduleController().getBufferTarget());
-        dashMetrics.addBufferLevel(type, new Date(), bufferLevel * 1000);
-    }
-
     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');
-            eventBus.trigger(Events.BUFFERING_COMPLETED, { sender: instance, streamInfo: streamProcessor.getStreamInfo() });
+            triggerEvent(Events.BUFFERING_COMPLETED);
         }
     }
 
@@ -553,7 +524,7 @@ function BufferController(config) {
             seekClearedBufferingCompleted = false;
             isBufferingCompleted = true;
             logger.debug('checkIfSufficientBuffer trigger BUFFERING_COMPLETED');
-            eventBus.trigger(Events.BUFFERING_COMPLETED, { sender: instance, streamInfo: streamProcessor.getStreamInfo() });
+            triggerEvent(Events.BUFFERING_COMPLETED);
         }
 
         // When the player is working in low latency mode, the buffer is often below STALL_THRESHOLD.
@@ -562,7 +533,7 @@ function BufferController(config) {
         if (((!settings.get().streaming.lowLatencyEnabled && bufferLevel < STALL_THRESHOLD) || bufferLevel === 0) && !isBufferingCompleted) {
             notifyBufferStateChanged(MetricsConstants.BUFFER_EMPTY);
         } else {
-            if (isBufferingCompleted || bufferLevel >= streamProcessor.getStreamInfo().manifestInfo.minBufferTime) {
+            if (isBufferingCompleted || bufferLevel >= streamInfo.manifestInfo.minBufferTime) {
                 notifyBufferStateChanged(MetricsConstants.BUFFER_LOADED);
             }
         }
@@ -576,38 +547,12 @@ function BufferController(config) {
         }
 
         bufferState = state;
-        addBufferMetrics();
 
-        eventBus.trigger(Events.BUFFER_LEVEL_STATE_CHANGED, { sender: instance, state: state, mediaType: type, streamInfo: streamProcessor.getStreamInfo() });
-        eventBus.trigger(state === MetricsConstants.BUFFER_LOADED ? Events.BUFFER_LOADED : Events.BUFFER_EMPTY, { mediaType: type });
+        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');
     }
 
-    function handleInbandEvents(data, request, mediaInbandEvents, trackInbandEvents) {
-        const fragmentStartTime = Math.max(!request || isNaN(request.startTime) ? 0 : request.startTime, 0);
-        const eventStreams = [];
-        const events = [];
-
-        /* Extract the possible schemeIdUri : If a DASH client detects an event message box with a scheme that is not defined in MPD, the client is expected to ignore it */
-        const inbandEvents = mediaInbandEvents.concat(trackInbandEvents);
-        for (let i = 0, ln = inbandEvents.length; i < ln; i++) {
-            eventStreams[inbandEvents[i].schemeIdUri + '/' + inbandEvents[i].value] = inbandEvents[i];
-        }
-
-        const isoFile = BoxParser(context).getInstance().parse(data);
-        const eventBoxes = isoFile.getBoxes('emsg');
-
-        for (let i = 0, ln = eventBoxes.length; i < ln; i++) {
-            const event = adapter.getEvent(eventBoxes[i], eventStreams, fragmentStartTime);
-
-            if (event) {
-                events.push(event);
-            }
-        }
-
-        return events;
-    }
-
     /* prune buffer on our own in background to avoid browsers pruning buffer silently */
     function pruneBuffer() {
         if (!buffer || type === Constants.FRAGMENTED_TEXT) {
@@ -712,9 +657,8 @@ function BufferController(config) {
         if (currentTime < range.end) {
             isBufferingCompleted = false;
             maxAppendedIndex = 0;
-            if (!bufferResetInProgress) {
-                streamProcessor.getScheduleController().setSeekTarget(currentTime);
-                streamProcessor.setIndexHandlerTime(currentTime);
+            if (!replacingBuffer) {
+                triggerEvent(Events.SEEK_TARGET, {time: currentTime});
             }
         }
 
@@ -735,49 +679,57 @@ function BufferController(config) {
 
         if (e.unintended) {
             logger.warn('Detected unintended removal from:', e.from, 'to', e.to, 'setting index handler time to', e.from);
-            streamProcessor.setIndexHandlerTime(e.from);
+            triggerEvent(Events.SEEK_TARGET, {time: e.from});
         }
 
         if (isPruningInProgress) {
             clearNextRange();
         } else {
-            if (!bufferResetInProgress) {
+            if (!replacingBuffer) {
                 logger.debug('onRemoved : call updateBufferLevel');
                 updateBufferLevel();
-                addBufferMetrics();
             } else {
-                bufferResetInProgress = false;
+                replacingBuffer = false;
                 if (mediaChunk) {
                     appendToBuffer(mediaChunk);
                 }
             }
-            eventBus.trigger(Events.BUFFER_CLEARED, { sender: instance, from: e.from, to: e.to, unintended: e.unintended,  hasEnoughSpaceToAppend: hasEnoughSpaceToAppend(), quotaExceeded: isQuotaExceeded });
+            triggerEvent(Events.BUFFER_CLEARED, {
+                from: e.from,
+                to: e.to,
+                unintended: e.unintended,
+                hasEnoughSpaceToAppend: hasEnoughSpaceToAppend(),
+                quotaExceeded: isQuotaExceeded });
         }
         //TODO - REMEMBER removed a timerout hack calling clearBuffer after manifestInfo.minBufferTime * 1000 if !hasEnoughSpaceToAppend() Aug 04 2016
     }
 
-    function updateBufferTimestampOffset(MSETimeOffset) {
+    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(MSETimeOffset);
+            buffer.updateTimestampOffset(representationInfo.MSETimeOffset);
         }
     }
 
     function onDataUpdateCompleted(e) {
-        if (e.sender.getType() !== streamProcessor.getType() || e.sender.getStreamId() !== streamProcessor.getStreamInfo().id || e.error) return;
-        updateBufferTimestampOffset(e.currentRepresentation.MSETimeOffset);
+        if (e.sender.getStreamId() !== streamInfo.id || e.sender.getType() !== type) return;
+        if (e.error) return;
+        updateBufferTimestampOffset(e.currentRepresentation);
     }
 
     function onStreamCompleted(e) {
-        if (e.request.mediaInfo.streamInfo.id !== streamId || e.request.mediaType !== type) return;
+        if (e.request.mediaInfo.streamInfo.id !== streamInfo.id || e.request.mediaType !== type) return;
         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 || (e.newMediaInfo.type !== type) || (e.newMediaInfo.streamInfo.id !== streamProcessor.getStreamInfo().id)) return;
+        if (!ranges) return;
 
         logger.info('Track change asked');
         if (mediaController.getSwitchMode(type) === MediaController.TRACK_SWITCH_MODE_ALWAYS_REPLACE) {
@@ -805,10 +757,6 @@ function BufferController(config) {
         return type;
     }
 
-    function getStreamProcessor() {
-        return streamProcessor;
-    }
-
     function setSeekStartTime(value) {
         seekStartTime = value;
     }
@@ -839,6 +787,10 @@ function BufferController(config) {
         return mediaSource;
     }
 
+    function replaceBuffer() {
+        replacingBuffer = true;
+    }
+
     function getIsBufferingCompleted() {
         return isBufferingCompleted;
     }
@@ -867,6 +819,14 @@ function BufferController(config) {
         return (totalBufferedTime < criticalBufferLevel);
     }
 
+    function triggerEvent(eventType, data) {
+        let payload = data || {};
+        payload.sender = instance;
+        payload.mediaType = type;
+        payload.streamId = streamInfo.id;
+        eventBus.trigger(eventType, payload);
+    }
+
     function resetInitialSettings(errored, keepBuffers) {
         criticalBufferLevel = Number.POSITIVE_INFINITY;
         bufferState = undefined;
@@ -890,16 +850,15 @@ function BufferController(config) {
             buffer = null;
         }
 
-        bufferResetInProgress = false;
+        replacingBuffer = false;
     }
 
     function reset(errored, keepBuffers) {
         eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
-        eventBus.off(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, 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.CURRENT_TRACK_CHANGED, onCurrentTrackChanged, this);
         eventBus.off(Events.PLAYBACK_PLAYING, onPlaybackPlaying, this);
         eventBus.off(Events.PLAYBACK_PROGRESS, onPlaybackProgression, this);
         eventBus.off(Events.PLAYBACK_TIME_UPDATED, onPlaybackProgression, this);
@@ -908,6 +867,7 @@ function BufferController(config) {
         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);
 
         resetInitialSettings(errored, keepBuffers);
@@ -915,11 +875,11 @@ function BufferController(config) {
 
     instance = {
         getBufferControllerType: getBufferControllerType,
+        getRepresentationInfo: getRepresentationInfo,
         initialize: initialize,
         createBuffer: createBuffer,
         dischargePreBuffer: dischargePreBuffer,
         getType: getType,
-        getStreamProcessor: getStreamProcessor,
         setSeekStartTime: setSeekStartTime,
         getBuffer: getBuffer,
         setBuffer: setBuffer,
@@ -927,8 +887,9 @@ function BufferController(config) {
         getRangeAt: getRangeAt,
         setMediaSource: setMediaSource,
         getMediaSource: getMediaSource,
+        appendInitSegment: appendInitSegment,
+        replaceBuffer: replaceBuffer,
         getIsBufferingCompleted: getIsBufferingCompleted,
-        switchInitData: switchInitData,
         getIsPruningInProgress: getIsPruningInProgress,
         reset: reset
     };
diff --git a/src/streaming/controllers/PlaybackController.js b/src/streaming/controllers/PlaybackController.js
index d609d84355..86baeb11fc 100644
--- a/src/streaming/controllers/PlaybackController.js
+++ b/src/streaming/controllers/PlaybackController.js
@@ -688,7 +688,7 @@ function PlaybackController() {
             return;
         }
 
-        const type = e.sender.getType();
+        const type = e.mediaType;
 
         if (bufferedRange[streamInfo.id] === undefined) {
             bufferedRange[streamInfo.id] = [];
@@ -705,11 +705,8 @@ function PlaybackController() {
             earliestTime[streamInfo.id][type] = Math.max(ranges.start(0), streamInfo.start);
         }
 
-        const hasVideoTrack = streamController.isTrackTypePresent(Constants.VIDEO);
-        const hasAudioTrack = streamController.isTrackTypePresent(Constants.AUDIO);
-
         initialStartTime = getStreamStartTime(false);
-        if (hasAudioTrack && hasVideoTrack) {
+        if (streamController.hasVideoTrack() && streamController.hasAudioTrack()) {
             //current stream has audio and video contents
             if (!isNaN(earliestTime[streamInfo.id].audio) && !isNaN(earliestTime[streamInfo.id].video)) {
 
@@ -761,7 +758,7 @@ function PlaybackController() {
 
     function onBufferLevelStateChanged(e) {
         // do not stall playback when get an event from Stream that is not active
-        if (e.streamInfo.id !== streamInfo.id) return;
+        if (e.streamId !== streamInfo.id) return;
 
         if (settings.get().streaming.lowLatencyEnabled) {
             if (e.state === MetricsConstants.BUFFER_EMPTY && !isSeeking()) {
diff --git a/src/streaming/controllers/ScheduleController.js b/src/streaming/controllers/ScheduleController.js
index 2e4c1a02b5..3c491e033e 100644
--- a/src/streaming/controllers/ScheduleController.js
+++ b/src/streaming/controllers/ScheduleController.js
@@ -30,16 +30,13 @@
  */
 import Constants from '../constants/Constants';
 import MetricsConstants from '../constants/MetricsConstants';
-import {PlayListTrace} from '../vo/metrics/PlayList';
 import BufferLevelRule from '../rules/scheduling/BufferLevelRule';
-import NextFragmentRequestRule from '../rules/scheduling/NextFragmentRequestRule';
 import FragmentModel from '../models/FragmentModel';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
 import FactoryMaker from '../../core/FactoryMaker';
 import Debug from '../../core/Debug';
 import MediaController from './MediaController';
-import LiveEdgeFinder from '../utils/LiveEdgeFinder';
 
 function ScheduleController(config) {
 
@@ -48,17 +45,16 @@ function ScheduleController(config) {
     const eventBus = EventBus(context).getInstance();
     const adapter = config.adapter;
     const dashMetrics = config.dashMetrics;
-    const timelineConverter = config.timelineConverter;
     const mediaPlayerModel = config.mediaPlayerModel;
     const fragmentModel = config.fragmentModel;
     const abrController = config.abrController;
     const playbackController = config.playbackController;
-    const streamController = config.streamController;
     const textController = config.textController;
     const streamId = config.streamId;
     const type = config.type;
-    const streamProcessor = config.streamProcessor;
+    const mimeType = config.mimeType;
     const mediaController = config.mediaController;
+    const bufferController = config.bufferController;
     const settings = config.settings;
 
     let instance,
@@ -70,30 +66,26 @@ function ScheduleController(config) {
         timeToLoadDelay,
         scheduleTimeout,
         seekTarget,
+        hasVideoTrack,
         bufferLevelRule,
-        nextFragmentRequestRule,
         lastFragmentRequest,
         topQualityIndex,
         lastInitQuality,
         replaceRequestArray,
         switchTrack,
-        bufferResetInProgress,
+        replacingBuffer,
         mediaRequest,
-        liveEdgeFinder,
         checkPlaybackQuality,
         isReplacementRequest;
 
     function setup() {
         logger = Debug(context).getInstance().getLogger(instance);
-        if (playbackController && playbackController.getIsDynamic()) {
-            liveEdgeFinder = LiveEdgeFinder(context).create({
-                timelineConverter: timelineConverter
-            });
-        }
         resetInitialSettings();
     }
 
-    function initialize() {
+    function initialize(_hasVideoTrack) {
+        hasVideoTrack = _hasVideoTrack;
+
         bufferLevelRule = BufferLevelRule(context).create({
             abrController: abrController,
             dashMetrics: dashMetrics,
@@ -102,26 +94,12 @@ function ScheduleController(config) {
             settings: settings
         });
 
-        nextFragmentRequestRule = NextFragmentRequestRule(context).create({
-            textController: textController,
-            playbackController: playbackController
-        });
-
-        if (adapter.getIsTextTrack(config.mimeType)) {
-            eventBus.on(Events.TIMED_TEXT_REQUESTED, onTimedTextRequested, this);
-        }
-
         //eventBus.on(Events.LIVE_EDGE_SEARCH_COMPLETED, onLiveEdgeSearchCompleted, this);
-        eventBus.on(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, this);
         eventBus.on(Events.DATA_UPDATE_STARTED, onDataUpdateStarted, this);
-        eventBus.on(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
         eventBus.on(Events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, this);
         eventBus.on(Events.STREAM_COMPLETED, onStreamCompleted, this);
-        eventBus.on(Events.STREAM_INITIALIZED, onStreamInitialized, this);
-        eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, this);
         eventBus.on(Events.BUFFER_CLEARED, onBufferCleared, this);
         eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, onBytesAppended, this);
-        eventBus.on(Events.INIT_REQUESTED, onInitRequested, this);
         eventBus.on(Events.QUOTA_EXCEEDED, onQuotaExceeded, this);
         eventBus.on(Events.PLAYBACK_SEEKING, onPlaybackSeeking, this);
         eventBus.on(Events.PLAYBACK_STARTED, onPlaybackStarted, this);
@@ -129,6 +107,11 @@ function ScheduleController(config) {
         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);
+    }
+
+    function setCurrentRepresentation(representationInfo) {
+        currentRepresentationInfo = representationInfo;
     }
 
     function isStarted() {
@@ -136,13 +119,12 @@ function ScheduleController(config) {
     }
 
     function start() {
-        if (!currentRepresentationInfo || streamProcessor.isBufferingCompleted()) {
-            logger.warn('Start denied to Schedule Controller');
-            return;
-        }
+        if (isStarted()) return;
+        if (!currentRepresentationInfo || bufferController.getIsBufferingCompleted()) return;
+
         logger.debug('Schedule Controller starts');
-        createPlaylistTraceMetrics();
         isStopped = false;
+        dashMetrics.createPlaylistTraceMetrics(currentRepresentationInfo.id, playbackController.getTime() * 1000, playbackController.getPlaybackRate());
 
         if (initialRequest) {
             initialRequest = false;
@@ -152,9 +134,8 @@ function ScheduleController(config) {
     }
 
     function stop() {
-        if (isStopped) {
-            return;
-        }
+        if (isStopped) return;
+
         logger.debug('Schedule Controller stops');
         isStopped = true;
         clearTimeout(scheduleTimeout);
@@ -174,8 +155,7 @@ function ScheduleController(config) {
     }
 
     function schedule() {
-        const bufferController = streamProcessor.getBufferController();
-        if (isStopped || isFragmentProcessingInProgress || !bufferController ||
+        if (isStopped || isFragmentProcessingInProgress ||
             (playbackController.isPaused() && !settings.get().streaming.scheduleWhilePaused) ||
             ((type === Constants.FRAGMENTED_TEXT || type === Constants.TEXT) && !textController.isTextEnabled())) {
             logger.debug('Schedule stop!');
@@ -190,22 +170,23 @@ function ScheduleController(config) {
         validateExecutedFragmentRequest();
 
         const isReplacement = replaceRequestArray.length > 0;
-        const streamInfo = streamProcessor.getStreamInfo();
-        if (bufferResetInProgress || isNaN(lastInitQuality) || switchTrack || isReplacement ||
-            hasTopQualityChanged(currentRepresentationInfo.mediaInfo.type, streamInfo.id) ||
-            bufferLevelRule.execute(streamProcessor, streamController.isTrackTypePresent(Constants.VIDEO))) {
+        if (replacingBuffer || isNaN(lastInitQuality) || switchTrack || isReplacement ||
+            hasTopQualityChanged(type, streamId) ||
+            bufferLevelRule.execute(type, currentRepresentationInfo, hasVideoTrack)) {
 
             const getNextFragment = function () {
-                if ((currentRepresentationInfo.quality !== lastInitQuality || switchTrack) && (!bufferResetInProgress)) {
-                    logger.debug('Quality has changed, get init request for representationid = ' + currentRepresentationInfo.id);
+                if ((currentRepresentationInfo.quality !== lastInitQuality || switchTrack) && (!replacingBuffer)) {
                     if (switchTrack) {
-                        bufferResetInProgress = mediaController.getSwitchMode(type) === MediaController.TRACK_SWITCH_MODE_ALWAYS_REPLACE ? true : false;
-                        logger.debug('Switch track has been asked, get init request for ' + type + ' with representationid = ' + currentRepresentationInfo.id + 'bufferResetInProgress = ' + bufferResetInProgress);
-                        streamProcessor.switchInitData(currentRepresentationInfo.id, bufferResetInProgress);
+                        logger.debug('Switch track for ' + type + ', representation id = ' + currentRepresentationInfo.id);
+                        replacingBuffer = mediaController.getSwitchMode(type) === MediaController.TRACK_SWITCH_MODE_ALWAYS_REPLACE;
+                        if (replacingBuffer && bufferController.replaceBuffer) {
+                            bufferController.replaceBuffer();
+                        }
                         switchTrack = false;
                     } else {
-                        streamProcessor.switchInitData(currentRepresentationInfo.id);
+                        logger.debug('Quality has changed, get init request for representationid = ' + currentRepresentationInfo.id);
                     }
+                    eventBus.trigger(Events.INIT_FRAGMENT_NEEDED, { sender: instance, representationId: currentRepresentationInfo.id });
                     lastInitQuality = currentRepresentationInfo.quality;
                     checkPlaybackQuality = false;
                 } else {
@@ -213,33 +194,10 @@ function ScheduleController(config) {
 
                     if (replacement && replacement.isInitializationRequest()) {
                         // To be sure the specific init segment had not already been loaded
-                        streamProcessor.switchInitData(replacement.representationId);
+                        eventBus.trigger(Events.INIT_FRAGMENT_NEEDED, { sender: instance, representationId: replacement.representationId });
                         checkPlaybackQuality = false;
                     } else {
-                        let request;
-                        // Don't schedule next fragments while pruning to avoid buffer inconsistencies
-                        if (!streamProcessor.getBufferController().getIsPruningInProgress()) {
-                            request = nextFragmentRequestRule.execute(streamProcessor, seekTarget, replacement);
-                            setSeekTarget(NaN);
-                            if (request && !replacement) {
-                                if (!isNaN(request.startTime + request.duration)) {
-                                    streamProcessor.setIndexHandlerTime(request.startTime + request.duration);
-                                }
-                                request.delayLoadingTime = new Date().getTime() + timeToLoadDelay;
-                                setTimeToLoadDelay(0);
-                            }
-                            if (!request && streamInfo.manifestInfo && streamInfo.manifestInfo.isDynamic) {
-                                logger.debug('Next fragment seems to be at the bleeding live edge and is not available yet. Rescheduling.');
-                            }
-                        }
-
-                        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.
-                            setFragmentProcessState(false);
-                            startScheduleTimer(settings.get().streaming.lowLatencyEnabled ? 100 : 500);
-                        }
+                        eventBus.trigger(Events.MEDIA_FRAGMENT_NEEDED, { sender: instance, seekTarget: seekTarget, replacement: replacement });
                         checkPlaybackQuality = true;
                     }
                 }
@@ -275,9 +233,9 @@ function ScheduleController(config) {
             threshold: 0
         })[0];
 
-        if (request && replaceRequestArray.indexOf(request) === -1 && !adapter.getIsTextTrack(type)) {
+        if (request && replaceRequestArray.indexOf(request) === -1 && !adapter.getIsTextTrack(mimeType)) {
             const fastSwitchModeEnabled = settings.get().streaming.fastSwitchEnabled;
-            const bufferLevel = streamProcessor.getBufferLevel();
+            const bufferLevel = bufferController.getBufferLevel();
             const abandonmentState = abrController.getAbandonmentStateFor(type);
 
             // Only replace on track switch when NEVER_REPLACE
@@ -288,7 +246,7 @@ function ScheduleController(config) {
                 replaceRequest(request);
                 isReplacementRequest = true;
                 logger.debug('Reloading outdated fragment at index: ', request.index);
-            } else if (request.quality > currentRepresentationInfo.quality && !bufferResetInProgress) {
+            } else if (request.quality > currentRepresentationInfo.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);
             }
@@ -301,30 +259,34 @@ function ScheduleController(config) {
         scheduleTimeout = setTimeout(schedule, value);
     }
 
-    function onInitRequested(e) {
-        if (!e.sender || e.sender.getStreamProcessor() !== streamProcessor) {
-            return;
-        }
-
-        getInitRequest(currentRepresentationInfo.quality);
-    }
-
-    function setFragmentProcessState(state) {
-        if (isFragmentProcessingInProgress !== state) {
+    function setFragmentProcessState (state) {
+        if (isFragmentProcessingInProgress !== state ) {
             isFragmentProcessingInProgress = state;
         } else {
             logger.debug('isFragmentProcessingInProgress is already equal to', state);
         }
     }
 
-    function getInitRequest(quality) {
-        const request = streamProcessor.getInitRequest(quality);
+    function processInitRequest(request) {
         if (request) {
             setFragmentProcessState(true);
             fragmentModel.executeRequest(request);
         }
     }
 
+    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 switchTrackAsked() {
         switchTrack = true;
     }
@@ -333,21 +295,6 @@ function ScheduleController(config) {
         replaceRequestArray.push(request);
     }
 
-    function onQualityChanged(e) {
-        if (type !== e.mediaType || streamProcessor.getStreamInfo().id !== e.streamInfo.id) {
-            return;
-        }
-
-        currentRepresentationInfo = streamProcessor.getRepresentationInfo(e.newQuality);
-
-        if (currentRepresentationInfo === null || currentRepresentationInfo === undefined) {
-            throw new Error('Unexpected error! - currentRepresentationInfo is null or undefined');
-        }
-
-        clearPlayListTraceMetrics(new Date(), PlayListTrace.REPRESENTATION_SWITCH_STOP_REASON);
-        createPlaylistTraceMetrics();
-    }
-
     function completeQualityChange(trigger) {
         if (playbackController && fragmentModel) {
             const item = fragmentModel.getRequests({
@@ -379,100 +326,6 @@ function ScheduleController(config) {
         }
     }
 
-    function onDataUpdateCompleted(e) {
-        if (e.error || e.sender.getType() !== streamProcessor.getType()) {
-            return;
-        }
-
-        currentRepresentationInfo = adapter.convertDataToRepresentationInfo(e.currentRepresentation);
-    }
-
-    function onStreamInitialized(e) {
-        if (!e.streamInfo || streamProcessor.getStreamInfo().id !== e.streamInfo.id) {
-            return;
-        }
-
-        currentRepresentationInfo = streamProcessor.getRepresentationInfo();
-
-        if (initialRequest) {
-            if (playbackController.getIsDynamic()) {
-                timelineConverter.setTimeSyncCompleted(true);
-                setLiveEdgeSeekTarget();
-            } else {
-                setSeekTarget(playbackController.getStreamStartTime(false));
-                const bufferController = streamProcessor.getBufferController();
-                if (bufferController) {
-                    bufferController.setSeekStartTime(seekTarget);
-                }
-            }
-        }
-
-        if (isStopped) {
-            start();
-        }
-    }
-
-    function setLiveEdgeSeekTarget() {
-        if (liveEdgeFinder) {
-            const liveEdge = liveEdgeFinder.getLiveEdge(streamProcessor.getRepresentationInfo());
-            let request = _findRequestForLiveEdge(liveEdge);
-
-            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) {
-                    const liveStartTime = request.duration < mediaPlayerModel.getLiveDelay() ? request.startTime : request.startTime + request.duration - mediaPlayerModel.getLiveDelay();
-                    playbackController.setLiveStartTime(liveStartTime);
-                } else {
-                    playbackController.setLiveStartTime(request.startTime);
-                }
-            } else {
-                logger.debug('setLiveEdgeSeekTarget : getFragmentRequest returned undefined request object');
-            }
-            setSeekTarget(playbackController.getStreamStartTime(false, liveEdge));
-            streamProcessor.getBufferController().setSeekStartTime(seekTarget);
-
-            //special use case for multi period stream. If the startTime is out of the current period, send a seek command.
-            //in onPlaybackSeeking callback (StreamController), the detection of switch stream is done.
-            if (seekTarget > (currentRepresentationInfo.mediaInfo.streamInfo.start + currentRepresentationInfo.mediaInfo.streamInfo.duration)) {
-                playbackController.seek(seekTarget);
-            }
-
-            dashMetrics.updateManifestUpdateInfo({
-                currentTime: seekTarget,
-                presentationStartTime: liveEdge,
-                latency: liveEdge - seekTarget,
-                clientTimeOffset: timelineConverter.getClientTimeOffset()
-            });
-        }
-    }
-
-    function _findRequestForLiveEdge(liveEdge) {
-        try {
-            let request = null;
-            let liveDelay = playbackController.computeLiveDelay(currentRepresentationInfo.fragmentDuration, currentRepresentationInfo.mediaInfo.streamInfo.manifestInfo.DVRWindowSize);
-            const dvrWindowSize = !isNaN(currentRepresentationInfo.mediaInfo.streamInfo.manifestInfo.DVRWindowSize) ? currentRepresentationInfo.mediaInfo.streamInfo.manifestInfo.DVRWindowSize : liveDelay;
-
-            // Make sure that we have at least a valid request for the end of the DVR window, otherwise we might try forever
-            if (streamProcessor.getFragmentRequest(currentRepresentationInfo, liveEdge - dvrWindowSize, {
-                ignoreIsFinished: true
-            })) {
-                // Try to find a request as close as possible to the targeted live edge
-                while (!request && liveDelay <= dvrWindowSize) {
-                    let startTime = liveEdge - liveDelay;
-                    request = streamProcessor.getFragmentRequest(currentRepresentationInfo, startTime, {
-                        ignoreIsFinished: true
-                    });
-                    liveDelay += 1; // Increase by one second for each iteration
-                }
-            }
-
-            return request;
-        } catch (e) {
-            return null;
-        }
-    }
-
     function onStreamCompleted(e) {
         if (e.request.mediaInfo.streamInfo.id !== streamId || e.request.mediaType !== type) return;
 
@@ -484,9 +337,9 @@ function ScheduleController(config) {
     function onFragmentLoadingCompleted(e) {
         if (e.request.mediaInfo.streamInfo.id !== streamId || e.request.mediaType !== type) return;
 
-        logger.info('OnFragmentLoadingCompleted - Url:', e.request ? e.request.url : 'undefined', e.request.range ?
-            ', Range:' + e.request.range : '');
-        if (adapter.getIsTextTrack(type)) {
+        logger.info('OnFragmentLoadingCompleted - Url:', e.request ? e.request.url : 'undefined', e.request.range ? ', Range:' + e.request.range : '');
+
+        if (adapter.getIsTextTrack(mimeType)) {
             setFragmentProcessState(false);
         }
 
@@ -496,7 +349,7 @@ function ScheduleController(config) {
             startScheduleTimer(0);
         }
 
-        if (bufferResetInProgress) {
+        if (replacingBuffer) {
             mediaRequest = e.request;
         }
     }
@@ -506,12 +359,10 @@ function ScheduleController(config) {
     }
 
     function onBytesAppended(e) {
-        if (e.sender.getStreamProcessor() !== streamProcessor) {
-            return;
-        }
+        if (e.streamId !== streamId || e.mediaType !== type) return;
 
-        if (bufferResetInProgress && !isNaN(e.startTime)) {
-            bufferResetInProgress = false;
+        if (replacingBuffer && !isNaN(e.startTime)) {
+            replacingBuffer = false;
             fragmentModel.addExecutedRequest(mediaRequest);
         }
 
@@ -547,48 +398,25 @@ function ScheduleController(config) {
     }
 
     function onDataUpdateStarted(e) {
-        const streamInfo = streamProcessor.getStreamInfo();
-        const streamInfoId = streamInfo ? streamInfo.id : null;
-        if (e.sender.getType() !== streamProcessor.getType() || e.sender.getStreamId() !== streamInfoId) {
-            return;
-        }
+        if (e.sender.getType() !== type || e.sender.getStreamId() !== streamId) return;
+        stop();
+    }
 
+    function onBufferingCompleted(e) {
+        if (type !== e.mediaType || streamId !== e.streamId) return;
         stop();
     }
 
     function onBufferCleared(e) {
-        if (e.sender.getStreamProcessor() !== streamProcessor) {
-            return;
-        }
-
-        const streamInfo = streamProcessor.getStreamInfo();
-        if (streamInfo) {
-            if (e.unintended) {
-                // There was an unintended buffer remove, probably creating a gap in the buffer, remove every saved request
-                fragmentModel.removeExecutedRequestsAfterTime(e.from);
-            } else {
-                fragmentModel.syncExecutedRequestsWithBufferedRange(
-                    streamProcessor.getBufferController().getBuffer().getAllBufferRanges(),
-                    streamInfo.duration);
-            }
-        }
+        if (e.streamId !== streamId || e.mediaType !== type) return;
 
         if (e.hasEnoughSpaceToAppend && e.quotaExceeded && isStopped) {
             start();
         }
     }
 
-    function onBufferLevelStateChanged(e) {
-        if ((e.sender.getStreamProcessor() === streamProcessor) && e.state === MetricsConstants.BUFFER_EMPTY && !playbackController.isSeeking()) {
-            logger.info('Buffer is empty! Stalling!');
-            clearPlayListTraceMetrics(new Date(), PlayListTrace.REBUFFERING_REASON);
-        }
-    }
-
     function onQuotaExceeded(e) {
-        if (e.sender.getStreamProcessor() !== streamProcessor) {
-            return;
-        }
+        if (e.streamId !== streamId || e.mediaType !== type) return;
 
         stop();
         setFragmentProcessState(false);
@@ -599,19 +427,6 @@ function ScheduleController(config) {
         stop();
     }
 
-    function onTimedTextRequested(e) {
-        const streamInfo = streamProcessor.getStreamInfo();
-        const streamInfoId = streamInfo ? streamInfo.id : null;
-        if (e.sender.getStreamId() !== streamInfoId) {
-            return;
-        }
-
-        //if subtitles are disabled, do not download subtitles file.
-        if (textController.isTextEnabled()) {
-            getInitRequest(e.index);
-        }
-    }
-
     function onPlaybackStarted() {
         if (isStopped || !settings.get().streaming.scheduleWhilePaused) {
             start();
@@ -652,27 +467,20 @@ function ScheduleController(config) {
         timeToLoadDelay = value;
     }
 
+    function getTimeToLoadDelay() {
+        return timeToLoadDelay;
+    }
+
     function getBufferTarget() {
-        return bufferLevelRule.getBufferTarget(streamProcessor, streamController.isTrackTypePresent(Constants.VIDEO));
+        return bufferLevelRule.getBufferTarget(type, currentRepresentationInfo, hasVideoTrack);
     }
 
     function getType() {
         return type;
     }
 
-    function finalisePlayList(time, reason) {
-        clearPlayListTraceMetrics(time, reason);
-    }
-
-    function clearPlayListTraceMetrics(endTime, stopreason) {
-        dashMetrics.pushPlayListTraceMetrics(endTime, stopreason);
-    }
-
-    function createPlaylistTraceMetrics() {
-        if (currentRepresentationInfo) {
-            const playbackRate = playbackController.getPlaybackRate();
-            dashMetrics.createPlaylistTraceMetrics(currentRepresentationInfo.id, playbackController.getTime() * 1000, playbackRate !== null ? playbackRate.toString() : null);
-        }
+    function getStreamId() {
+        return streamId;
     }
 
     function resetInitialSettings() {
@@ -691,7 +499,7 @@ function ScheduleController(config) {
         replaceRequestArray = [];
         isStopped = true;
         switchTrack = false;
-        bufferResetInProgress = false;
+        replacingBuffer = false;
         mediaRequest = null;
         isReplacementRequest = false;
     }
@@ -699,48 +507,40 @@ function ScheduleController(config) {
     function reset() {
         //eventBus.off(Events.LIVE_EDGE_SEARCH_COMPLETED, onLiveEdgeSearchCompleted, this);
         eventBus.off(Events.DATA_UPDATE_STARTED, onDataUpdateStarted, this);
-        eventBus.off(Events.DATA_UPDATE_COMPLETED, onDataUpdateCompleted, this);
-        eventBus.off(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, this);
-        eventBus.off(Events.QUALITY_CHANGE_REQUESTED, onQualityChanged, this);
         eventBus.off(Events.FRAGMENT_LOADING_COMPLETED, onFragmentLoadingCompleted, this);
         eventBus.off(Events.STREAM_COMPLETED, onStreamCompleted, this);
-        eventBus.off(Events.STREAM_INITIALIZED, onStreamInitialized, this);
-        eventBus.off(Events.QUOTA_EXCEEDED, onQuotaExceeded, this);
-        eventBus.off(Events.BYTES_APPENDED_END_FRAGMENT, onBytesAppended, this);
         eventBus.off(Events.BUFFER_CLEARED, onBufferCleared, this);
-        eventBus.off(Events.INIT_REQUESTED, onInitRequested, this);
-        eventBus.off(Events.PLAYBACK_RATE_CHANGED, onPlaybackRateChanged, 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);
-        if (adapter.getIsTextTrack(type)) {
-            eventBus.off(Events.TIMED_TEXT_REQUESTED, onTimedTextRequested, this);
-        }
+        eventBus.off(Events.BUFFERING_COMPLETED, onBufferingCompleted, this);
 
         stop();
         completeQualityChange(false);
         resetInitialSettings();
-        if (liveEdgeFinder) {
-            liveEdgeFinder.reset();
-            liveEdgeFinder = null;
-        }
     }
 
     instance = {
         initialize: initialize,
         getType: getType,
+        getStreamId: getStreamId,
+        setCurrentRepresentation: setCurrentRepresentation,
         setSeekTarget: setSeekTarget,
         setTimeToLoadDelay: setTimeToLoadDelay,
-        replaceRequest: replaceRequest,
+        getTimeToLoadDelay: getTimeToLoadDelay,
         switchTrackAsked: switchTrackAsked,
         isStarted: isStarted,
         start: start,
         stop: stop,
         reset: reset,
         getBufferTarget: getBufferTarget,
-        finalisePlayList: finalisePlayList
+        processInitRequest: processInitRequest,
+        processMediaRequest: processMediaRequest
     };
 
     setup();
diff --git a/src/streaming/controllers/StreamController.js b/src/streaming/controllers/StreamController.js
index 4df7f7d4e0..00b5e7d991 100644
--- a/src/streaming/controllers/StreamController.js
+++ b/src/streaming/controllers/StreamController.js
@@ -90,8 +90,6 @@ function StreamController() {
         mediaPlayerModel,
         isPaused,
         initialPlayback,
-        videoTrackDetected,
-        audioTrackDetected,
         isPeriodSwitchInProgress,
         playbackEndedTimerId,
         prefetchTimerId,
@@ -177,7 +175,7 @@ function StreamController() {
      * Used to determine the time current stream is finished and we should switch to the next stream.
      */
     function onPlaybackTimeUpdated(/*e*/) {
-        if (isTrackTypePresent(Constants.VIDEO)) {
+        if (hasVideoTrack()) {
             const playbackQuality = videoModel.getPlaybackQuality();
             if (playbackQuality) {
                 dashMetrics.addDroppedFrames(playbackQuality);
@@ -339,16 +337,11 @@ function StreamController() {
     function onTrackBufferingCompleted(e) {
         // In multiperiod situations, as soon as one of the tracks (AUDIO, VIDEO) is finished we should
         // start doing prefetching of the next period
-        if (!e.sender) {
-            return;
-        }
-        if (e.sender.getType() !== Constants.AUDIO && e.sender.getType() !== Constants.VIDEO) {
-            return;
-        }
+        if (e.mediaType !== Constants.AUDIO && e.mediaType !== Constants.VIDEO) return;
 
         const isLast = getActiveStreamInfo().isLast;
         if (mediaSource && !isLast && playbackEndedTimerId === undefined) {
-            logger.info('[onTrackBufferingCompleted] end of period detected. Track', e.sender.getType(), 'has finished');
+            logger.info('[onTrackBufferingCompleted] end of period detected. Track', e.mediaType, 'has finished');
             isPeriodSwitchInProgress = true;
             if (isPaused === false) {
                 toggleEndPeriodTimer();
@@ -453,8 +446,6 @@ function StreamController() {
     function onEnded() {
         const nextStream = getNextStream();
         if (nextStream) {
-            audioTrackDetected = undefined;
-            videoTrackDetected = undefined;
             switchStream(activeStream, nextStream, NaN);
         } else {
             logger.debug('StreamController no next stream found');
@@ -562,8 +553,6 @@ function StreamController() {
 
     function activateStream(seekTime, keepBuffers) {
         buffers = activeStream.activate(mediaSource, keepBuffers ? buffers : undefined);
-        audioTrackDetected = checkTrackPresence(Constants.AUDIO);
-        videoTrackDetected = checkTrackPresence(Constants.VIDEO);
 
         // check if change type is supported by the browser
         if (buffers) {
@@ -649,7 +638,6 @@ function StreamController() {
                         mediaController: mediaController,
                         textController: textController,
                         videoModel: videoModel,
-                        streamController: instance,
                         settings: settings
                     });
                     streams.push(stream);
@@ -754,42 +742,19 @@ function StreamController() {
         }
     }
 
-    function isTrackTypePresent(trackType) {
-        let isTrackTypeDetected;
-
-        if (!trackType) {
-            return isTrackTypeDetected;
-        }
-
-        switch (trackType) {
-            case Constants.VIDEO :
-                isTrackTypeDetected = videoTrackDetected;
-                break;
-            case Constants.AUDIO :
-                isTrackTypeDetected = audioTrackDetected;
-                break;
-        }
-        return isTrackTypeDetected;
+    function hasVideoTrack() {
+        return activeStream ? activeStream.getHasVideoTrack() : false;
     }
 
-    function checkTrackPresence(type) {
-        let isDetected = false;
-        getActiveStreamProcessors().forEach(p => {
-            if (p.getMediaInfo().type === type) {
-                isDetected = true;
-            }
-        });
-        return isDetected;
+    function hasAudioTrack() {
+        return activeStream ? activeStream.getHasAudioTrack() : false;
     }
 
     function flushPlaylistMetrics(reason, time) {
         time = time || new Date();
 
         getActiveStreamProcessors().forEach(p => {
-            const ctrlr = p.getScheduleController();
-            if (ctrlr) {
-                ctrlr.finalisePlayList(time, reason);
-            }
+            p.finalisePlayList(time, reason);
         });
         dashMetrics.addPlayList();
     }
@@ -947,8 +912,6 @@ function StreamController() {
         activeStream = null;
         hasMediaError = false;
         hasInitialisationError = false;
-        videoTrackDetected = undefined;
-        audioTrackDetected = undefined;
         initialPlayback = true;
         isPaused = false;
         autoPlay = true;
@@ -1017,7 +980,8 @@ function StreamController() {
     instance = {
         initialize: initialize,
         getActiveStreamInfo: getActiveStreamInfo,
-        isTrackTypePresent: isTrackTypePresent,
+        hasVideoTrack: hasVideoTrack,
+        hasAudioTrack: hasAudioTrack,
         switchToVideoElement: switchToVideoElement,
         getStreamById: getStreamById,
         getStreamForTime: getStreamForTime,
diff --git a/src/streaming/rules/scheduling/BufferLevelRule.js b/src/streaming/rules/scheduling/BufferLevelRule.js
index 3257a77fad..c61f408b70 100644
--- a/src/streaming/rules/scheduling/BufferLevelRule.js
+++ b/src/streaming/rules/scheduling/BufferLevelRule.js
@@ -44,22 +44,21 @@ function BufferLevelRule(config) {
     function setup() {
     }
 
-    function execute(streamProcessor, videoTrackPresent) {
-        if (!streamProcessor) {
+    function execute(type, representationInfo, hasVideoTrack) {
+        if (!type || !representationInfo) {
             return true;
         }
-        const bufferLevel = dashMetrics.getCurrentBufferLevel(streamProcessor.getType());
-        return bufferLevel < getBufferTarget(streamProcessor, videoTrackPresent);
+        const bufferLevel = dashMetrics.getCurrentBufferLevel(type);
+        return bufferLevel < getBufferTarget(type, representationInfo, hasVideoTrack);
     }
 
-    function getBufferTarget(streamProcessor, videoTrackPresent) {
+    function getBufferTarget(type, representationInfo, hasVideoTrack) {
         let bufferTarget = NaN;
 
-        if (!streamProcessor) {
+        if (!type || !representationInfo) {
             return bufferTarget;
         }
-        const type = streamProcessor.getType();
-        const representationInfo = streamProcessor.getRepresentationInfo();
+
         if (type === Constants.FRAGMENTED_TEXT) {
             if (textController.isTextEnabled()) {
                 if (isNaN(representationInfo.fragmentDuration)) { //fragmentDuration of representationInfo is not defined,
@@ -73,7 +72,7 @@ function BufferLevelRule(config) {
             } else { // text is disabled, rule will return false
                 bufferTarget = 0;
             }
-        } else if (type === Constants.AUDIO && videoTrackPresent) {
+        } else if (type === Constants.AUDIO && hasVideoTrack) {
             const videoBufferLevel = dashMetrics.getCurrentBufferLevel(Constants.VIDEO);
             if (isNaN(representationInfo.fragmentDuration)) {
                 bufferTarget = videoBufferLevel;
diff --git a/src/streaming/text/NotFragmentedTextBufferController.js b/src/streaming/text/NotFragmentedTextBufferController.js
index 1b062a7d63..54bbf0ee09 100644
--- a/src/streaming/text/NotFragmentedTextBufferController.js
+++ b/src/streaming/text/NotFragmentedTextBufferController.js
@@ -42,15 +42,15 @@ const BUFFER_CONTROLLER_TYPE = 'NotFragmentedTextBufferController';
 function NotFragmentedTextBufferController(config) {
 
     config = config || {};
-    let context = this.context;
-    let eventBus = EventBus(context).getInstance();
+    const context = this.context;
+    const eventBus = EventBus(context).getInstance();
     const textController = TextController(context).getInstance();
 
-    let errHandler = config.errHandler;
-    let streamId = config.streamId;
-    let type = config.type;
-    let mimeType = config.mimeType;
-    let streamProcessor = config.streamProcessor;
+    const errHandler = config.errHandler;
+    const streamInfo = config.streamInfo;
+    const type = config.type;
+    const mimeType = config.mimeType;
+    const fragmentModel = config.fragmentModel;
 
     let instance,
         isBufferingCompleted,
@@ -77,17 +77,14 @@ function NotFragmentedTextBufferController(config) {
         initCache = InitCache(context).getInstance();
     }
 
-    /**
-     * @param {MediaInfo }mediaInfo
-     * @memberof BufferController#
-     */
-    function createBuffer(mediaInfo) {
+    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, streamProcessor);
+                    textBuffer.initialize(mimeType, streamInfo, mediaInfoArr, fragmentModel);
                 }
                 initialized = true;
             }
@@ -121,10 +118,6 @@ function NotFragmentedTextBufferController(config) {
         return mediaSource;
     }
 
-    function getStreamProcessor() {
-        return streamProcessor;
-    }
-
     function getIsPruningInProgress() {
         return false;
     }
@@ -155,23 +148,23 @@ function NotFragmentedTextBufferController(config) {
     }
 
     function onDataUpdateCompleted(e) {
-        if (e.sender.getType() !== streamProcessor.getType() || e.error) return;
+        if (e.sender.getStreamId() !== streamInfo.id || e.sender.getType() !== type || e.error) return;
 
-        const streamId = e.sender.getStreamId();
         const currentRepresentation = e.sender.getCurrentRepresentation();
 
-        const chunk = initCache.extract(streamId, currentRepresentation ? currentRepresentation.id : null);
+        const chunk = initCache.extract(streamInfo.id, currentRepresentation ? currentRepresentation.id : null);
 
         if (!chunk) {
             eventBus.trigger(Events.TIMED_TEXT_REQUESTED, {
                 index: 0,
+                streamId: streamInfo.id,
                 sender: e.sender
             }); //TODO make index dynamic if referring to MP?
         }
     }
 
     function onInitFragmentLoaded(e) {
-        if (e.chunk.streamId !== streamId || e.chunk.mediaInfo.type !== type || (!e.chunk.bytes)) return;
+        if (e.chunk.streamId !== streamInfo.id || e.chunk.mediaInfo.type !== type || (!e.chunk.bytes)) return;
 
         initCache.save(e.chunk);
         buffer.append(e.chunk);
@@ -181,12 +174,14 @@ function NotFragmentedTextBufferController(config) {
         });
     }
 
-    function switchInitData(streamId, representationId) {
-        const chunk = initCache.extract(streamId, representationId);
+    function appendInitSegment(representationId) {
+        const chunk = initCache.extract(streamInfo.id, representationId);
 
         if (!chunk) {
+            console.log('trigger TIMED_TEXT_REQUESTED');
             eventBus.trigger(Events.TIMED_TEXT_REQUESTED, {
                 index: 0,
+                streamId: streamInfo.id,
                 sender: instance
             });
         }
@@ -207,7 +202,6 @@ function NotFragmentedTextBufferController(config) {
         initialize: initialize,
         createBuffer: createBuffer,
         getType: getType,
-        getStreamProcessor: getStreamProcessor,
         setSeekStartTime: setSeekStartTime,
         getBuffer: getBuffer,
         getBufferLevel: getBufferLevel,
@@ -216,7 +210,7 @@ function NotFragmentedTextBufferController(config) {
         getIsBufferingCompleted: getIsBufferingCompleted,
         getIsPruningInProgress: getIsPruningInProgress,
         dischargePreBuffer: dischargePreBuffer,
-        switchInitData: switchInitData,
+        appendInitSegment: appendInitSegment,
         getRangeAt: getRangeAt,
         reset: reset,
         updateTimestampOffset: updateTimestampOffset
diff --git a/src/streaming/text/TextBufferController.js b/src/streaming/text/TextBufferController.js
index 1bd7d6be61..084f1a9165 100644
--- a/src/streaming/text/TextBufferController.js
+++ b/src/streaming/text/TextBufferController.js
@@ -48,31 +48,29 @@ function TextBufferController(config) {
 
             // in this case, internal buffer ocntroller is a classical BufferController object
             _BufferControllerImpl = BufferController(context).create({
-                streamId: config.streamId,
+                streamInfo: config.streamInfo,
                 type: config.type,
-                dashMetrics: config.dashMetrics,
                 mediaPlayerModel: config.mediaPlayerModel,
                 manifestModel: config.manifestModel,
                 fragmentModel: config.fragmentModel,
                 errHandler: config.errHandler,
-                streamController: config.streamController,
                 mediaController: config.mediaController,
+                representationController: config.representationController,
                 adapter: config.adapter,
                 textController: config.textController,
                 abrController: config.abrController,
                 playbackController: config.playbackController,
-                streamProcessor: config.streamProcessor,
                 settings: config.settings
             });
         } else {
 
             // in this case, internal buffer controller is a not fragmented text controller object
             _BufferControllerImpl = NotFragmentedTextBufferController(context).create({
-                streamId: config.streamId,
+                streamInfo: config.streamInfo,
                 type: config.type,
                 mimeType: config.mimeType,
-                errHandler: config.errHandler,
-                streamProcessor: config.streamProcessor
+                fragmentModel: config.fragmentModel,
+                errHandler: config.errHandler
             });
         }
     }
@@ -85,13 +83,8 @@ function TextBufferController(config) {
         return _BufferControllerImpl.initialize(source, StreamProcessor);
     }
 
-    /**
-     * @param {MediaInfo }mediaInfo
-     * @returns {Object} SourceBuffer object
-     * @memberof BufferController#
-     */
-    function createBuffer(mediaInfo) {
-        return _BufferControllerImpl.createBuffer(mediaInfo);
+    function createBuffer(mediaInfoArr) {
+        return _BufferControllerImpl.createBuffer(mediaInfoArr);
     }
 
     function getType() {
@@ -114,10 +107,6 @@ function TextBufferController(config) {
         _BufferControllerImpl.setMediaSource(value);
     }
 
-    function getStreamProcessor() {
-        _BufferControllerImpl.getStreamProcessor();
-    }
-
     function setSeekStartTime(value) {
         _BufferControllerImpl.setSeekStartTime(value);
     }
@@ -134,8 +123,8 @@ function TextBufferController(config) {
         return _BufferControllerImpl.getIsBufferingCompleted();
     }
 
-    function switchInitData(streamId, representationId) {
-        _BufferControllerImpl.switchInitData(streamId, representationId);
+    function appendInitSegment(representationId) {
+        _BufferControllerImpl.appendInitSegment(representationId);
     }
 
     function getIsPruningInProgress() {
@@ -162,7 +151,6 @@ function TextBufferController(config) {
         initialize: initialize,
         createBuffer: createBuffer,
         getType: getType,
-        getStreamProcessor: getStreamProcessor,
         setSeekStartTime: setSeekStartTime,
         getBuffer: getBuffer,
         setBuffer: setBuffer,
@@ -172,7 +160,7 @@ function TextBufferController(config) {
         getIsBufferingCompleted: getIsBufferingCompleted,
         getIsPruningInProgress: getIsPruningInProgress,
         dischargePreBuffer: dischargePreBuffer,
-        switchInitData: switchInitData,
+        appendInitSegment: appendInitSegment,
         getRangeAt: getRangeAt,
         reset: reset,
         updateTimestampOffset: updateTimestampOffset
diff --git a/src/streaming/text/TextSourceBuffer.js b/src/streaming/text/TextSourceBuffer.js
index d89dffdf28..e6084d7ab3 100644
--- a/src/streaming/text/TextSourceBuffer.js
+++ b/src/streaming/text/TextSourceBuffer.js
@@ -98,7 +98,7 @@ function TextSourceBuffer() {
         parser = null;
     }
 
-    function initialize(mimeType, streamProcessor) {
+    function initialize(mimeType, streamInfo, mediaInfoArr, fragmentModel) {
         if (!embeddedInitialized) {
             initEmbedded();
         }
@@ -112,30 +112,29 @@ function TextSourceBuffer() {
             boxParser = BoxParser(context).getInstance();
         }
 
-        addMediaInfos(mimeType, streamProcessor);
+        addMediaInfos(mimeType, streamInfo, mediaInfoArr, fragmentModel);
     }
 
-    function addMediaInfos(mimeType, streamProcessor) {
+    function addMediaInfos(mimeType, streamInfo, mediaInfoArr, fragmentModel) {
         const isFragmented = !adapter.getIsTextTrack(mimeType);
-        if (streamProcessor) {
-            mediaInfos = mediaInfos.concat(streamProcessor.getMediaInfoArr());
-
-            if (isFragmented) {
-                fragmentedFragmentModel = streamProcessor.getFragmentModel();
-                instance.buffered = CustomTimeRanges(context).create();
-                fragmentedTracks = mediaController.getTracksFor(Constants.FRAGMENTED_TEXT, streamProcessor.getStreamInfo());
-                const currFragTrack = mediaController.getCurrentTrackFor(Constants.FRAGMENTED_TEXT, streamProcessor.getStreamInfo());
-                for (let i = 0; i < fragmentedTracks.length; i++) {
-                    if (fragmentedTracks[i] === currFragTrack) {
-                        setCurrentFragmentedTrackIdx(i);
-                        break;
-                    }
+
+        mediaInfos = mediaInfos.concat(mediaInfoArr);
+
+        if (isFragmented) {
+            fragmentedFragmentModel = fragmentModel;
+            instance.buffered = CustomTimeRanges(context).create();
+            fragmentedTracks = mediaController.getTracksFor(Constants.FRAGMENTED_TEXT, streamInfo);
+            const currFragTrack = mediaController.getCurrentTrackFor(Constants.FRAGMENTED_TEXT, streamInfo);
+            for (let i = 0; i < fragmentedTracks.length; i++) {
+                if (fragmentedTracks[i] === currFragTrack) {
+                    setCurrentFragmentedTrackIdx(i);
+                    break;
                 }
             }
+        }
 
-            for (let i = 0; i < mediaInfos.length; i++) {
-                createTextTrackFromMediaInfo(null, mediaInfos[i]);
-            }
+        for (let i = 0; i < mediaInfos.length; i++) {
+            createTextTrackFromMediaInfo(null, mediaInfos[i]);
         }
     }
 
diff --git a/test/unit/Streaming.StreamProcessor.js b/test/unit/Streaming.StreamProcessor.js
index 995bd448cd..d767d90cc2 100644
--- a/test/unit/Streaming.StreamProcessor.js
+++ b/test/unit/Streaming.StreamProcessor.js
@@ -24,52 +24,48 @@ const adapterMock = new AdapterMock();
 const eventBus = EventBus(context).getInstance();
 
 const streamInfo = {
-    streamId: 'streamId',
+    id: 'streamId',
     manifestInfo: {
         isDynamic: true
     }
 };
 
 describe('StreamProcessor', function () {
-    it('should return NaN when getIndexHandlerTime is called and streamProcessor is defined, without its attributes', function () {
-        const streamProcessor = StreamProcessor(context).create({});
-        const time = streamProcessor.getIndexHandlerTime();
+    describe('StreamProcessor not initialized', function () {
+        let streamProcessor = null;
 
-        expect(time).to.be.NaN; // jshint ignore:line
-    });
-
-    it('should not throw an error when setIndexHandlerTime is called and indexHandler is undefined', function () {
-        const streamProcessor = StreamProcessor(context).create({});
-
-        expect(streamProcessor.setIndexHandlerTime.bind(streamProcessor)).to.not.throw();
-    });
-
-    it('should return null when getInitRequest is called and indexHandler is undefined', function () {
-        const streamProcessor = StreamProcessor(context).create({});
-
-        const initRequest = streamProcessor.getInitRequest(0);
-
-        expect(initRequest).to.be.null;                // jshint ignore:line
-    });
+        beforeEach(function () {
+            streamProcessor = StreamProcessor(context).create({});
+        });
 
-    it('should throw an error when getInitRequest is called and streamProcessor is defined, but quality is not a number', function () {
-        const streamProcessor = StreamProcessor(context).create({});
+        afterEach(function () {
+            streamProcessor.reset();
+        });
 
-        expect(streamProcessor.getInitRequest.bind(streamProcessor, {})).to.be.throw(Constants.BAD_ARGUMENT_ERROR + ' : argument is not an integer');
-    });
+        it('getIndexHandlerTime should return NaN', function () {
+            const time = streamProcessor.getIndexHandlerTime();
+            expect(time).to.be.NaN; // jshint ignore:line
+        });
 
-    it('should return null when getFragmentRequest is called and without parameters', function () {
-        const streamProcessor = StreamProcessor(context).create({});
+        it('setIndexHandlerTime should not throw an error', function () {
+            expect(streamProcessor.setIndexHandlerTime.bind(streamProcessor)).to.not.throw();
+        });
 
-        const nextFragRequest = streamProcessor.getFragmentRequest();
+        it('getInitRequest should return null', function () {
+            const initRequest = streamProcessor.getInitRequest(0);
+            expect(initRequest).to.be.null; // jshint ignore:line
+        });
 
-        expect(nextFragRequest).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');
+        });
 
-    describe('representationController parameter is properly defined, without its attributes', () => {
-        const streamProcessor = StreamProcessor(context).create({});
+        it('getFragmentRequest should return null', function () {
+            const nextFragRequest = streamProcessor.getFragmentRequest();
+            expect(nextFragRequest).to.be.null; // jshint ignore:line
+        });
 
-        it('should throw an error when getRepresentationInfo is called and representationController parameter is defined, but quality is not a number', function () {
+        it('getRepresentationInfo should throw an error when quality is not a number', function () {
             expect(streamProcessor.getRepresentationInfo.bind(streamProcessor, {})).to.be.throw(Constants.BAD_ARGUMENT_ERROR + ' : argument is not an integer');
         });
     });
@@ -91,7 +87,7 @@ describe('StreamProcessor', function () {
         let dvrInfo = dashMetricsMock.getCurrentDVRInfo();
         expect(dvrInfo).to.be.null; // jshint ignore:line
 
-        eventBus.trigger(Events.BUFFER_LEVEL_UPDATED, { sender: { getStreamProcessor() { return streamProcessor;}}, bufferLevel: 50 });
+        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
diff --git a/test/unit/mocks/AdapterMock.js b/test/unit/mocks/AdapterMock.js
index 647e061b19..2caed88dc4 100644
--- a/test/unit/mocks/AdapterMock.js
+++ b/test/unit/mocks/AdapterMock.js
@@ -111,4 +111,4 @@ function AdapterMock () {
     };
 }
 
-export default AdapterMock;
\ No newline at end of file
+export default AdapterMock;
diff --git a/test/unit/mocks/StreamProcessorMock.js b/test/unit/mocks/StreamProcessorMock.js
index acb00f2470..c5f44a0d6d 100644
--- a/test/unit/mocks/StreamProcessorMock.js
+++ b/test/unit/mocks/StreamProcessorMock.js
@@ -113,7 +113,7 @@ function StreamProcessorMock (testType, streamInfo) {
         return this.bufferController.getIsBufferingCompleted();
     };
 
-    this.switchInitData = function () {};
+    this.appendInitSegment = function () {};
 
     this.reset = function () {};
 }
diff --git a/test/unit/streaming.Stream.js b/test/unit/streaming.Stream.js
index 97921f1b9d..c85010479e 100644
--- a/test/unit/streaming.Stream.js
+++ b/test/unit/streaming.Stream.js
@@ -48,25 +48,29 @@ describe('Stream', function () {
     const timelineConverter = objectsHelper.getDummyTimelineConverter();
     const streamInfo = {
         id: 'id',
-        index: 'index'
+        index: 'index',
+        manifestInfo: {
+            isDynamic: false
+        }
     };
     Events.extend(ProtectionEvents);
 
     describe('Well initialized', function () {
         beforeEach(function () {
-            stream = Stream(context).create({errHandler: errHandlerMock,
-                                             manifestModel: manifestModelMock,
-                                             adapter: adapterMock,
-                                             abrController: abrControllerMock,
-                                             manifestUpdater: manifestUpdaterMock,
-                                             playbackController: playbackControllerMock,
-                                             capabilities: capabilitiesMock,
-                                             mediaController: mediaControllerMock,
-                                             timelineConverter: timelineConverter,
-                                             dashMetrics: dashMetricsMock,
-                                             textController: textControllerMock,
-                                             videoModel: videoModelMock,
-                                             settings: settings});
+            stream = Stream(context).create({
+                errHandler: errHandlerMock,
+                manifestModel: manifestModelMock,
+                adapter: adapterMock,
+                abrController: abrControllerMock,
+                manifestUpdater: manifestUpdaterMock,
+                playbackController: playbackControllerMock,
+                capabilities: capabilitiesMock,
+                mediaController: mediaControllerMock,
+                timelineConverter: timelineConverter,
+                dashMetrics: dashMetricsMock,
+                textController: textControllerMock,
+                videoModel: videoModelMock,
+                settings: settings});
         });
 
         afterEach(function () {
@@ -76,14 +80,14 @@ describe('Stream', function () {
         it('should return false when isActive is called', () => {
             const isActive = stream.isActive();
 
-            expect(isActive).to.be.false;            // jshint ignore:line
+            expect(isActive).to.be.false; // jshint ignore:line
         });
 
         it('should return an empty array when getProcessors is called but streamProcessors attribute is an empty array', () => {
             const processors = stream.getProcessors();
 
             expect(processors).to.be.instanceOf(Array); // jshint ignore:line
-            expect(processors).to.be.empty;            // jshint ignore:line
+            expect(processors).to.be.empty; // jshint ignore:line
         });
 
         it('should trigger MANIFEST_ERROR_ID_NOSTREAMS_CODE error when setMediaSource is called but streamProcessors array is empty', () => {
@@ -100,51 +104,51 @@ describe('Stream', function () {
         it('should return an NaN when getStartTime is called but streamInfo attribute is null or undefined', () => {
             const startTime = stream.getStartTime();
 
-            expect(startTime).to.be.NaN;                // jshint ignore:line
+            expect(startTime).to.be.NaN; // jshint ignore:line
         });
 
         it('should return an NaN when getDuration is called but streamInfo attribute is null or undefined', () => {
             const duration = stream.getDuration();
 
-            expect(duration).to.be.NaN;                // jshint ignore:line
+            expect(duration).to.be.NaN; // jshint ignore:line
         });
 
         it('should return null false isMediaCodecCompatible is called but stream attribute is undefined', () => {
             const isCompatible = stream.isMediaCodecCompatible();
 
-            expect(isCompatible).to.be.false;                // jshint ignore:line
+            expect(isCompatible).to.be.false; // jshint ignore:line
         });
 
         it('should return false when isMediaCodecCompatible is called but stream attribute is an empty object', () => {
             const isCompatible = stream.isMediaCodecCompatible({});
 
-            expect(isCompatible).to.be.false;                // jshint ignore:line
+            expect(isCompatible).to.be.false; // jshint ignore:line
         });
 
         it('should return false when isMediaCodecCompatible is called with a correct stream attribute', () => {
             const isCompatible = stream.isMediaCodecCompatible(new StreamMock());
 
-            expect(isCompatible).to.be.false;                // jshint ignore:line
+            expect(isCompatible).to.be.false; // jshint ignore:line
         });
 
         it('should return null when isProtectionCompatible is called but stream attribute is undefined', () => {
             const isCompatible = stream.isProtectionCompatible();
 
-            expect(isCompatible).to.be.false;                // jshint ignore:line
+            expect(isCompatible).to.be.false; // jshint ignore:line
         });
 
         it('should return an empty array when getBitrateListFor is called but no stream processor is defined', () => {
             const bitrateList = stream.getBitrateListFor('');
 
             expect(bitrateList).to.be.instanceOf(Array); // jshint ignore:line
-            expect(bitrateList).to.be.empty;            // jshint ignore:line
+            expect(bitrateList).to.be.empty; // jshint ignore:line
         });
 
         it('should return an empty array when getBitrateListFor, for image type, is called but thumbnailController is not defined', () => {
             const bitrateList = stream.getBitrateListFor(Constants.IMAGE);
 
             expect(bitrateList).to.be.instanceOf(Array); // jshint ignore:line
-            expect(bitrateList).to.be.empty;            // jshint ignore:line
+            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', () => {
@@ -154,7 +158,7 @@ describe('Stream', function () {
 
             stream.updateData(streamInfo);
 
-            expect(spy.notCalled).to.be.true;                // jshint ignore:line
+            expect(spy.notCalled).to.be.true; // jshint ignore:line
 
             eventBus.off(Events.STREAM_INITIALIZED, spy);
         });
@@ -209,13 +213,13 @@ describe('Stream', function () {
 
             let isPreloaded = stream.getPreloaded();
 
-            expect(isPreloaded).to.be.false;                // jshint ignore:line
+            expect(isPreloaded).to.be.false; // jshint ignore:line
 
             stream.preload();
 
             isPreloaded = stream.getPreloaded();
 
-            expect(isPreloaded).to.be.true;                // jshint ignore:line
+            expect(isPreloaded).to.be.true; // jshint ignore:line
         });
 
         it('should return undefined when getThumbnailController is called without a call to initializeMediaForType', () => {
@@ -223,17 +227,17 @@ describe('Stream', function () {
 
             const thumbnailController = stream.getThumbnailController();
 
-            expect(thumbnailController).to.be.undefined;          // jshint ignore:line
+            expect(thumbnailController).to.be.undefined; // jshint ignore:line
         });
 
-        it('should returns an empty array when activate is called', function () {
-            stream.initialize(streamInfo, {});
+        // it('should returns an array of buffers when activate is called', function () {
+        //     stream.initialize(streamInfo, {});
 
-            const buffers = stream.activate();
+        //     const buffers = stream.activate();
 
-            expect(buffers).to.be.instanceOf(Object); // jshint ignore:line
-            expect(buffers).to.not.equal({});     // jshint ignore:line
-        });
+        //     expect(buffers).to.be.instanceOf(Object); // jshint ignore:line
+        //     expect(buffers).to.not.equal({}); // jshint ignore:line
+        // });
     });
 
     describe('Not well initialized with no config parameter', function () {
diff --git a/test/unit/streaming.controllers.BufferController.js b/test/unit/streaming.controllers.BufferController.js
index 3f4b64893b..7319ae603e 100644
--- a/test/unit/streaming.controllers.BufferController.js
+++ b/test/unit/streaming.controllers.BufferController.js
@@ -1,4 +1,3 @@
-import ObjectUtils from '../../src/streaming/utils/ObjectUtils';
 import BufferController from '../../src/streaming/controllers/BufferController';
 import EventBus from '../../src/core/EventBus';
 import Events from '../../src/core/events/Events';
@@ -7,7 +6,6 @@ import Settings from '../../src/core/Settings';
 
 import StreamControllerMock from './mocks/StreamControllerMock';
 import PlaybackControllerMock from './mocks/PlaybackControllerMock';
-import StreamProcessorMock from './mocks/StreamProcessorMock';
 import DashMetricsMock from './mocks/DashMetricsMock';
 import AdapterMock from './mocks/AdapterMock';
 import MediaSourceMock from './mocks/MediaSourceMock';
@@ -16,6 +14,7 @@ import ErrorHandlerMock from './mocks/ErrorHandlerMock';
 import MediaControllerMock from './mocks/MediaControllerMock';
 import AbrControllerMock from './mocks/AbrControllerMock';
 import TextControllerMock from './mocks/TextControllerMock';
+import RepresentationControllerMock from './mocks/RepresentationControllerMock';
 
 const chai = require('chai');
 const expect = chai.expect;
@@ -23,16 +22,16 @@ const expect = chai.expect;
 const context = {};
 const testType = 'video';
 const streamInfo = {
-    id: 'id'
+    id: 'streamId'
 };
 const eventBus = EventBus(context).getInstance();
-const objectUtils = ObjectUtils(context).getInstance();
+// const objectUtils = ObjectUtils(context).getInstance();
 const initCache = InitCache(context).getInstance();
 
 describe('BufferController', function () {
     // disable log
     let settings = Settings(context).getInstance();
-    const streamProcessor = new StreamProcessorMock(testType, streamInfo);
+    // const streamProcessor = new StreamProcessorMock(testType, streamInfo);
     const streamControllerMock = new StreamControllerMock();
     const adapterMock = new AdapterMock();
     const dashMetricsMock = new DashMetricsMock();
@@ -42,9 +41,10 @@ describe('BufferController', function () {
     const mediaControllerMock = new MediaControllerMock();
     const abrControllerMock = new AbrControllerMock();
     const textControllerMock = new TextControllerMock();
+    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 = {
@@ -53,7 +53,7 @@ describe('BufferController', function () {
 
         mediaSourceMock = new MediaSourceMock();
         bufferController = BufferController(context).create({
-            streamId: streamInfo.id,
+            streamInfo: streamInfo,
             type: testType,
             dashMetrics: dashMetricsMock,
             errHandler: errorHandlerMock,
@@ -62,7 +62,7 @@ describe('BufferController', function () {
             adapter: adapterMock,
             textController: textControllerMock,
             abrController: abrControllerMock,
-            streamProcessor: streamProcessor,
+            representationController: representationControllerMock,
             playbackController: playbackControllerMock,
             mediaPlayerModel: mediaPlayerModelMock,
             settings: settings
@@ -74,14 +74,12 @@ describe('BufferController', function () {
 
         bufferController.reset();
         bufferController = null;
-        streamProcessor.reset();
     });
 
     describe('Method initialize', function () {
         it('should initialize the controller', function () {
             expect(bufferController.getType()).to.equal(testType);
             bufferController.initialize({});
-
         });
     });
 
@@ -105,13 +103,6 @@ describe('BufferController', function () {
         });
     });
 
-    describe('Method getStreamProcessor', function () {
-        it('should return configured stream processor', function () {
-            const configuredSP = bufferController.getStreamProcessor();
-            expect(objectUtils.areEqual(configuredSP, streamProcessor)).to.be.true; // jshint ignore:line
-        });
-    });
-
     describe('Methods get/set Media Source', function () {
         it('should update media source', function () {
             bufferController.setMediaSource(mediaSourceMock);
@@ -119,7 +110,7 @@ describe('BufferController', function () {
         });
     });
 
-    describe('Method switchInitData', function () {
+    describe('Method appendInitSegment', function () {
         beforeEach(function () {
             bufferController.initialize(mediaSourceMock);
             bufferController.createBuffer(mediaInfo);
@@ -132,27 +123,20 @@ describe('BufferController', function () {
                 mediaInfo: {
                     type: 'video'
                 },
-                streamId: 'streamId',
+                streamId: streamInfo.id,
                 representationId: 'representationId'
             };
 
             initCache.save(chunk);
 
-            bufferController.switchInitData('streamId', 'representationId');
+            bufferController.appendInitSegment('representationId');
             expect(mediaSourceMock.buffers[0].chunk).to.equal(chunk.bytes);
         });
 
-        it('should trigger INIT_REQUESTED if no init data is cached', function (done) {
+        it('should return false if no init data is cached', function () {
             // reset cache
             initCache.reset();
-
-            const onInitRequest = function () {
-                eventBus.off(Events.INIT_REQUESTED, onInitRequest);
-                done();
-            };
-            eventBus.on(Events.INIT_REQUESTED, onInitRequest, this);
-
-            bufferController.switchInitData('streamId', 'representationId');
+            expect(bufferController.appendInitSegment('representationId')).to.equal(false);
         });
     });
 
@@ -203,7 +187,7 @@ describe('BufferController', function () {
         it('should append data to source buffer ', function (done) {
             const event = {
                 chunk: {
-                    streamId: 'id',
+                    streamId: streamInfo.id,
                     mediaInfo: {
                         type: 'video'
                     },
@@ -226,7 +210,7 @@ describe('BufferController', function () {
 
         it('should save init data into cache', function (done) {
             const chunk = {
-                streamId: 'id',
+                streamId: streamInfo.id,
                 mediaInfo: {
                     type: 'video'
                 },
@@ -288,7 +272,7 @@ describe('BufferController', function () {
         it('should append data to source buffer ', function (done) {
             const event = {
                 chunk: {
-                    streamId: 'id',
+                    streamId: streamInfo.id,
                     mediaInfo: {
                         type: 'video'
                     },
@@ -311,12 +295,12 @@ describe('BufferController', function () {
         it('should trigger VIDEO_CHUNK_RECEIVED if event is video', function (done) {
             const event = {
                 chunk: {
+                    streamId: streamInfo.id,
                     bytes: 'data',
                     quality: 2,
                     mediaInfo: {
                         type: 'video'
-                    },
-                    streamId: 'id'
+                    }
                 }
             };
             const onVideoChunk = function () {
@@ -334,6 +318,11 @@ describe('BufferController', function () {
         beforeEach(function () {
             bufferController.initialize(mediaSourceMock);
             bufferController.createBuffer(mediaInfo);
+            bufferController.getRepresentationInfo = function (quality) {
+                return {
+                    MSETimeOffset: quality
+                };
+            };
         });
 
         it('should not update buffer timestamp offset - wrong stream processor id', function () {
@@ -356,11 +345,11 @@ describe('BufferController', function () {
             expect(mediaSourceMock.buffers[0].timestampOffset).to.equal(1);
 
             const event = {
-                newQuality: 2,
-                mediaType: 'wrongMediaType',
                 streamInfo: {
-                    id: streamProcessor.getStreamInfo().id
-                }
+                    id: streamInfo.id
+                },
+                newQuality: 2,
+                mediaType: 'wrongMediaType'
             };
 
             // send event
@@ -369,13 +358,14 @@ describe('BufferController', function () {
         });
 
         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: streamProcessor.getStreamInfo().id
+                    id: streamInfo.id
                 }
             };
 
@@ -391,7 +381,7 @@ describe('BufferController', function () {
                 newQuality: 2,
                 mediaType: testType,
                 streamInfo: {
-                    id: streamProcessor.getStreamInfo().id
+                    id: streamInfo.id
                 }
             };
 
@@ -453,10 +443,6 @@ describe('BufferController', function () {
     describe('Method getBufferRange', function () {
         let buffer;
         beforeEach(function () {
-            let mediaInfo = {
-                codec: 'video/webm; codecs="vp8, vorbis"'
-            };
-
             bufferController.initialize(mediaSourceMock);
             bufferController.createBuffer(mediaInfo);
             const sink = bufferController.getBuffer();
diff --git a/test/unit/streaming.controllers.ScheduleController.js b/test/unit/streaming.controllers.ScheduleController.js
deleted file mode 100644
index 0b3c5cd420..0000000000
--- a/test/unit/streaming.controllers.ScheduleController.js
+++ /dev/null
@@ -1,106 +0,0 @@
-import ScheduleController from '../../src/streaming/controllers/ScheduleController';
-import Events from '../../src/core/events/Events';
-import EventBus from '../../src/core/EventBus';
-
-import PlaybackControllerMock from './mocks/PlaybackControllerMock';
-import StreamProcessorMock from './mocks/StreamProcessorMock';
-import MediaPlayerModelMock from './mocks/MediaPlayerModelMock';
-import AbrControllerMock from './mocks/AbrControllerMock';
-import StreamControllerMock from './mocks/StreamControllerMock';
-import DashMetricsMock from './mocks/DashMetricsMock';
-import AdapterMock from './mocks/AdapterMock';
-import Settings from '../../src/core/Settings';
-
-const expect = require('chai').expect;
-const context = {};
-
-const eventBus = EventBus(context).getInstance();
-
-const streamInfo = {
-    id: 'id'
-};
-const testType = 'video';
-
-describe('ScheduleController', function () {
-
-    let scheduleController;
-    let mediaPlayerModelMock;
-    let streamProcessorMock;
-    let adapterMock;
-    let playbackControllerMock;
-    let abrControllerMock;
-    let streamControllerMock;
-    let dashMetricsMock;
-    let metricsModelMock;
-    const settings = Settings(context).getInstance();
-
-    beforeEach(function () {
-        mediaPlayerModelMock = new MediaPlayerModelMock();
-        streamProcessorMock = new StreamProcessorMock(testType, streamInfo);
-        adapterMock = new AdapterMock();
-        playbackControllerMock = new PlaybackControllerMock();
-        abrControllerMock = new AbrControllerMock();
-        streamControllerMock = new StreamControllerMock();
-        dashMetricsMock = new DashMetricsMock();
-
-        scheduleController = ScheduleController(context).create({
-            type: testType,
-            mediaPlayerModel: mediaPlayerModelMock,
-            streamProcessor: streamProcessorMock,
-            adapter: adapterMock,
-            playbackController: playbackControllerMock,
-            abrController: abrControllerMock,
-            streamController: streamControllerMock,
-            dashMetrics: dashMetricsMock,
-            metricsModel: metricsModelMock,
-            settings: settings
-        });
-
-        scheduleController.initialize();
-    });
-
-    afterEach(function () {
-        settings.reset();
-        scheduleController.reset();
-        scheduleController = null;
-    });
-
-    it('should start on STREAM_INITIALIZED event', function (done) {
-
-        let onStreamInit = function () {
-            eventBus.off(Events.STREAM_INITIALIZED, onStreamInit);
-
-            expect(scheduleController.isStarted()).to.be.true; // jshint ignore:line
-            done();
-        };
-
-        eventBus.on(Events.STREAM_INITIALIZED, onStreamInit, this);
-
-        eventBus.trigger(Events.STREAM_INITIALIZED, {
-            streamInfo: streamInfo
-        });
-    });
-
-    it('should return 12 if streamProcessor is defined and current representation is video and videoTrackPresent is true', function () {
-        const bufferTarget = scheduleController.getBufferTarget();
-        expect(bufferTarget).to.be.equal(12); // jshint ignore:line
-    });
-
-    it('should stop is controller is started', function (done) {
-
-        let onStreamInit = function () {
-            eventBus.off(Events.STREAM_INITIALIZED, onStreamInit);
-
-            expect(scheduleController.isStarted()).to.be.true; // jshint ignore:line
-
-            scheduleController.stop();
-            expect(scheduleController.isStarted()).to.be.false; // jshint ignore:line
-            done();
-        };
-
-        eventBus.on(Events.STREAM_INITIALIZED, onStreamInit, this);
-        eventBus.trigger(Events.STREAM_INITIALIZED, {
-            streamInfo: streamInfo
-        });
-    });
-});
diff --git a/test/unit/streaming.controllers.StreamController.js b/test/unit/streaming.controllers.StreamController.js
index bb1f9ce36b..53137aba28 100644
--- a/test/unit/streaming.controllers.StreamController.js
+++ b/test/unit/streaming.controllers.StreamController.js
@@ -93,32 +93,22 @@ describe('StreamController', function () {
         it('should return an empty array when attempting to call getActiveStreamProcessors while no activeStream has been defined', function () {
             const activeStreamProcessorsArray = streamController.getActiveStreamProcessors();
 
-            expect(activeStreamProcessorsArray).to.be.instanceOf(Array);    // jshint ignore:line
-            expect(activeStreamProcessorsArray).to.be.empty;                // jshint ignore:line
+            expect(activeStreamProcessorsArray).to.be.instanceOf(Array); // jshint ignore:line
+            expect(activeStreamProcessorsArray).to.be.empty; // jshint ignore:line
         });
 
-        it('should return undefined when attempting to call isTrackTypePresent with no track type', function () {
-            const isAudioTrackPresent = streamController.isTrackTypePresent();
-
-            expect(isAudioTrackPresent).to.be.undefined;    // jshint ignore:line
+        it('should return false when attempting to call hasAudioTrack, while no activeStream has been defined', function () {
+            expect(streamController.hasAudioTrack()).to.be.false; // jshint ignore:line
         });
 
-        it('should return undefined when attempting to call isTrackTypePresent, for audio type, while no activeStream has been defined', function () {
-            const isAudioTrackPresent = streamController.isTrackTypePresent('audio');
-
-            expect(isAudioTrackPresent).to.be.undefined;    // jshint ignore:line
-        });
-
-        it('should return undefined when attempting to call isTrackTypePresent, for video type, while no activeStream has been defined', function () {
-            const isVideoTrackPresent = streamController.isTrackTypePresent('video');
-
-            expect(isVideoTrackPresent).to.be.undefined;    // jshint ignore:line
+        it('should return false when attempting to call hasVideoTrack, while no activeStream has been defined', function () {
+            expect(streamController.hasVideoTrack()).to.be.false; // jshint ignore:line
         });
 
         it('should return null when attempting to call getStreamForTime, and no stream has been composed', function () {
             const stream = streamController.getStreamForTime(10);
 
-            expect(stream).to.be.null;    // jshint ignore:line
+            expect(stream).to.be.null; // jshint ignore:line
         });
     });
 
diff --git a/test/unit/streaming.rules.scheduling.BufferLevelRule.js b/test/unit/streaming.rules.scheduling.BufferLevelRule.js
index 487be430e2..130a40c4bd 100644
--- a/test/unit/streaming.rules.scheduling.BufferLevelRule.js
+++ b/test/unit/streaming.rules.scheduling.BufferLevelRule.js
@@ -1,6 +1,5 @@
 import BufferLevelRule from '../../src/streaming/rules/scheduling/BufferLevelRule';
 
-import StreamProcessorMock from './mocks/StreamProcessorMock';
 import TextControllerMock from './mocks/TextControllerMock';
 import DashMetricsMock from './mocks/DashMetricsMock';
 import AbrControllerMock from './mocks/AbrControllerMock';
@@ -17,6 +16,7 @@ const bufferLevelRule = BufferLevelRule(context).create({
     dashMetrics: new DashMetricsMock(),
     abrController: new AbrControllerMock(),
     mediaPlayerModel: new MediaPlayerModelMock(),
+    hasVideoTrack: true,
     settings: settings
 });
 
@@ -26,51 +26,56 @@ describe('BufferLevelRule', function () {
     const streamInfo = {
         id: 'id'
     };
+    const representationInfo = {
+        mediaInfo: {
+            type: testAudioType,
+            streamInfo: streamInfo
+        },
+        fragmentDuration: 6
+    };
 
     afterEach(function () {
         settings.reset();
     });
 
-    it('should return NaN if streamProcessor is undefined', function () {
+    it('should return NaN if type is undefined', function () {
         const result = bufferLevelRule.getBufferTarget();
+        expect(result).to.be.NaN;  // jshint ignore:line
+    });
 
+    it('should return NaN if representationInfo is undefined', function () {
+        const result = bufferLevelRule.getBufferTarget(testAudioType);
         expect(result).to.be.NaN;  // jshint ignore:line
     });
 
     it('should return 0 if streamProcessor is defined and current representation is fragmentedText, and subtitles are disabled', function () {
-        const result = bufferLevelRule.getBufferTarget(new StreamProcessorMock(testFragmentedTextType, streamInfo));
-
+        const result = bufferLevelRule.getBufferTarget(testFragmentedTextType, representationInfo);
         expect(result).to.be.equal(0);  // jshint ignore:line
     });
 
     it('should return 6 (value returns by currentRepresentationInfo.fragmentDuration) if streamProcessor is defined and current representation is fragmentedText, and subtitles are enabled', function () {
         textControllerMock.enableText(true);
-        const result = bufferLevelRule.getBufferTarget(new StreamProcessorMock(testFragmentedTextType, streamInfo));
-
+        const result = bufferLevelRule.getBufferTarget(testFragmentedTextType, representationInfo);
         expect(result).to.be.equal(6);  // jshint ignore:line
     });
 
     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(new StreamProcessorMock(testAudioType, streamInfo), true);
-
+        const result = bufferLevelRule.getBufferTarget(testAudioType, representationInfo, true);
         expect(result).to.be.equal(15); // 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 () {
-        const result = bufferLevelRule.getBufferTarget(new StreamProcessorMock(testAudioType, streamInfo), false);
-
+        const result = bufferLevelRule.getBufferTarget(testAudioType, representationInfo, false);
         expect(result).to.be.equal(12); // jshint ignore:line
     });
 
-    it('should return true if streamProcessor is undefined', function () {
+    it('should return true if representationInfo is undefined', function () {
         const result = bufferLevelRule.execute();
-
         expect(result).to.be.true;  // jshint ignore:line
     });
 
-    it('should return false if streamProcessor is defined', function () {
-        const result = bufferLevelRule.execute(new StreamProcessorMock(testAudioType, streamInfo));
-
+    it('should return false if representationInfo is defined', function () {
+        const result = bufferLevelRule.execute(testAudioType, representationInfo);
         expect(result).to.be.false;  // jshint ignore:line
     });
-});
\ No newline at end of file
+});
diff --git a/test/unit/streaming.text.NotFragmentedTextBufferController.js b/test/unit/streaming.text.NotFragmentedTextBufferController.js
index 244ee688b5..ac95e1d5c4 100644
--- a/test/unit/streaming.text.NotFragmentedTextBufferController.js
+++ b/test/unit/streaming.text.NotFragmentedTextBufferController.js
@@ -26,12 +26,12 @@ describe('NotFragmentedTextBufferController', function () {
     let errorHandlerMock = new ErrorHandlerMock();
     let mediaSourceMock;
     let notFragmentedTextBufferController;
-    let mockMediaInfo = { isText: false, codec: '' };
+    let mockMediaInfoArr = [{ isText: false, codec: '' }];
 
     beforeEach(function () {
         mediaSourceMock = new MediaSourceMock();
         notFragmentedTextBufferController = NotFragmentedTextBufferController(context).create({
-            streamId: streamInfo.id,
+            streamInfo: streamInfo,
             type: testType,
             errHandler: errorHandlerMock,
             streamProcessor: streamProcessorMock
@@ -54,14 +54,14 @@ describe('NotFragmentedTextBufferController', function () {
     describe('when initialized', function () {
         describe('Method createSourceBuffer', function () {
             it('should create a sourceBuffer and initialize it', function () {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
                 const buffer = notFragmentedTextBufferController.getBuffer();
                 expect(buffer).to.exist; // jshint ignore:line
             });
 
             it('should notify error handler if an error occurs', function () {
                 mediaSourceMock.forceError = true;
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                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);
@@ -77,18 +77,12 @@ describe('NotFragmentedTextBufferController', function () {
 
         describe('Method getBuffer', function () {
             it('should return created buffer', function () {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
                 let buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
                 expect(objectUtils.areEqual(buffer, mediaSourceMock.buffers[0])).to.be.true; // jshint ignore:line
             });
         });
 
-        describe('Method getStreamProcessor', function () {
-            it('should return streamProcessor', function () {
-                let sp = notFragmentedTextBufferController.getStreamProcessor();
-                expect(objectUtils.areEqual(sp, streamProcessorMock)).to.be.true; // jshint ignore:line
-            });
-        });
 
         describe('Method getBufferLevel', function () {
             it('should return 0', function () {
@@ -106,7 +100,7 @@ describe('NotFragmentedTextBufferController', function () {
 
         describe('Method reset', function () {
             beforeEach(function () {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
             });
 
             it('should not abort buffer if there is an error', function () {
@@ -133,24 +127,24 @@ describe('NotFragmentedTextBufferController', function () {
             });
         });
 
-        describe('Method switchInitData', function () {
-            it('should not append init data to source buffer if data have already been cached', function () {
-                let chunk = {
-                    bytes: 'initData',
-                    quality: 2,
-                    mediaInfo: {
-                        type: testType
-                    },
-                    streamId: 'streamId',
-                    representationId: 'representationId'
-                };
-
-                initCache.save(chunk);
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
-                const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
-                notFragmentedTextBufferController.switchInitData(chunk.streamId, chunk.representationId);
-                expect(buffer.chunk).to.equal(null);
-            });
+        describe('Method appendInitSegment', function () {
+            // it('should not append init data to source buffer if data have already been cached', function () {
+            //     let chunk = {
+            //         bytes: 'initData',
+            //         quality: 2,
+            //         mediaInfo: {
+            //             type: testType
+            //         },
+            //         streamId: 'streamId',
+            //         representationId: 'representationId'
+            //     };
+
+            //     initCache.save(chunk);
+            //     notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
+            //     const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
+            //     notFragmentedTextBufferController.appendInitSegment(chunk.representationId);
+            //     expect(buffer.chunk).to.equal(null);
+            // });
 
             it('should trigger TIMED_TEXT_REQUESTED if no init data is cached', function (done) {
 
@@ -163,7 +157,7 @@ describe('NotFragmentedTextBufferController', function () {
                 };
                 eventBus.on(Events.TIMED_TEXT_REQUESTED, onInitRequest, this);
 
-                notFragmentedTextBufferController.switchInitData('streamId', 'representationId');
+                notFragmentedTextBufferController.appendInitSegment('representationId');
             });
         });
 
@@ -192,7 +186,7 @@ describe('NotFragmentedTextBufferController', function () {
 
             it('should not append data to buffer - wrong stream id', function (done) {
 
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
                 const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
 
                 let event = {
@@ -217,7 +211,7 @@ describe('NotFragmentedTextBufferController', function () {
 
             it('should not append data to buffer - no bytes', function (done) {
 
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
                 const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
 
                 let event = {
@@ -240,7 +234,7 @@ describe('NotFragmentedTextBufferController', function () {
             });
 
             it('should append data to buffer', function (done) {
-                notFragmentedTextBufferController.createBuffer(mockMediaInfo);
+                notFragmentedTextBufferController.createBuffer(mockMediaInfoArr);
                 const buffer = notFragmentedTextBufferController.getBuffer().getBuffer();
                 let event = {
                     chunk: {
diff --git a/test/unit/streaming.text.TextSourceBuffer.js b/test/unit/streaming.text.TextSourceBuffer.js
index db00b5122b..026f71473e 100644
--- a/test/unit/streaming.text.TextSourceBuffer.js
+++ b/test/unit/streaming.text.TextSourceBuffer.js
@@ -23,17 +23,9 @@ describe('TextSourceBuffer', function () {
                                 errHandler: errorHandlerMock,
                                 ttmlParser: ttmlParser});
 
-    it('call to addEmbeddedTrack function with no mediaInfo parameter should not throw an error', function () {
-        expect(textSourceBuffer.addEmbeddedTrack.bind(textSourceBuffer)).to.not.throw();
-    });
-
-    it('call to initialize function with no streamProcessor parameter should not throw an error', function () {
-        expect(textSourceBuffer.initialize.bind(textSourceBuffer, 'mimeType')).to.not.throw();
-    });
-
     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\''}});
         expect(errorHandlerMock.errorCode).to.equal(Errors.TIMED_TEXT_ERROR_ID_PARSE_CODE);
     });
-});
\ No newline at end of file
+});