eyevinn-channel-engine 3.2.5 → 3.3.0

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

@@ -47,6 +47,10 @@ class Session {
       video: null,
       audio: null
     }
+    this.prevMediaSeqOffset = {
+      video: null,
+      audio: null
+    }
     this.waitingForNextVod = false;
     this.leaderIsSettingNextVod = false;
     this.isSwitchingBackToV2L = false;
@@ -58,8 +62,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;
       }
@@ -195,7 +203,7 @@ class Session {
             this.diffCompensation -= DIFF_COMPENSATION;
           }
           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;
@@ -361,9 +369,13 @@ class Session {
       state = await this.getSessionState();
     }
 
-    const playheadState = await this._playheadState.getValues(["vodMediaSeqVideo"]);
-    if (opts && opts.targetMseq) {
+    const playheadState = {
+      vodMediaSeqVideo: null
+    }
+    if (opts && opts.targetMseq !== undefined) {
       playheadState.vodMediaSeqVideo = opts.targetMseq;
+    } else {
+      playheadState.vodMediaSeqVideo = await this._playheadState.get("vodMediaSeqVideo");
     }
 
     // NOTE: Assume that VOD cache was already cleared in 'getCurrentMediaAndDiscSequenceCount()'
@@ -372,7 +384,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);
@@ -424,10 +445,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,
         };
@@ -460,6 +489,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`);
@@ -473,8 +505,13 @@ 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.`);
@@ -488,10 +525,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);
@@ -566,6 +610,7 @@ class Session {
         } else {
           debug(`[${this._sessionId}]: We don't have any previously generated m3u8`);
         }
+        this.isAllowedToClearVodCache = true;
       }
     } else {
       sessionState.vodMediaSeqVideo = await this._sessionState.increment("vodMediaSeqVideo");
@@ -586,19 +631,25 @@ 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();
         this.isAllowedToClearVodCache = false;
       }
     } else {
@@ -606,7 +657,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;
   }
 
@@ -823,17 +877,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());
@@ -886,7 +944,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]);
@@ -956,6 +1015,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()}]`);
@@ -965,8 +1027,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;
           }
@@ -991,6 +1054,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();
@@ -1008,7 +1077,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]);
@@ -1044,10 +1114,10 @@ class Session {
             debug(`[${this._sessionId}]: ${newVod.getPlayheadPositions()}`);
             currentVod = newVod;
             debug(`[${this._sessionId}]: msequences=${currentVod.getLiveMediaSequencesCount()}`);
+            sessionState.mediaSeq = await this._sessionState.set("mediaSeq", sessionState.mediaSeq + endMseqValue);
+            sessionState.discSeq = await this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity);
             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.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 });
@@ -1065,6 +1135,8 @@ class Session {
             debug(`[${this._sessionId}]: not a leader so will go directly to state VOD_NEXT_INITIATING`);
             this.waitingForNextVod = true;
             sessionState.state = await this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING);
+            // Allow Leader|Follower to clear vodCache...
+            this.isAllowedToClearVodCache = true;
             sessionState.currentVod = await this._sessionState.getCurrentVod();
           }
         } catch (err) {
@@ -1081,6 +1153,8 @@ class Session {
             debug("No slate to load");
             throw err;
           }
+          // Allow Leader|Follower to clear vodCache...
+          this.isAllowedToClearVodCache = true;
         }
         break;
         case SessionState.VOD_RELOAD_INIT:
@@ -1094,7 +1168,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;
@@ -1113,15 +1192,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);
@@ -1153,6 +1231,8 @@ class Session {
             }
             this.waitingForNextVod = true;
           }
+          // Allow Leader|Follower to clear vodCache...
+          this.isAllowedToClearVodCache = true;
           return;
       default:
         throw new Error("Invalid state: " + sessionState.state);
@@ -1199,7 +1279,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());
@@ -1243,7 +1324,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());

package/engine/session_live.js

@@ -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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "3.2.5",
+  "version": "3.3.0",
   "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.0",
     "@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

@@ -413,12 +413,14 @@ describe("The initialize switching", () => {
       uri: "http://mock.mock.com/180000/seg12.ts",
     });
     expect(sessionCurrentSegs["1313000"][size - 1 - 2]).toEqual({
-      discontinuity: true,
-      cue: { in: true },
+      duration: 7.5,
+      timelinePosition: null,
+      uri: 'https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00008.ts',
+      cue: null
     });
     expect(sessionCurrentSegs["1313000"][size - 1]).toEqual({
       duration: 7.5,
-      uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00016.ts",
+      uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/600/600-00010.ts",
       timelinePosition: null,
       cue: null,
     });
@@ -469,7 +471,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 +747,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);
   });