From 39dc91e2057c98f49756a207da24600a7430628a Mon Sep 17 00:00:00 2001
From: Fritz Heiden <fritz.heiden@fokus.fraunhofer.de>
Date: Mon, 19 Oct 2020 15:46:25 +0200
Subject: [PATCH] Implemented on_receive mode for event registration

---
 .../listening-to-SCTE-EMSG-events.html        | 38 ++++++--
 src/core/EventBus.js                          | 26 +++--
 src/streaming/MediaPlayer.js                  |  7 +-
 src/streaming/MediaPlayerEvents.js            | 12 +++
 src/streaming/controllers/EventController.js  | 13 ++-
 .../controllers/PlaybackController.js         |  2 +-
 test/unit/core.EventBus.js                    | 18 +++-
 test/unit/mocks/PlaybackControllerMock.js     |  7 +-
 .../streaming.controllers.EventController.js  | 94 +++++++++++++++++++
 9 files changed, 189 insertions(+), 28 deletions(-)

diff --git a/samples/advanced/listening-to-SCTE-EMSG-events.html b/samples/advanced/listening-to-SCTE-EMSG-events.html
index f30d3e4522..18e486f091 100644
--- a/samples/advanced/listening-to-SCTE-EMSG-events.html
+++ b/samples/advanced/listening-to-SCTE-EMSG-events.html
@@ -13,35 +13,46 @@
         var player;
         const URL = "https://livesim.dashif.org/livesim/scte35_2/testpic_2s/Manifest.mpd";
         const SCHEMEIDURI = "urn:scte:scte35:2013:xml";
+        const EVENT_MODE_ON_START = dashjs.MediaPlayer.events.EVENT_MODE_ON_START;
+        const EVENT_MODE_ON_RECEIVE = dashjs.MediaPlayer.events.EVENT_MODE_ON_RECEIVE; 
 
         function init() {
             player = dashjs.MediaPlayer().create();
             player.updateSettings({ 'debug': { 'logLevel': dashjs.Debug.LOG_LEVEL_NONE }});
-            player.on(SCHEMEIDURI, showEvent);
+            player.on(SCHEMEIDURI, showStartEvent, null, { mode: EVENT_MODE_ON_START });
+            player.on(SCHEMEIDURI, showReceiveEvent, null, { mode: EVENT_MODE_ON_RECEIVE });
             player.initialize(document.querySelector("video"), URL, true);
         }
 
