eyevinn-channel-engine 3.2.7 → 3.3.2

package/README.md

@@ -108,6 +108,7 @@ Available options when constructing the Channel Engine object are:
 - `maxTickInterval`: The maximum interval for playhead tick interval. Default is 10000 ms.
 - `cloudWatchMetrics`: Output CloudWatch JSON metrics on console log. Default is false.
 - `useDemuxedAudio`: Enable playing VODs with multiple audio tracks. Default is false.
+- `alwaysNewSegments`: Force all new HLS media sequences to always contain at least 1 new segment. Default is false.
 
 ## High Availability
 

package/engine/server.js

@@ -33,9 +33,13 @@ class ChannelEngine {
       this.adXchangeUri = options.adXchangeUri;
     }
     this.useDemuxedAudio = false;
-    if (options && options.useDemuxedAudio === true) {
+    if (options && options.useDemuxedAudio) {
       this.useDemuxedAudio = true;
     }
+    this.alwaysNewSegments = false;
+    if (options && options.alwaysNewSegments) {
+      this.alwaysNewSegments = true;
+    }
     if (options && options.defaultSlateUri) {
       this.defaultSlateUri = options.defaultSlateUri;
       this.slateRepetitions = options.slateRepetitions || 10;
@@ -228,6 +232,7 @@ class ChannelEngine {
         sessionId: channel.id,
         averageSegmentDuration: channel.options && channel.options.averageSegmentDuration ? channel.options.averageSegmentDuration : this.streamerOpts.defaultAverageSegmentDuration,
         useDemuxedAudio: options.useDemuxedAudio,
+        alwaysNewSegments: options.alwaysNewSegments,
         playheadDiffThreshold: channel.options && channel.options.playheadDiffThreshold ? channel.options.playheadDiffThreshold : this.streamerOpts.defaultPlayheadDiffThreshold,
         maxTickInterval: channel.options && channel.options.maxTickInterval ? channel.options.maxTickInterval : this.streamerOpts.defaultMaxTickInterval,
         targetDurationPadding: channel.options && channel.options.targetDurationPadding ? channel.options.targetDurationPadding : this.streamerOpts.targetDurationPadding,
@@ -444,6 +449,7 @@ class ChannelEngine {
       options.adXchangeUri = this.adXchangeUri;
       options.averageSegmentDuration = this.streamerOpts.defaultAverageSegmentDuration;
       options.useDemuxedAudio = this.useDemuxedAudio;
+      options.alwaysNewSegments = this.alwaysNewSegments;
       options.playheadDiffThreshold = this.streamerOpts.defaultPlayheadDiffThreshold;
       options.maxTickInterval = this.streamerOpts.defaultMaxTickInterval;
       options.targetDurationPadding = this.streamerOpts.targetDurationPadding;

package/engine/session.js

@@ -15,6 +15,7 @@ const ChaosMonkey = require('./chaos_monkey.js');
 const AVERAGE_SEGMENT_DURATION = 3000;
 const DEFAULT_PLAYHEAD_DIFF_THRESHOLD = 1000;
 const DEFAULT_MAX_TICK_INTERVAL = 10000;
+const DIFF_CORRECTION_RATE = 0.5;
 
 const timer = ms => new Promise(res => setTimeout(res, ms));
 
@@ -43,10 +44,15 @@ class Session {
     this.playheadDiffThreshold = DEFAULT_PLAYHEAD_DIFF_THRESHOLD;
     this.maxTickInterval = DEFAULT_MAX_TICK_INTERVAL;
     this.diffCompensation = null;
+    this.timePositionOffset = 0;
     this.prevVodMediaSeq = {
       video: null,
       audio: null
     }
+    this.prevMediaSeqOffset = {
+      video: null,
+      audio: null
+    }
     this.waitingForNextVod = false;
     this.leaderIsSettingNextVod = false;
     this.isSwitchingBackToV2L = false;
@@ -58,8 +64,12 @@ class Session {
       reloadBehind: null,
     }
     this.isAllowedToClearVodCache = null;
-
+    this.alwaysNewSegments = null;
     if (config) {
+      if (config.alwaysNewSegments) {
+        this.alwaysNewSegments = config.alwaysNewSegments;
+      }
+
       if (config.sessionId) {
         this._sessionId = config.sessionId;
       }
@@ -172,30 +182,45 @@ class Session {
           const reqTickInterval = playheadState.tickInterval;
           const timeSpentInIncrement = (tsIncrementEnd - tsIncrementBegin) / 1000;
           let tickInterval = reqTickInterval - timeSpentInIncrement;
+          // Apply HLSVod delta time for current msequence.
           const delta = await this._getCurrentDeltaTime();
           if (delta != 0) {
-            debug(`[${this._sessionId}]: Delta time is != 0 need will adjust ${delta}sec to tick interval`);
             tickInterval += delta;
+            debug(`[${this._sessionId}]: Delta time is != 0 need will adjust ${delta}sec to tick interval. tick=${tickInterval}`);
           }
           const position = (await this._getCurrentPlayheadPosition()) * 1000;
-          const timePosition = Date.now() - playheadState.playheadRef;
+          let timePosition = Date.now() - playheadState.playheadRef;
+          // Apply time position offset if set, only after external diff compensation has concluded.
+          if (this.timePositionOffset && this.diffCompensation <= 0 && this.alwaysNewSegments) {
+            timePosition -= this.timePositionOffset;
+            cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
+            { event: 'applyTimePositionOffset', channel: this._sessionId, offsetMs: this.timePositionOffset });
+          }
           const diff = position - timePosition;
           debug(`[${this._sessionId}]: ${timePosition}:${position}:${diff > 0 ? '+' : ''}${diff}ms`);
           cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
             { event: 'playheadDiff', channel: this._sessionId, diffMs: diff });
-          if (diff > this.playheadDiffThreshold) {
-            tickInterval += ((diff / 1000)) - (this.playheadDiffThreshold / 1000);
-          } else if (diff < -this.playheadDiffThreshold) {
-            tickInterval += ((diff / 1000)) + (this.playheadDiffThreshold / 1000);
-          }
+            if (this.alwaysNewSegments) {
+              // Apply Playhead diff compensation, only after external diff compensation has concluded.
+              if (this.diffCompensation <= 0) {
+                const timeToAdd = this._getPlayheadDiffCompesationValue(diff, this.playheadDiffThreshold);
+                tickInterval += timeToAdd;
+              }
+            } else {
+              // Apply Playhead diff compensation, always.
+              const timeToAdd = this._getPlayheadDiffCompesationValue(diff, this.playheadDiffThreshold);
+              tickInterval += timeToAdd;
+            }
+          // Apply external diff compensation if available.
           if (this.diffCompensation && this.diffCompensation > 0) {
-            const DIFF_COMPENSATION = 2000;
+            const DIFF_COMPENSATION = (reqTickInterval * DIFF_CORRECTION_RATE).toFixed(2) * 1000;
             debug(`[${this._sessionId}]: Adding ${DIFF_COMPENSATION}msec to tickInterval to compensate for schedule diff (current=${this.diffCompensation}msec)`);
             tickInterval += (DIFF_COMPENSATION / 1000);
             this.diffCompensation -= DIFF_COMPENSATION;
           }
+          // Keep tickInterval within upper and lower limits.
           debug(`[${this._sessionId}]: Requested tickInterval=${tickInterval}s (max=${this.maxTickInterval / 1000}s, diffThreshold=${this.playheadDiffThreshold}msec)`);
-          if (tickInterval <= 0) {
+          if (tickInterval <= 0.5) {
             tickInterval = 0.5;
           } else if (tickInterval > (this.maxTickInterval / 1000)) {
             tickInterval = this.maxTickInterval / 1000;
@@ -206,6 +231,13 @@ class Session {
           await this._playheadState.set("tickMs", (tsTickEnd - tsIncrementBegin));
           cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
             { event: 'tickInterval', channel: this._sessionId, tickTimeMs: (tsTickEnd - tsIncrementBegin) });
+          if (this.alwaysNewSegments) {
+            // Use dynamic base-tickInterval. Set according to duration of latest segment.
+            const lastDuration = await this._getLastDuration(manifest);
+            const nextTickInterval = lastDuration < 2 ? 2 : lastDuration;
+            await this._playheadState.set("tickInterval", nextTickInterval);
+            cloudWatchLog(!this.cloudWatchLogging, "engine-session", { event: "tickIntervalUpdated", channel: this._sessionId, tickIntervalSec: nextTickInterval });
+          }
         }
       } catch (err) {
         debug(`[${this._sessionId}]: Playhead consumer crashed (1)`);
@@ -376,7 +408,16 @@ class Session {
     if (currentVod) {
       try {
         const mediaSegments = currentVod.getLiveMediaSequenceSegments(playheadState.vodMediaSeqVideo);
-        debug(`[${this._sessionId}]: Requesting all segments from Media Sequence: ${playheadState.vodMediaSeqVideo}_${currentVod.getLiveMediaSequencesCount()}`);
+
+        let mediaSequenceValue = 0;
+        if (currentVod.sequenceAlwaysContainNewSegments) {
+          mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+          debug(`[${this._sessionId}]: {${mediaSequenceValue}}_{${currentVod.getLastSequenceMediaSequenceValue()}}`);
+        } else {
+          mediaSequenceValue = playheadState.vodMediaSeqVideo;
+        }
+
+        debug(`[${this._sessionId}]: Requesting all segments from Media Sequence: ${playheadState.vodMediaSeqVideo}(${mediaSequenceValue})_${currentVod.getLiveMediaSequencesCount()}`);
         return mediaSegments;
       } catch (err) {
         logerror(this._sessionId, err);
@@ -428,10 +469,18 @@ class Session {
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
+        let mediaSequenceValue = 0;
+        if (currentVod.sequenceAlwaysContainNewSegments) {
+          mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+          debug(`[${this._sessionId}]: seqIndex=${playheadState.vodMediaSeqVideo}_seqValue=${mediaSequenceValue}`)
+        } else {
+          mediaSequenceValue = playheadState.vodMediaSeqVideo;
+        }
         const discSeqCount = discSeqOffset + currentVod.discontinuities[playheadState.vodMediaSeqVideo];
-        debug(`[${this._sessionId}]: MediaSeq: (${(playheadState.mediaSeq + playheadState.vodMediaSeqVideo)}) and DiscSeq: (${discSeqCount}) requested `);
+        
+        debug(`[${this._sessionId}]: MediaSeq: (${playheadState.mediaSeq}+${mediaSequenceValue}=${(playheadState.mediaSeq + mediaSequenceValue)}) and DiscSeq: (${discSeqCount}) requested `);
         return {
-          'mediaSeq': (playheadState.mediaSeq + playheadState.vodMediaSeqVideo),
+          'mediaSeq': (playheadState.mediaSeq + mediaSequenceValue),
           'discSeq': discSeqCount,
           'vodMediaSeqVideo': playheadState.vodMediaSeqVideo,
         };
@@ -464,6 +513,9 @@ class Session {
     if (this.prevVodMediaSeq.video === null) {
       this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
     }
+    if (this.prevMediaSeqOffset.video === null) {
+      this.prevMediaSeqOffset.video = playheadState.mediaSeq;
+    }
 
     if (playheadState.vodMediaSeqVideo > sessionState.vodMediaSeqVideo) {
       debug(`[${this._sessionId}]: Recently Loaded Next Vod. PlayheadState not up-to-date. Return the last generated m3u8`);
@@ -477,13 +529,30 @@ class Session {
     }
 
     // Force reading up from store, but only once if the condition is right
-    if (playheadState.vodMediaSeqVideo < 2 || playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video) { 
+    if (playheadState.vodMediaSeqVideo < 2 || playheadState.mediaSeq !== this.prevMediaSeqOffset.video) { 
       debug(`[${this._sessionId}]: current[${playheadState.vodMediaSeqVideo}]_prev[${this.prevVodMediaSeq.video}]`);
+      debug(`[${this._sessionId}]: current-offset[${playheadState.mediaSeq}]_prev-offset[${this.prevMediaSeqOffset.video}]`);
+      // If true, then we have not updated the prev-values and not cleared the cache yet.
+      if (playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video || playheadState.mediaSeq !== this.prevMediaSeqOffset.video) {
+        this.isAllowedToClearVodCache = true;
+      }
       const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
       if (!isLeader && this.isAllowedToClearVodCache) {
         debug(`[${this._sessionId}]: Not a leader and first|second media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
         await this._sessionState.clearCurrentVodCache();
         this.isAllowedToClearVodCache = false;
+        const diffMs = await this._playheadState.get("diffCompensation");
+        if (diffMs) {
+          this.diffCompensation = diffMs;
+          debug(`[${this._sessionId}]: Setting diffCompensation->${this.diffCompensation}`);
+          if (this.diffCompensation) {
+            this.timePositionOffset = this.diffCompensation;
+            cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
+            { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+          } else{
+            this.timePositionOffset = 0;
+          }
+        }
       }
     } else {
       this.isAllowedToClearVodCache = true;
@@ -492,10 +561,17 @@ class Session {
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
+
+        if (currentVod.sequenceAlwaysContainNewSegments) {
+          const mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+          debug(`[${this._sessionId}]: {${mediaSequenceValue}}_{${currentVod.getLastSequenceMediaSequenceValue()}}`);
+        }
+
         debug(`[${this._sessionId}]: [${playheadState.vodMediaSeqVideo}]_[${currentVod.getLiveMediaSequencesCount()}]`);
         const m3u8 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, bw, playheadState.vodMediaSeqVideo, sessionState.discSeq, this.targetDurationPadding, this.forceTargetDuration);
         debug(`[${this._sessionId}]: [${playheadState.mediaSeq + playheadState.vodMediaSeqVideo}][${sessionState.discSeq}][+${this.targetDurationPadding || 0}] Current media manifest for ${bw} requested`);
         this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
+        this.prevMediaSeqOffset.video = playheadState.mediaSeq;
         return m3u8;
       } catch (err) {
         logerror(this._sessionId, err);
@@ -591,19 +667,37 @@ class Session {
     playheadState.mediaSeq = await this._playheadState.set("mediaSeq", sessionState.mediaSeq);
     playheadState.vodMediaSeqVideo = await this._playheadState.set("vodMediaSeqVideo", sessionState.vodMediaSeqVideo);
     playheadState.vodMediaSeqAudio = await this._playheadState.set("vodMediaSeqAudio", sessionState.vodMediaSeqAudio);
+
+    if (currentVod.sequenceAlwaysContainNewSegments) {
+      const mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+      debug(`[${this._sessionId}]: Session can now serve mseq={${playheadState.mediaSeq + mediaSequenceValue}}`);
+    }
+
     debug(`[${this._sessionId}]: INCREMENT (mseq=${playheadState.mediaSeq + playheadState.vodMediaSeqVideo}) vodMediaSeq=(${playheadState.vodMediaSeqVideo}_${playheadState.vodMediaSeqAudio} of ${currentVod.getLiveMediaSequencesCount()})`);
-    let m3u8 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, 180000, playheadState.vodMediaSeqVideo, sessionState.discSeq);
-    await this._playheadState.setLastM3u8(m3u8);
 
     // As a FOLLOWER, we might need to read up from shared store... 
-    if (playheadState.vodMediaSeqVideo < 2 || playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video) { 
+    if (playheadState.vodMediaSeqVideo < 2 || playheadState.mediaSeq !== this.prevMediaSeqOffset.video) { 
       debug(`[${this._sessionId}]: current[${playheadState.vodMediaSeqVideo}]_prev[${this.prevVodMediaSeq.video}]`);
-      if (playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video) {
-        this.alreadyCleredVodCache = false;
+      debug(`[${this._sessionId}]: current-offset[${playheadState.mediaSeq}]_prev-offset[${this.prevMediaSeqOffset.video}]`);
+      if (playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video || playheadState.mediaSeq !== this.prevMediaSeqOffset.video) {
+        this.isAllowedToClearVodCache = true;
       }
       if (!isLeader && this.isAllowedToClearVodCache) {
         debug(`[${this._sessionId}]: Not a leader and have just set 'playheadState.vodMediaSeqVideo' to 0|1. Invalidate cache to ensure having the correct VOD.`);
         await this._sessionState.clearCurrentVodCache();
+        currentVod = await this._sessionState.getCurrentVod();
+        const diffMs = await this._playheadState.get("diffCompensation");
+        if (diffMs) {
+          this.diffCompensation = diffMs;
+          debug(`[${this._sessionId}]: Setting diffCompensation->${this.diffCompensation}`);
+          if (this.diffCompensation) {
+            this.timePositionOffset = this.diffCompensation;
+            cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
+            { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+          } else{
+            this.timePositionOffset = 0;
+          }
+        }
         this.isAllowedToClearVodCache = false;
       }
     } else {
@@ -611,7 +705,10 @@ class Session {
     }
     // Update Value for Previous Sequence
     this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
+    this.prevMediaSeqOffset.video = playheadState.mediaSeq;
 
+    let m3u8 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, 180000, playheadState.vodMediaSeqVideo, sessionState.discSeq);
+    await this._playheadState.setLastM3u8(m3u8);
     return m3u8;
   }
 
@@ -828,17 +925,21 @@ class Session {
       const slateVod = await this._loadSlate(currentVod);
       debug(`[${this._sessionId}]: slate loaded`);
       const sessionState = await this._sessionState.getValues(["slateCount", "mediaSeq", "discSeq"]);
-      let length = 0;
+      let endValue = 0;
       let lastDiscontinuity = 0;
       if (currentVod) {
-        length = currentVod.getLiveMediaSequencesCount();
+        if (currentVod.sequenceAlwaysContainNewSegments) {
+          endValue = currentVod.getLastSequenceMediaSequenceValue();
+        } else {
+          endValue = currentVod.getLiveMediaSequencesCount();
+        }
         lastDiscontinuity = currentVod.getLastDiscontinuity();
       }
       await this._sessionState.set("vodMediaSeqVideo", 0);
       await this._sessionState.set("vodMediaSeqAudio", 0);
       await this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING);
       await this._sessionState.setCurrentVod(slateVod); 
-      await this._sessionState.set("mediaSeq", sessionState.mediaSeq + length);
+      await this._sessionState.set("mediaSeq", sessionState.mediaSeq + endValue);
       await this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity);
       await this._sessionState.set("slateCount", sessionState.slateCount + 1);
       await this._playheadState.set("playheadRef", Date.now());
@@ -891,7 +992,8 @@ class Session {
             let loadPromise;
             if (!vodResponse.type) {
               debug(`[${this._sessionId}]: got first VOD uri=${vodResponse.uri}:${vodResponse.offset || 0}`);
-              newVod = new HLSVod(vodResponse.uri, [], null, vodResponse.offset * 1000, m3u8Header(this._instanceId));
+              const hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments };
+              newVod = new HLSVod(vodResponse.uri, [], null, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
               if (vodResponse.timedMetadata) {
                 Object.keys(vodResponse.timedMetadata).map(k => {
                   newVod.addMetadata(k, vodResponse.timedMetadata[k]);
@@ -961,6 +1063,9 @@ class Session {
           if (this.prevVodMediaSeq.video === null) {
             this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
           }
+          if (this.prevMediaSeqOffset.video === null) {
+            this.prevMediaSeqOffset.video = sessionState.mediaSeq;
+          }
           // Clear Cache if prev count is HIGHER than current...
           if (sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video) {
             debug(`[${this._sessionId}]: state=VOD_PLAYING, current[${sessionState.vodMediaSeqVideo}], prev[${this.prevVodMediaSeq.video}], total[${currentVod.getLiveMediaSequencesCount()}]`);
@@ -970,8 +1075,9 @@ class Session {
           }
         } else {
           // Handle edge case where Leader loaded next vod but Follower remained in state=VOD_PLAYING
-          if (this.prevVodMediaSeq.video !== null & sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video) {
+          if (this.prevMediaSeqOffset.video !== null & sessionState.mediaSeq !== this.prevMediaSeqOffset.video) {
             debug(`[${this._sessionId}]: state=VOD_PLAYING, current[${sessionState.vodMediaSeqVideo}], prev[${this.prevVodMediaSeq.video}], total[${currentVod.getLiveMediaSequencesCount()}]`);
+            debug(`[${this._sessionId}]: mediaSeq offsets -> current[${sessionState.vodMediaSeqVideo}], prev[${this.prevVodMediaSeq.video}]`);
             // Allow Follower to clear VodCache...
             this.isAllowedToClearVodCache = true;
           }
@@ -996,6 +1102,12 @@ class Session {
               return;
             }
             const length = currentVod.getLiveMediaSequencesCount();
+            let endMseqValue;
+            if (currentVod.sequenceAlwaysContainNewSegments) {
+              endMseqValue = currentVod.getLastSequenceMediaSequenceValue();
+            } else {
+              endMseqValue = currentVod.getLiveMediaSequencesCount();
+            }
             const lastDiscontinuity = currentVod.getLastDiscontinuity();
             sessionState.state = await this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING);
             let vodPromise = this._getNextVod();
@@ -1013,7 +1125,8 @@ class Session {
             let loadPromise;
             if (!vodResponse.type) {
               debug(`[${this._sessionId}]: got next VOD uri=${vodResponse.uri}:${vodResponse.offset}`);
-              newVod = new HLSVod(vodResponse.uri, null, null, vodResponse.offset * 1000, m3u8Header(this._instanceId));
+              const hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments };
+              newVod = new HLSVod(vodResponse.uri, null, null, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
               if (vodResponse.timedMetadata) {
                 Object.keys(vodResponse.timedMetadata).map(k => {
                   newVod.addMetadata(k, vodResponse.timedMetadata[k]);
@@ -1030,6 +1143,13 @@ class Session {
               loadPromise = newVod.loadAfter(currentVod);
               if (vodResponse.diffMs) {
                 this.diffCompensation = vodResponse.diffMs;
+                if (this.diffCompensation) {
+                  this.timePositionOffset = this.diffCompensation;
+                  cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
+                  { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                } else{
+                  this.timePositionOffset = 0;
+                }
               }
             } else {
               loadPromise = new Promise((resolve, reject) => {
@@ -1051,13 +1171,15 @@ class Session {
             debug(`[${this._sessionId}]: msequences=${currentVod.getLiveMediaSequencesCount()}`);
             sessionState.vodMediaSeqVideo = await this._sessionState.set("vodMediaSeqVideo", 0);
             sessionState.vodMediaSeqAudio = await this._sessionState.set("vodMediaSeqAudio", 0);
-            sessionState.mediaSeq = await this._sessionState.set("mediaSeq", sessionState.mediaSeq + length);
+            sessionState.mediaSeq = await this._sessionState.set("mediaSeq", sessionState.mediaSeq + endMseqValue);
             sessionState.discSeq = await this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity);
             debug(`[${this._sessionId}]: new sequence data set in store [${sessionState.mediaSeq}][${sessionState.discSeq}]`);
             await this._sessionState.remove("nextVod");
             sessionState.currentVod = await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
             this.leaderIsSettingNextVod = false;
             await this._playheadState.set("playheadRef", Date.now());
+            await this._playheadState.set("diffCompensation", this.diffCompensation);
+            debug(`[${this._sessionId}]: sharing durrent vods diffCompensation=${this.diffCompensation}`);
             this.produceEvent({
               type: 'NOW_PLAYING',
               data: {
@@ -1073,6 +1195,18 @@ class Session {
             // Allow Leader|Follower to clear vodCache...
             this.isAllowedToClearVodCache = true;
             sessionState.currentVod = await this._sessionState.getCurrentVod();
+            const diffMs = await this._playheadState.get("diffCompensation");
+            if (diffMs) {
+              this.diffCompensation = diffMs;
+              debug(`[${this._sessionId}]: Setting diffCompensation=${this.diffCompensation}`);
+              if (this.diffCompensation) {
+                this.timePositionOffset = this.diffCompensation;
+                cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
+                { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+              } else{
+                this.timePositionOffset = 0;
+              }
+            }
           }
         } catch (err) {
           console.error(`[${this._sessionId}]: Failed to init next VOD`);
@@ -1103,7 +1237,12 @@ class Session {
               sessionState.state = await this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING);
 
               // 2) Set new 'offset' sequences, to carry on the continuity from session-live 
-              const mSeq = this.switchDataForSession.mediaSeq;
+              let mSeq = this.switchDataForSession.mediaSeq;
+              let currentVod = await this._sessionState.getCurrentVod();
+              if (currentVod.sequenceAlwaysContainNewSegments) {
+                // (!) will need to compensate if using this setting on HLSVod Object.
+                mSeq -= 1;
+              } 
               const dSeq = this.switchDataForSession.discSeq;
               const mSeqOffset = this.switchDataForSession.mediaSeqOffset;
               const reloadBehind = this.switchDataForSession.reloadBehind;
@@ -1122,15 +1261,14 @@ class Session {
               // 3) Set new media segments/currentVod, to carry on the continuity from session-live
               debug(`[${this._sessionId}]: LEADER: making changes to current VOD. I will also update currentVod in store.`);
               const playheadState = await this._playheadState.getValues(["vodMediaSeqVideo"]);
-              let currentVod = await this._sessionState.getCurrentVod();
-              let currentMseq = playheadState.vodMediaSeqVideo + mSeqOffset;
-              if (currentMseq > currentVod.getLiveMediaSequencesCount() - 1) {
-                currentMseq = currentVod.getLiveMediaSequencesCount() - 1;
+              let nextMseq = playheadState.vodMediaSeqVideo + 1;
+              if (nextMseq > currentVod.getLiveMediaSequencesCount() - 1) {
+                nextMseq = currentVod.getLiveMediaSequencesCount() - 1;
               }
 
               // TODO: Support reloading with audioSegments as well
 
-              await currentVod.reload(currentMseq, segments, null, reloadBehind);
+              await currentVod.reload(nextMseq, segments, null, reloadBehind);
               await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
               await this._sessionState.set("vodReloaded", 1);
               await this._sessionState.set("vodMediaSeqVideo", 0);
@@ -1140,6 +1278,9 @@ class Session {
               await this._playheadState.set("playheadRef", Date.now());
               debug(`[${this._sessionId}]: LEADER: Set new Reloaded VOD and vodMediaSeq counts in store.`);
               // 4) emit cloudwatch event object
+              debug(`[${this._sessionId}]: next VOD Reloaded (${currentVod.getDeltaTimes()})`);
+              debug(`[${this._sessionId}]: ${currentVod.getPlayheadPositions()}`);
+              debug(`[${this._sessionId}]: msequences=${currentVod.getLiveMediaSequencesCount()}`);
               cloudWatchLog(!this.cloudWatchLogging, "engine-session", { event: "switchback", channel: this._sessionId, reqTimeMs: Date.now() - startTS });
 
               return;
@@ -1210,7 +1351,8 @@ class Session {
 
         slateVod.load()
         .then(() => {
-          hlsVod = new HLSVod(this.slateUri, null, null, null, m3u8Header(this._instanceId));
+          const hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments };
+          hlsVod = new HLSVod(this.slateUri, null, null, null, m3u8Header(this._instanceId), hlsOpts);
           const timestamp = Date.now();
           hlsVod.addMetadata('id', `slate-${timestamp}`);
           hlsVod.addMetadata('start-date', new Date(timestamp).toISOString());
@@ -1254,7 +1396,8 @@ class Session {
 
         slateVod.load()
         .then(() => {
-          hlsVod = new HLSVod(nexVodUri, null, null, null, m3u8Header(this._instanceId));
+          const hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments };
+          hlsVod = new HLSVod(nexVodUri, null, null, null, m3u8Header(this._instanceId), hlsOpts);
           const timestamp = Date.now();
           hlsVod.addMetadata('id', `slate-${timestamp}`);
           hlsVod.addMetadata('start-date', new Date(timestamp).toISOString());
@@ -1364,6 +1507,47 @@ class Session {
     debug(`[${this._sessionId}]: Current playhead position (${sessionState.vodMediaSeqVideo}): ${playheadPositions[sessionState.vodMediaSeqVideo]}`);
     return playheadPositions[sessionState.vodMediaSeqVideo];
   }
+
+  _getLastDuration(manifest) {
+    return new Promise((resolve, reject) => {
+      try {
+        const parser = m3u8.createStream();
+        let manifestStream = new Readable();
+        manifestStream.push(manifest);
+        manifestStream.push(null);
+
+        manifestStream.pipe(parser);
+        parser.on('m3u', m3u => {
+          if (m3u.items.PlaylistItem.length > 0) {
+            const endIdx = m3u.items.PlaylistItem.length - 1;
+            const bottomDuration = m3u.items.PlaylistItem[endIdx].get("duration");
+            resolve(bottomDuration);
+          } else {
+            console.error("Empty media playlist");
+            console.error(manifest);
+            reject('Empty media playlist!')
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  _getPlayheadDiffCompesationValue(diffMs, thresholdMs) {
+    let compensationSec = 0;
+    if (diffMs > thresholdMs) {
+      compensationSec = (diffMs / 1000) - (thresholdMs / 1000);
+      debug(`[${this._sessionId}]: Playhead stepping msequences too early. Need to wait longer. adding ${compensationSec}s`);
+      return compensationSec;
+    } else if (diffMs < -thresholdMs) {
+      compensationSec = (diffMs / 1000) + (thresholdMs / 1000);
+      debug(`[${this._sessionId}]: Playhead stepping msequences too LATE. Need to fast-forward. adding ${compensationSec}s`);
+      return compensationSec;
+    } else {
+      return compensationSec;
+    }
+  }
 }
 
 module.exports = Session;

package/engine/session_live.js

@@ -267,7 +267,7 @@ class SessionLive {
       debug(`[${this.sessionId}]: 'vodSegments' not empty = Using 'transitSegs'`);
     }
 
-    debug(`[${this.sessionId}]: Setting CurrentMediaSequenceSegments. First seg is: [${this.vodSegments[allBws[0]][0].uri}]`);
+    debug(`[${this.sessionId}]: Setting CurrentMediaSequenceSegments. First seg is: [${this.vodSegments[Object.keys(this.vodSegments)[0]][0].uri}]`);
 
     const isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
     if (isLeader) {
@@ -501,7 +501,7 @@ class SessionLive {
           this.liveSegQueue[liveBw] = [];
         }
         // Do not push duplicates
-        const liveSegURIs = this.liveSegQueue[liveBw].filter(seg => seg.uri).map(seg => seg.uri);
+        const liveSegURIs = this.liveSegQueue[liveBw].filter((seg) => seg.uri).map((seg) => seg.uri);
         if (liveSegFromLeader.uri && liveSegURIs.includes(liveSegFromLeader.uri)) {
           debug(`[${this.sessionId}]: FOLLOWER: Found duplicate live segment. Skip push! (${liveBw})`);
         } else {
@@ -542,7 +542,7 @@ class SessionLive {
         this.blockGenerateManifest = false;
       }
 
-      let attempts = 5;
+      let attempts = 10;
       //  CHECK AGAIN CASE 1: Store Empty
       while (!leadersMediaSeqRaw && attempts > 0) {
         const segDur = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
@@ -565,7 +565,7 @@ class SessionLive {
         }
       }
 
-      attempts = 5;
+      attempts = 10;
       //  CHECK AGAIN CASE 2: Store Old
       while (leadersMediaSeqRaw <= this.lastRequestedMediaSeqRaw && attempts > 0) {
         const segDur = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
@@ -638,7 +638,7 @@ class SessionLive {
       if (manifestList.some((result) => result.status === "rejected")) {
         FETCH_ATTEMPTS--;
         debug(`[${this.sessionId}]: ALERT! Promises I: Failed, Rejection Found! Trying again in 1000ms...`);
-        await timer(1000)
+        await timer(1000);
         continue;
       }
 
@@ -654,8 +654,8 @@ class SessionLive {
         debug(`[${this.sessionId}]: Live Mseq counts=[${allMediaSeqCounts}]`);
         // Decrement fetch counter
         FETCH_ATTEMPTS--;
-        // Calculate retry delay time. Default=1500
-        let retryDelayMs = 1500;
+        // Calculate retry delay time. Default=1000
+        let retryDelayMs = 1000;
         if (Object.keys(this.liveSegQueue).length > 0) {
           const firstBw = Object.keys(this.liveSegQueue)[0];
           const lastIdx = this.liveSegQueue[firstBw].length - 1;
@@ -678,7 +678,7 @@ class SessionLive {
         let leadersFirstSeqCounts = await this.sessionLiveState.get("firstCounts");
         let tries = 20;
 
-        while (!isLeader && (!leadersFirstSeqCounts.liveSourceMseqCount && tries > 0) || leadersFirstSeqCounts.liveSourceMseqCount === 0) {
+        while ((!isLeader && !leadersFirstSeqCounts.liveSourceMseqCount && tries > 0) || leadersFirstSeqCounts.liveSourceMseqCount === 0) {
           debug(`[${this.sessionId}]: NEW FOLLOWER: Waiting for LEADER to add 'firstCounts' in store! Will look again after 1000ms (tries left=${tries})`);
           await timer(1000);
           leadersFirstSeqCounts = await this.sessionLiveState.get("firstCounts");
@@ -719,8 +719,9 @@ class SessionLive {
         }
         if (leadersFirstSeqCounts.mediaSeqCount !== this.mediaSeqCount) {
           this.mediaSeqCount = leadersFirstSeqCounts.mediaSeqCount;
-          debug(`[${this.sessionId}]: FOLLOWER transistioned with wrong V2L segments, updating counts to [${
-            this.mediaSeqCount}][${this.discSeqCount}], and reading 'transitSegs' from store`);
+          debug(
+            `[${this.sessionId}]: FOLLOWER transistioned with wrong V2L segments, updating counts to [${this.mediaSeqCount}][${this.discSeqCount}], and reading 'transitSegs' from store`
+          );
           const transitSegs = await this.sessionLiveState.get("transitSegs");
           if (!this._isEmpty(transitSegs)) {
             this.vodSegments = transitSegs;
@@ -1070,7 +1071,7 @@ class SessionLive {
         if (startIdx < 0) {
           this.restAmount = startIdx * -1;
           startIdx = 0;
-        } 
+        }
         if (mediaManifestUri) {
           // push segments
           this._addLiveSegmentsToQueue(startIdx, m3u.items.PlaylistItem, baseUrl, liveTargetBandwidth, isLeader);
@@ -1092,7 +1093,7 @@ class SessionLive {
    * @param {string} liveTargetBandwidth
    */
   _addLiveSegmentsToQueue(startIdx, playlistItems, baseUrl, liveTargetBandwidth, isLeader) {
-    const leaderOrFollower = isLeader ? "LEADER": "NEW FOLLOWER";
+    const leaderOrFollower = isLeader ? "LEADER" : "NEW FOLLOWER";
 
     for (let i = startIdx; i < playlistItems.length; i++) {
       let seg = {};
@@ -1162,7 +1163,7 @@ class SessionLive {
           seg["daterange"] = daterangeData;
         }
         // Push new Live Segments! But do not push duplicates
-        const liveSegURIs = this.liveSegQueue[liveTargetBandwidth].filter(seg => seg.uri).map(seg => seg.uri);
+        const liveSegURIs = this.liveSegQueue[liveTargetBandwidth].filter((seg) => seg.uri).map((seg) => seg.uri);
         if (seg.uri && liveSegURIs.includes(seg.uri)) {
           debug(`[${this.sessionId}]: ${leaderOrFollower}: Found duplicate live segment. Skip push! (${liveTargetBandwidth})`);
         } else {
@@ -1372,12 +1373,12 @@ class SessionLive {
     if (this._isEmpty(this.liveSegQueue)) {
       return null;
     }
-  
-    const bw0 = Object.keys(this.liveSegQueue)[0]; 
+
+    const bw0 = Object.keys(this.liveSegQueue)[0];
     if (this.liveSegQueue[bw0].length === 0) {
       return null;
     }
-    
+
     for (let i = 0; i < this.liveSegQueue[bw0].length; i++) {
       const segment = this.liveSegQueue[bw0][i];
       if (!segment.duration) {

package/engine/stream_switcher.js

@@ -482,7 +482,7 @@ class StreamSwitcher {
           if (mediaUri.match("^http")) {
             mediaURIs[bw] = mediaUri;
           } else {
-            mediaURIs[bw] = new URL(mediaUri, uri);
+            mediaURIs[bw] = new URL(mediaUri, uri).href;
           }
         }
 
@@ -575,7 +575,7 @@ class StreamSwitcher {
             if (playlistItem.properties.uri.match("^http")) {
               segmentUri = playlistItem.properties.uri;
             } else {
-              segmentUri = new URL(playlistItem.properties.uri, mediaURIs[bw]);
+              segmentUri = new URL(playlistItem.properties.uri, mediaURIs[bw]).href;
             }
             seg["duration"] = playlistItem.properties.duration;
             seg["uri"] = segmentUri;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "3.2.7",
+  "version": "3.3.2",
   "description": "OTT TV Channel Engine",
   "main": "index.js",
   "scripts": {
@@ -22,7 +22,7 @@
   "dependencies": {
     "@eyevinn/hls-repeat": "^0.1.1",
     "@eyevinn/hls-truncate": "^0.1.0",
-    "@eyevinn/hls-vodtolive": "^1.17.1",
+    "@eyevinn/hls-vodtolive": "^2.0.2",
     "@eyevinn/m3u8": "^0.4.1",
     "abort-controller": "^3.0.0",
     "debug": "^3.2.7",

package/server.js

@@ -100,4 +100,4 @@ const engineOptions = {
 
 const engine = new ChannelEngine(refAssetManager, engineOptions);
 engine.start();
-engine.listen(process.env.port || 8000);
+engine.listen(process.env.PORT || 8000);

package/spec/engine/init_switching_spec.js

@@ -414,11 +414,11 @@ describe("The initialize switching", () => {
     });
     expect(sessionCurrentSegs["1313000"][size - 1 - 2]).toEqual({
       discontinuity: true,
-      cue: { in: true },
+      cue: { in: true }
     });
     expect(sessionCurrentSegs["1313000"][size - 1]).toEqual({
-      duration: 7.5,
-      uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00016.ts",
+      duration: 11.25,
+      uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00015.ts",
       timelinePosition: null,
       cue: null,
     });
@@ -469,7 +469,7 @@ describe("The initialize switching", () => {
     const size = sessionCurrentSegs["1313000"].length;
     expect(sessionCurrentSegs["1313000"][0]).toEqual({
       duration: 7.5,
-      uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00011.ts",
+      uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00012.ts",
       timelinePosition: null,
       cue: null,
     });
@@ -745,41 +745,41 @@ describe("The initialize switching", () => {
     const borderSegment = newVodSegments["1313000"][6];
 
     const expectedLastVODSegItem = {
-      duration: 7.2,
-      uri: "https://maitv-vod.lab.eyevinn.technology/MORBIUS_Trailer_2020.mp4/1000/1000-00008.ts",
-      timelinePosition: null,
-      cue: null,
+      discontinuity: true,
+      daterange: null
     }
     const expectedFirstV2LSegItem = {
-      duration: 10.846444,
-      uri: "https://maitv-vod.lab.eyevinn.technology/VINN.mp4/600/600-00000.ts",
+      duration: 7.2,
       timelinePosition: null,
       cue: null,
+      uri: 'https://maitv-vod.lab.eyevinn.technology/VINN.mp4/600/600-00001.ts'
     }
     const expectedSecondVODSegItem = {
       duration: 7.5075,
-      uri: "https://maitv-vod.lab.eyevinn.technology/BECKY_Trailer_2020.mp4/600/600-00001.ts",
+      uri: "https://maitv-vod.lab.eyevinn.technology/BECKY_Trailer_2020.mp4/1000/1000-00001.ts",
       timelinePosition: null,
       cue: null,
     }
 
     expect(newVodSegments["1313000"][0]).toEqual(expectedLastVODSegItem);
     expect(newVodSegments["1313000"][1]).toEqual({
-      discontinuity: true,
-      daterange: null,
+      duration: 10.846444,
+      timelinePosition: null,
+      cue: null,
+      uri: 'https://maitv-vod.lab.eyevinn.technology/VINN.mp4/600/600-00000.ts'
     });
     expect(newVodSegments["1313000"][2]).toEqual(expectedFirstV2LSegItem);
-    expect(newVodSegments["1313000"][5]).toEqual({
-      discontinuity: true,
-      cue: { in: true },
-    });
+    // expect(newVodSegments["1313000"][5]).toEqual({
+    //   discontinuity: true,
+    //   cue: { in: true },
+    // });
     expect(borderSegment.daterange["planned-duration"]).toEqual(vodEventDurationMs2 / 1000);
     expect("start-date" in borderSegment.daterange).toBe(true);
     expect("id" in borderSegment.daterange).toBe(true);
-    expect(borderSegment.duration).toEqual(11.3077);
+    expect(borderSegment.duration).toEqual(11.3447);
     expect(borderSegment.timelinePosition).toEqual(null);
     expect(borderSegment.cue).toEqual(null);
-    expect(borderSegment.uri).toEqual("https://maitv-vod.lab.eyevinn.technology/BECKY_Trailer_2020.mp4/600/600-00000.ts");
+    expect(borderSegment.uri).toEqual("https://maitv-vod.lab.eyevinn.technology/BECKY_Trailer_2020.mp4/1000/1000-00000.ts");
     expect(newVodSegments["1313000"][7]).toEqual(expectedSecondVODSegItem);
   });