Make imscJS style options generic

Author: ryanmccartney

src/core/Settings.js

@@ -513,12 +513,8 @@ import Events from './events/Events';
  * When true, only those captions where itts:forcedDisplay="true" will be displayed.
  * @property {boolean} [imsc.enableRollUp=true]
  * Enable/disable rollUp style display of IMSC captions.
- * @property {number} [imsc.options.sizeAdjust=1]
- * IMSC styling options - adjust text size, scales the text size and line padding 
- * @property {number} [imsc.options.lineHeightAdjust=1]
- * IMSC styling options - scales the line height 
- * @property {number} [imsc.options.backgroundOpacityScale=1]
- * IMSC styling options - scales the backgroundColor opacity 
+ * @property {number} [imsc.options]
+ * IMSC styling options - including; sizeAdjust, lineHeightAdjust, backgroundOpacityScale and fontFamily. See the renderHtml function of imscJS for full details 
  * @property {object} [webvtt.customRenderingEnabled=false]
  * Enables the custom rendering for WebVTT captions. For details refer to the "Subtitles and Captions" sample section of dash.js.
  * Custom WebVTT rendering requires the external library vtt.js that can be found in the contrib folder.
@@ -1015,11 +1011,7 @@ function Settings() {
                 imsc: {
                     displayForcedOnlyMode: false,
                     enableRollUp: true,
-                    options: {
-                        sizeAdjust: 1,
-                        lineHeightAdjust: 1,
-                        backgroundOpacityScale: 1
-                    },
+                    options: null,
                 },
                 webvtt: {
                     customRenderingEnabled: false

test/unit/streaming.controllers.CatchupController.js

@@ -0,0 +1,145 @@
+import CatchupController from '../../src/streaming/controllers/CatchupController';
+import Settings from '../../src/core/Settings';
+
+import VideoModelMock from './mocks/VideoModelMock';
+import DashMetricsMock from './mocks/DashMetricsMock';
+import StreamControllerMock from './mocks/StreamControllerMock';
+import StreamMock from './mocks/StreamMock';
+import MediaPlayerModelMock from './mocks/MediaPlayerModelMock';
+import PlaybackControllerMock from './mocks/PlaybackControllerMock';
+
+const expect = require('chai').expect;
+const context = {};
+
+describe('CatchupController', function () {
+
+    let catchupController,
+        streamMock,
+        videoModelMock,
+        dashMetricsMock,
+        streamControllerMock,
+        playbackControllerMock,
+        mediaPlayerModelMock,
+        settings;
+
+    beforeEach(function () {
+        settings = Settings(context).getInstance();
+        videoModelMock = new VideoModelMock();
+        dashMetricsMock = new DashMetricsMock();
+        streamMock = new StreamMock();
+        streamControllerMock = new StreamControllerMock();
+        playbackControllerMock = new PlaybackControllerMock();
+        mediaPlayerModelMock = new MediaPlayerModelMock();
+
+        catchupController = CatchupController(context).getInstance();
+        catchupController.setConfig({
+            videoModel: videoModelMock,
+            dashMetrics: dashMetricsMock,
+            streamController: streamControllerMock,
+            playbackController: playbackControllerMock,
+            mediaPlayerModel: mediaPlayerModelMock,
+            settings: settings,
+        });
+
+        streamControllerMock.initialize([streamMock]);
+    });
+
+    afterEach(function () {
+        catchupController.reset();
+        catchupController = null;
+    });
+
+    describe('Step Algorithm - _stepNeedToCatchUp', function () {
+
+        beforeEach(function () {
+            let streamInfo = {
+                manifestInfo: {
+                    isDynamic: true,
+                    availableFrom: new Date()
+                },
+                start: 10,
+                duration: 600
+            };
+
+            catchupController.initialize(streamInfo);
+            streamMock.initialize(streamInfo);
+        });
+
+        it('should true when current latency below the live delay', function () {
+            expect(catchupController._stepNeedToCatchUp.bind(catchupController)).not.to.throw();
+
+            settings.update({ streaming: 
+                { 
+                    delay: { liveDelay: 20 }, 
+                    catchup:{
+                        step: {
+                            start: { min: 1, max: 1 },
+                            stop: { min: 0.5, max: 0.5 }
+                        },
+                        mode: 'liveCatchupModeStep'
+                    } 
+                }
+            });
+
+            expect(catchupController._stepNeedToCatchUp()).to.be.true;
+        });
+
+        it('should true when current latency above the live delay', function () {
+            expect(catchupController._stepNeedToCatchUp.bind(catchupController)).not.to.throw();
+
+            settings.update({ streaming: 
+                { 
+                    delay: { liveDelay: 20 }, 
+                    catchup:{
+                        step: {
+                            start: { min: 1, max: 1 },
+                            stop: { min: 0.5, max: 0.5 }
+                        },
+                        mode: 'liveCatchupModeStep'
+                    } 
+                }
+            });
+
+            expect(catchupController._stepNeedToCatchUp()).to.be.true;
+        });
+
+        it('should true when current latency between start and stop min live delay', function () {
+            expect(catchupController._stepNeedToCatchUp.bind(catchupController)).not.to.throw();
+
+            settings.update({ streaming: 
+                { 
+                    delay: { liveDelay: 20 }, 
+                    catchup:{
+                        step: {
+                            start: { min: 1, max: 1 },
+                            stop: { min: 0.5, max: 0.5 }
+                        },
+                        mode: 'liveCatchupModeStep'
+                    } 
+                }
+            });
+
+            expect(catchupController._stepNeedToCatchUp()).to.be.true;
+        });
+
+        it('should true when current latency between start and stop max live delay', function () {
+            expect(catchupController._stepNeedToCatchUp.bind(catchupController)).not.to.throw();
+
+            settings.update({ streaming: 
+                { 
+                    delay: { liveDelay: 20 }, 
+                    catchup:{
+                        step: {
+                            start: { min: 1, max: 1 },
+                            stop: { min: 0.5, max: 0.5 }
+                        },
+                        mode: 'liveCatchupModeStep'
+                    } 
+                }
+            });
+
+            expect(catchupController._stepNeedToCatchUp()).to.be.true;
+        });
+         
+    })
+});