-        function showEvent(e) {
-            log("EVENT RECEIVED: " + e.type);
+        function showStartEvent(e) {
+            showEvent(e, "start");
+        }
+
+        function showReceiveEvent(e) {
+            showEvent(e, "receive");
+        }
+
+        function showEvent(e, output) {
             /* We double process in order to pretty-print. Only two levels of object properties are exposed. */
             for (var name in e) {
                 if (typeof e[name] != 'object') {
-                    log("    " + name + ": " + e[name]);
+                    log("    " + name + ": " + e[name], output);
                 }
             }
             for (name in e) {
                 if (typeof e[name] == 'object' ) {
-                    log("    " + name + ":");
+                    log("    " + name + ":", output);
                     for (name2 in e[name]) {
-                        log("        " + name2 + ": " + JSON.stringify(e[name][name2]));
+                        log("        " + name2 + ": " + JSON.stringify(e[name][name2]), output);
                     }
                 }
             }
+            log("", output);
         }
 
-        function log(msg) {
+        function log(msg, output) {
             msg = msg.length > 200 ? msg.substring(0, 200) + "..." : msg; /* to avoid repeated wrapping with large objects */
-            var tracePanel = document.getElementById("trace");
+            var tracePanel = document.getElementById(output);
             tracePanel.innerHTML += msg + "\n";
             tracePanel.scrollTop = tracePanel.scrollHeight;
             console.log(msg);
@@ -68,7 +79,16 @@
         <div>
             <video controls="true">
             </video>
-            <textarea id="trace" placeholder="Trapped events will be displayed here"></textarea>
+        </div>
+        <div style="display:flex">
+            <div>
+                <p>Received Events</p>
+                <textarea id="receive" placeholder="Trapped on_receive events will be displayed here"></textarea>
+            </div>
+            <div>
+                <p>Started Events</p>
+                <textarea id="start" placeholder="Trapped on_start events will be displayed here"></textarea>
+            </div>
         </div>
         <script>
             document.addEventListener("DOMContentLoaded", function () {
diff --git a/src/core/EventBus.js b/src/core/EventBus.js
index 099d56d50f..91af973466 100644
--- a/src/core/EventBus.js
+++ b/src/core/EventBus.js
@@ -29,6 +29,7 @@
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 import FactoryMaker from './FactoryMaker';
+import { EVENT_MODE_ON_START, EVENT_MODE_ON_RECEIVE } from '../streaming/MediaPlayerEvents';
 
 const EVENT_PRIORITY_LOW = 0;
 const EVENT_PRIORITY_HIGH = 5000;
@@ -37,7 +38,7 @@ function EventBus() {
 
     let handlers = {};
 
-    function on(type, listener, scope, priority = EVENT_PRIORITY_LOW) {
+    function on(type, listener, scope, options = {}) {
 
         if (!type) {
             throw new Error('event type cannot be null or undefined');
@@ -46,6 +47,9 @@ function EventBus() {
             throw new Error('listener must be a function: ' + listener);
         }
 
+        let priority = options.priority || EVENT_PRIORITY_LOW;
+        let mode = options.mode || EVENT_MODE_ON_START;
+
         if (getHandlerIdx(type, listener, scope) >= 0) return;
 
         handlers[type] = handlers[type] || [];
@@ -53,7 +57,8 @@ function EventBus() {
         const handler = {
             callback: listener,
             scope: scope,
-            priority: priority
+            priority: priority,
+            mode
         };
 
         if (scope && scope.getStreamId) {
@@ -85,20 +90,23 @@ function EventBus() {
     function trigger(type, payload = {}, filters = {}) {
         if (!type || !handlers[type]) return;
 
+        let isEventStart = true;
+        if (typeof filters.isEventStart === 'boolean') isEventStart = filters.isEventStart;
+
         payload = payload || {};
 
         if (payload.hasOwnProperty('type')) throw new Error('\'type\' is a reserved word for event dispatching');
 
         payload.type = type;
 
-        handlers[type] = handlers[type].filter((item) => item);
-        const eventHandlers = handlers[type].filter(item => {
-            if (filters.streamId && item.streamId && item.streamId !== filters.streamId) return false;
-            if (filters.mediaType && item.mediaType && item.mediaType !== filters.mediaType) return false;
-            return true;
-        });
+        const mode = isEventStart ? EVENT_MODE_ON_START : EVENT_MODE_ON_RECEIVE;
 
-        eventHandlers.forEach(handler => handler && handler.callback.call(handler.scope, payload));
+        handlers[type]
+            .filter((item) => item)
+            .filter(item => !(filters.streamId && item.streamId && item.streamId !== filters.streamId))
+            .filter(item => !(filters.mediaType && item.mediaType && item.mediaType !== filters.mediaType))
+            .filter(handler => handler.mode === mode)
+            .forEach(handler => handler && handler.callback.call(handler.scope, payload));
     }
 
     function getHandlerIdx(type, listener, scope) {
diff --git a/src/streaming/MediaPlayer.js b/src/streaming/MediaPlayer.js
index 49d0a61d47..e5d9c0112c 100644
--- a/src/streaming/MediaPlayer.js
+++ b/src/streaming/MediaPlayer.js
@@ -406,11 +406,12 @@ function MediaPlayer() {
      * @param {string} type - {@link MediaPlayerEvents}
      * @param {Function} listener - callback method when the event fires.
      * @param {Object} scope - context of the listener so it can be removed properly.
+     * @param {Object} options - object to define various options such as scope, priority and mode
      * @memberof module:MediaPlayer
      * @instance
      */
-    function on(type, listener, scope) {
-        eventBus.on(type, listener, scope);
+    function on(type, listener, scope, options) {
+        eventBus.on(type, listener, scope, options);
     }
 
     /**
@@ -1736,7 +1737,7 @@ function MediaPlayer() {
             manifestLoader.reset();
         };
 
-        eventBus.on(Events.INTERNAL_MANIFEST_LOADED, handler, self);
+        eventBus.on(Events.INTERNAL_MANIFEST_LOADED, handler, { scope: self });
 
         uriFragmentModel.initialize(url);
         manifestLoader.load(url);
diff --git a/src/streaming/MediaPlayerEvents.js b/src/streaming/MediaPlayerEvents.js
index ac8d58f558..5c135dd0e0 100644
--- a/src/streaming/MediaPlayerEvents.js
+++ b/src/streaming/MediaPlayerEvents.js
@@ -354,6 +354,18 @@ class MediaPlayerEvents extends EventsBase {
          * @event MediaPlayerEvents#GAP_CAUSED_SEEK_TO_PERIOD_END
          */
         this.GAP_CAUSED_SEEK_TO_PERIOD_END = 'gapCausedSeekToPeriodEnd';
+
+        /**
+         * Dash events are triggered at their respective start points on the timeline.
+         * @event MediaPlayerEvents#EVENT_MODE_ON_START
+         */
+        this.EVENT_MODE_ON_START = 'onStart';
+
+        /**
+         * Dash events are triggered as soon as they were parsed.
+         * @event MediaPlayerEvents#EVENT_MODE_ON_RECEIVE
+         */
+        this.EVENT_MODE_ON_RECEIVE = 'onReceive';
     }
 }
 
diff --git a/src/streaming/controllers/EventController.js b/src/streaming/controllers/EventController.js
index d58cec396e..d0381a2fef 100644
--- a/src/streaming/controllers/EventController.js
+++ b/src/streaming/controllers/EventController.js
@@ -121,6 +121,7 @@ function EventController() {
                     let event = values[i];
                     inlineEvents[event.id] = event;
                     logger.debug('Add inline event with id ' + event.id);
+                    _startEvent(event.id, event, values);
                 }
             }
             logger.debug(`Added ${values.length} inline events`);
@@ -145,6 +146,7 @@ function EventController() {
                     }
                     inbandEvents[event.id] = event;
                     logger.debug('Add inband event with id ' + event.id);
+                    _startEvent(event.id, event, values);
                 } else {
                     logger.debug('Repeated event with id ' + event.id);
                 }
@@ -207,6 +209,7 @@ function EventController() {
     function _onEventTimer() {
         try {
             if (!eventHandlingInProgress) {
+                eventHandlingInProgress = true;
                 const currentVideoTime = playbackController.getTime();
                 let presentationTimeThreshold = (currentVideoTime - lastEventTimerCall);
 
@@ -218,8 +221,8 @@ function EventController() {
                 _removeEvents();
 
                 lastEventTimerCall = currentVideoTime;
+                eventHandlingInProgress = false;
             }
-            eventHandlingInProgress = false;
         } catch (e) {
             eventHandlingInProgress = false;
         }
@@ -310,8 +313,10 @@ function EventController() {
     function _startEvent(eventId, event, events) {
         try {
             const currentVideoTime = playbackController.getTime();
+            const calculatedPresentationTimeInSeconds = event.calculatedPresentationTime / event.eventStream.timescale;
+            const isEventStart = Math.floor(currentVideoTime) === calculatedPresentationTimeInSeconds;
 
-            if (event.duration > 0) {
+            if (isEventStart && event.duration > 0) {
                 activeEvents[eventId] = event;
             }
 
@@ -325,10 +330,10 @@ function EventController() {
                 _sendCallbackRequest(event.messageData);
             } else {
                 logger.debug(`Starting event ${eventId} at ${currentVideoTime}`);
-                eventBus.trigger(event.eventStream.schemeIdUri, { event: event });
+                eventBus.trigger(event.eventStream.schemeIdUri, { event: event }, { isEventStart });
             }
 
-            delete events[eventId];
+            if (isEventStart) delete events[eventId];
         } catch (e) {
         }
     }
diff --git a/src/streaming/controllers/PlaybackController.js b/src/streaming/controllers/PlaybackController.js
index 420745e02e..02464126e3 100644
--- a/src/streaming/controllers/PlaybackController.js
+++ b/src/streaming/controllers/PlaybackController.js
@@ -93,7 +93,7 @@ function PlaybackController() {
         eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, onBufferLevelStateChanged, this);
         eventBus.on(Events.PLAYBACK_PROGRESS, onPlaybackProgression, this);
         eventBus.on(Events.PLAYBACK_TIME_UPDATED, onPlaybackProgression, this);
-        eventBus.on(Events.PLAYBACK_ENDED, onPlaybackEnded, this, EventBus.EVENT_PRIORITY_HIGH);
+        eventBus.on(Events.PLAYBACK_ENDED, onPlaybackEnded, this, { priority: EventBus.EVENT_PRIORITY_HIGH });
         eventBus.on(Events.STREAM_INITIALIZING, onStreamInitializing, this);
 
         if (playOnceInitialized) {
diff --git a/test/unit/core.EventBus.js b/test/unit/core.EventBus.js
index f1caaeab30..e78da60178 100644
--- a/test/unit/core.EventBus.js
+++ b/test/unit/core.EventBus.js
@@ -1,4 +1,5 @@
 import EventBus from '../../src/core/EventBus';
+import { EVENT_MODE_ON_START, EVENT_MODE_ON_RECEIVE } from '../../src/streaming/MediaPlayerEvents';
 
 const chai = require('chai');
 const sinon = require('sinon');
@@ -31,7 +32,7 @@ describe('EventBus', function () {
         const spy2 = sinon.spy();
 
         eventBus.on('EVENT_TEST', spy);
-        eventBus.on('EVENT_TEST', spy2, this, EventBus.EVENT_PRIORITY_HIGH);
+        eventBus.on('EVENT_TEST', spy2, this, { priority: EventBus.EVENT_PRIORITY_HIGH });
 
         eventBus.trigger('EVENT_TEST', {});
 
@@ -39,4 +40,19 @@ describe('EventBus', function () {
         assert.equal(spy2.calledOnce, true);
         assert.equal(spy2.calledBefore(spy), true);
     });
+
+    it('should respect mode parameter in the on function in order to trigger events according to isEventStart option in trigger function', function () {
+        const spy = sinon.spy();
+        const spy2 = sinon.spy();
+
+        eventBus.on('EVENT_TEST', spy, null, { mode: EVENT_MODE_ON_START });
+        eventBus.on('EVENT_TEST', spy2, null, { mode: EVENT_MODE_ON_RECEIVE });
+
+        eventBus.trigger('EVENT_TEST', {}, { isEventStart: false });
+        eventBus.trigger('EVENT_TEST', {}, { isEventStart: true });
+
+        assert.equal(spy.calledOnce, true);
+        assert.equal(spy2.calledOnce, true);
+        assert.equal(spy2.calledBefore(spy), true);
+    });
 });
diff --git a/test/unit/mocks/PlaybackControllerMock.js b/test/unit/mocks/PlaybackControllerMock.js
index 56cde44b55..8911f9669a 100644
--- a/test/unit/mocks/PlaybackControllerMock.js
+++ b/test/unit/mocks/PlaybackControllerMock.js
@@ -11,6 +11,7 @@ class PlaybackControllerMock {
         this.playing = false;
         this.seeking = false;
         this.isDynamic = false;
+        this.time = 0;
         this.streamController = new StreamControllerMock();
     }
 
@@ -60,7 +61,11 @@ class PlaybackControllerMock {
     }
 
     getTime() {
-        return null;
+        return this.time;
+    }
+
+    setTime(time) {
+        this.time = time;
     }
 
     getNormalizedTime() {
diff --git a/test/unit/streaming.controllers.EventController.js b/test/unit/streaming.controllers.EventController.js
index dcef9f7c26..ff985677a5 100644
--- a/test/unit/streaming.controllers.EventController.js
+++ b/test/unit/streaming.controllers.EventController.js
@@ -5,6 +5,8 @@ import Events from '../../src/core/events/Events';
 import PlaybackControllerMock from './mocks/PlaybackControllerMock';
 import ManifestUpdaterMock from './mocks/ManifestUpdaterMock';
 
+import { EVENT_MODE_ON_START, EVENT_MODE_ON_RECEIVE } from '../../src/streaming/MediaPlayerEvents';
+
 const expect = require('chai').expect;
 const context = {};
 const eventBus = EventBus(context).getInstance();
@@ -108,6 +110,98 @@ describe('EventController', function () {
             eventController.start();
         });
 
+        it('should trigger added inline events immediately with mode set to on_receive', function (done) {
+            let schemeIdUri = 'inlineEvent';
+            let events = [{
+                eventStream: {
+                    timescale: 1,
+                    schemeIdUri: schemeIdUri
+                },
+                id: 'event0',
+                calculatedPresentationTime: 20
+            }];
+
+            let onReceiveEvent = function (e) {
+                expect(e.event.id).to.equal('event0');
+                eventBus.off(schemeIdUri, onReceiveEvent);
+            };
+
+            eventBus.on(schemeIdUri, onReceiveEvent, { scope: this, mode: EVENT_MODE_ON_RECEIVE });
+
+            let onStartEvent = function (e) {
+                expect(e.event.id).to.equal('event0');
+                eventBus.off(schemeIdUri, onStartEvent);
+                expect(playbackControllerMock.getTime()).to.equal(20);
+                playbackControllerMock.setTime(0);
+                done();
+            };
+            eventBus.on(schemeIdUri, onStartEvent, { scope: this, mode: EVENT_MODE_ON_START });
+
+            eventController.addInlineEvents(events);
+            eventController.start();
+
+            playbackControllerMock.setTime(20);
+        });
+
+        it('should trigger added inline events immediately with mode set to on_receive', function (done) {
+            let schemeIdUri = 'inbandEvent';
+            let events = [{
+                eventStream: {
+                    timescale: 1,
+                    schemeIdUri: schemeIdUri
+                },
+                id: 'event0',
+                calculatedPresentationTime: 20
+            }];
+
+            let onReceiveEvent = function (e) {
+                expect(e.event.id).to.equal('event0');
+                eventBus.off(schemeIdUri, onReceiveEvent);
+            };
+
+            eventBus.on(schemeIdUri, onReceiveEvent, { scope: this, mode: EVENT_MODE_ON_RECEIVE });
+
+            let onStartEvent = function (e) {
+                expect(e.event.id).to.equal('event0');
+                eventBus.off(schemeIdUri, onStartEvent);
+                expect(playbackControllerMock.getTime()).to.equal(20);
+                playbackControllerMock.setTime(0);
+                done();
+            };
+            eventBus.on(schemeIdUri, onStartEvent, { scope: this, mode: EVENT_MODE_ON_START });
+
+            eventController.addInbandEvents(events);
+            eventController.start();
+
+            playbackControllerMock.setTime(20);
+        });
+
+        it('should respect provided timescale when triggering events', function (done) {
+            let schemeIdUri = 'inbandEvent';
+            let events = [{
+                eventStream: {
+                    timescale: 3,
+                    schemeIdUri: schemeIdUri
+                },
+                id: 'event0',
+                calculatedPresentationTime: 60
+            }];
+
+            let onStartEvent = function (e) {
+                expect(e.event.id).to.equal('event0');
+                eventBus.off(schemeIdUri, onStartEvent);
+                expect(playbackControllerMock.getTime()).to.equal(20);
+                playbackControllerMock.setTime(0);
+                done();
+            };
+            eventBus.on(schemeIdUri, onStartEvent, { scope: this, mode: EVENT_MODE_ON_START });
+
+            eventController.addInlineEvents(events);
+            eventController.start();
+
+            playbackControllerMock.setTime(20);
+        });
+
         it('should fire MANIFEST_VALIDITY_CHANGED events immediately', function (done) {
             const manifestValidityExpiredHandler = function (event) {
                 expect(event.id).to.equal(manifestExpiredEventStub.id);