eyevinn-channel-engine 3.0.7 → 3.1.2

package/.github/workflows/publish.yml

@@ -2,7 +2,7 @@ name: Publish
   
 on:
   release:
-    types: [published]
+    types: [created]
 
 jobs:
   build:

package/engine/session.js

@@ -276,7 +276,8 @@ class Session {
         debug(`[${this._sessionId}]: FOLLOWER: WARNING! Attempts=0 - Risk of using wrong currentVod`);
       }
       if (!isLeader || vodReloaded) {
-        debug(`[${this._sessionId}]: FOLLOWER: leader is alive, and has presumably updated currentVod`);
+        debug(`[${this._sessionId}]: FOLLOWER: leader is alive, and has presumably updated currentVod. Clearing the cache now`);
+        await this._sessionState.clearCurrentVodCache();
         return;
       }
     }
@@ -394,9 +395,21 @@ class Session {
     if (!this._sessionState) {
       throw new Error('Session not ready');
     }
-    const sessionState = await this._sessionState.getValues(["discSeq"]);
+    const sessionState = await this._sessionState.getValues(["mediaSeq", "discSeq", "vodMediaSeqVideo"]);
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
-    if (playheadState.vodMediaSeqVideo === 0) {
+
+    /*
+      Since sessionState is always newer. If it is a smaller value, then this signals that
+      a new vod has been loaded but playheadState has yet to get the new mseq value in 'incrementAsync()'.
+      Without this, we risk returning an m3u8 with an old mseq on a new vod to the client.
+    */
+    if (playheadState.vodMediaSeqVideo > sessionState.vodMediaSeqVideo) {
+      playheadState.vodMediaSeqVideo = sessionState.vodMediaSeqVideo;
+      playheadState.mediaSeq = sessionState.mediaSeq;
+    }
+
+    if (playheadState.vodMediaSeqVideo === 0 || this.waitingForNextVod) { 
+      this.waitingForNextVod = false;
       const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
       if (!isLeader) {
         debug(`[${this._sessionId}]: Not a leader and first media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
@@ -406,6 +419,7 @@ class Session {
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
+        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`);
         return m3u8;
@@ -726,10 +740,11 @@ class Session {
         length = currentVod.getLiveMediaSequencesCount();
         lastDiscontinuity = currentVod.getLastDiscontinuity();
       }
+      await this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING);
+      await this._sessionState.setCurrentVod(slateVod); 
+
       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("discSeq", sessionState.discSeq + lastDiscontinuity);
       await this._sessionState.set("slateCount", sessionState.slateCount + 1);
@@ -813,10 +828,6 @@ class Session {
             debug(`[${this._sessionId}]: ${currentVod.getDeltaTimes()}`);
             debug(`[${this._sessionId}]: ${currentVod.getPlayheadPositions()}`);
             //debug(newVod);
-            sessionState.mediaSeq = await this._sessionState.set("mediaSeq", 0);
-            sessionState.discSeq = await this._sessionState.set("discSeq", 0);
-            sessionState.vodMediaSeqVideo = await this._sessionState.set("vodMediaSeqVideo", 0);
-            sessionState.vodMediaSeqAudio = await this._sessionState.set("vodMediaSeqAudio", 0);
             await this._playheadState.set("playheadRef", Date.now());
             this.produceEvent({
               type: 'NOW_PLAYING',
@@ -827,6 +838,10 @@ class Session {
             });
             sessionState.state = await this._sessionState.set("state", SessionState.VOD_PLAYING);
             sessionState.currentVod = await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
+            sessionState.mediaSeq = await this._sessionState.set("mediaSeq", 0);
+            sessionState.discSeq = await this._sessionState.set("discSeq", 0);
+            sessionState.vodMediaSeqVideo = await this._sessionState.set("vodMediaSeqVideo", 0);
+            sessionState.vodMediaSeqAudio = await this._sessionState.set("vodMediaSeqAudio", 0);
             await this._sessionState.remove("nextVod");
             return;
           } else {

package/engine/session_live.js

@@ -15,8 +15,10 @@ const daterangeAttribute = (key, attr) => {
     return key.toUpperCase() + "=" + `"${attr}"`;
   }
 };
+const TARGET_PLAYLIST_DURATION_SEC = 60;
 const RESET_DELAY = 5000;
 const FAIL_TIMEOUT = 4000;
+const DEFAULT_PLAYHEAD_INTERVAL_MS = 6 * 1000;
 const PlayheadState = Object.freeze({
   RUNNING: 1,
   STOPPED: 2,
@@ -30,14 +32,15 @@ class SessionLive {
     this.sessionLiveStateStore = sessionLiveStore.sessionLiveStateStore;
     this.instanceId = sessionLiveStore.instanceId;
     this.mediaSeqCount = 0;
+    this.prevMediaSeqCount = 0;
     this.discSeqCount = 0;
+    this.prevDiscSeqCount = 0;
     this.targetDuration = 0;
     this.masterManifestUri = null;
     this.vodSegments = {};
     this.mediaManifestURIs = {};
     this.liveSegQueue = {};
     this.lastRequestedMediaSeqRaw = null;
-    this.targetNumSeg = 0;
     this.liveSourceM3Us = {};
     this.playheadState = PlayheadState.IDLE;
     this.liveSegsForFollowers = {};
@@ -106,6 +109,7 @@ class SessionLive {
     }
 
     this.mediaSeqCount = 0;
+    this.prevMediaSeqCount = 0;
     this.discSeqCount = 0;
     this.targetDuration = 0;
     this.masterManifestUri = null;
@@ -113,7 +117,6 @@ class SessionLive {
     this.mediaManifestURIs = {};
     this.liveSegQueue = {};
     this.lastRequestedMediaSeqRaw = null;
-    this.targetNumSeg = 0;
     this.liveSourceM3Us = {};
     this.liveSegsForFollowers = {};
     this.timerCompensation = null;
@@ -145,13 +148,6 @@ class SessionLive {
           return;
         }
 
-        // Let the playhead move at an interval set according to live segment duration
-        let liveSegmentDurationMs = 6000;
-        let liveBws = Object.keys(this.liveSegQueue);
-        if (liveBws.length !== 0 && this.liveSegQueue[liveBws[0]].length !== 0 && this.liveSegQueue[liveBws[0]][0].duration) {
-          liveSegmentDurationMs = this.liveSegQueue[liveBws[0]][0].duration * 1000;
-        }
-
         // Fetch Live-Source Segments, and get ready for on-the-fly manifest generation
         // And also compensate for processing time
 
@@ -161,6 +157,13 @@ class SessionLive {
         const tsIncrementEnd = Date.now();
         this.waitForPlayhead = false;
 
+        // Let the playhead move at an interval set according to live segment duration
+        let liveSegmentDurationMs = DEFAULT_PLAYHEAD_INTERVAL_MS;
+        let liveBws = Object.keys(this.liveSegQueue);
+        if (liveBws.length !== 0 && this.liveSegQueue[liveBws[0]].length !== 0 && this.liveSegQueue[liveBws[0]][0].duration) {
+          liveSegmentDurationMs = this.liveSegQueue[liveBws[0]][0].duration * 1000;
+        }
+
         // Set the timer
         let timerValueMs = 0;
         if (this.timerCompensation) {
@@ -238,7 +241,6 @@ class SessionLive {
     }
     // Make it possible to add & share new segments
     this.allowedToSet = true;
-    let segCount = 0;
     const allBws = Object.keys(segments);
     for (let i = 0; i < allBws.length; i++) {
       const bw = allBws[i];
@@ -260,12 +262,6 @@ class SessionLive {
       }
     }
 
-    for (let segIdx = 0; segIdx < segments[allBws[0]].length; segIdx++) {
-      if (segments[allBws[0]][segIdx].uri) {
-        segCount++;
-      }
-    }
-    this.targetNumSeg = segCount;
     debug(`[${this.sessionId}]: Setting CurrentMediaSequenceSegments. First seg is: [${this.vodSegments[allBws[0]][0].uri}]`);
 
     const isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
@@ -303,7 +299,7 @@ class SessionLive {
       const leadersMediaSeqCount = liveCounts.mediaSeqCount;
       const leadersDiscSeqCount = liveCounts.discSeqCount;
       if (leadersMediaSeqCount !== null) {
-        this.mediaSeqCount = leadersMediaSeqCount - 1;
+        this.mediaSeqCount = leadersMediaSeqCount;
         debug(`[${this.sessionId}]: Setting mediaSeqCount to: [${this.mediaSeqCount}]`);
       }
       if (leadersDiscSeqCount !== null) {
@@ -342,7 +338,7 @@ class SessionLive {
       let bw = Object.keys(this.mediaManifestURIs)[i];
 
       const liveTargetBandwidth = this._findNearestBw(bw, Object.keys(this.mediaManifestURIs));
-      const vodTargetBandwidth = this._findNearestBw(bw, Object.keys(this.vodSegments));
+      const vodTargetBandwidth = this._getNearestBandwidth(bw, Object.keys(this.vodSegments));
 
       // Remove segments and disc-tag if they are on top
       if (this.vodSegments[vodTargetBandwidth].length > 0 && this.vodSegments[vodTargetBandwidth][0].discontinuity) {
@@ -481,68 +477,28 @@ class SessionLive {
   // FOLLOWER only function
   _updateLiveSegQueue() {
     if (Object.keys(this.liveSegsForFollowers).length === 0) {
-      debug(`[${this.sessionId}]: Error No Segments found at all.`);
+      debug(`[${this.sessionId}]: FOLLOWER: Error No Segments found at all.`);
     }
-    const vodBws = Object.keys(this.vodSegments);
     const liveBws = Object.keys(this.liveSegsForFollowers);
     const size = this.liveSegsForFollowers[liveBws[0]].length;
 
-    let newSegCount = 0;
-    this.liveSegsForFollowers[liveBws[0]].map((seg) => {
-      if (seg.uri) {
-        newSegCount++;
-      }
-    });
-
-    debug(`[${this.sessionId}]: FOLLOWER: liveSegsForFollowers Bws=${Object.keys(this.liveSegsForFollowers)}_newSegCount=${newSegCount} `);
-    // Remove transitional segs & add live source segs collected from store
-    for (let k = 0; k < newSegCount; k++) {
-      let incrementDiscSeqCount = false;
-      // Shift the top vod segment on all variants
-      for (let i = 0; i < vodBws.length; i++) {
-        let seg = this.vodSegments[vodBws[i]].shift();
-        if (seg && seg.discontinuity) {
-          incrementDiscSeqCount = true;
-          this.vodSegments[vodBws[i]].shift();
-        }
-      }
-      if (incrementDiscSeqCount) {
-        this.discSeqCount++;
-      }
-    }
-    // Push to bottom, new live source segment on all variants
+    // Push the New Live Segments to All Variants
     for (let segIdx = 0; segIdx < size; segIdx++) {
-      let incrementDiscSeqCount = false;
-      liveBws.forEach((bw) => {
-        let liveSegFromLeader = this.liveSegsForFollowers[bw][segIdx];
-        if (!this.liveSegQueue[bw]) {
-          this.liveSegQueue[bw] = [];
+      for (let i = 0; i < liveBws.length; i++) {
+        const liveBw = liveBws[i];
+        const liveSegFromLeader = this.liveSegsForFollowers[liveBw][segIdx];
+        if (!this.liveSegQueue[liveBw]) {
+          this.liveSegQueue[liveBw] = [];
         }
-        this.liveSegQueue[bw].push(liveSegFromLeader);
-
-        let segCount = 0;
-        this.liveSegQueue[bw].map((seg) => {
-          if (seg.uri) {
-            segCount++;
-          }
-        });
-        if (segCount > this.targetNumSeg) {
-          let seg = this.liveSegQueue[bw].shift();
-          if (seg && seg.discontinuity) {
-            incrementDiscSeqCount = true;
-            seg = this.liveSegQueue[bw].shift();
-          }
-        }
-        debug(`[${this.sessionId}]: Pushed segment (${liveSegFromLeader.uri ? liveSegFromLeader.uri : "Disc-tag"}) to 'liveSegQueue'`);
-      });
-      if (incrementDiscSeqCount) {
-        this.discSeqCount++;
+        this.liveSegQueue[liveBw].push(liveSegFromLeader);
+        debug(`[${this.sessionId}]: FOLLOWER: Pushed segment (${liveSegFromLeader.uri ? liveSegFromLeader.uri : "Disc-tag"}) to 'liveSegQueue' (${liveBw})`);
       }
     }
-    let prevVal = this.mediaSeqCount;
-    this.mediaSeqCount += newSegCount;
-    debug(`[${this.sessionId}]: Incrementing Mseq Count from [${prevVal}] -> [${this.mediaSeqCount}]`);
-    debug(`[${this.sessionId}]: Finished updating all Follower's Counts and Segment Queues!`);
+    // Remove older segments and update counts
+    const newTotalDuration = this._incrementAndShift("FOLLOWER");
+    if (newTotalDuration) {
+      debug(`[${this.sessionId}]: FOLLOWER: New Adjusted Playlist Duration=${newTotalDuration}s`);
+    }
   }
 
   /**
@@ -681,12 +637,13 @@ class SessionLive {
         if (Object.keys(this.liveSegQueue).length > 0) {
           const firstBw = Object.keys(this.liveSegQueue)[0];
           const lastIdx = this.liveSegQueue[firstBw].length - 1;
-          retryDelayMs = this.liveSegQueue[firstBw][lastIdx].duration * 1000 * 0.25;
+          if (this.liveSegQueue[firstBw][lastIdx].duration) {
+            retryDelayMs = this.liveSegQueue[firstBw][lastIdx].duration * 1000 * 0.25;
+          }
         }
         // Wait a little before trying again
         debug(`[${this.sessionId}]: ALERT! Live Source Data NOT in sync! Will try again after ${retryDelayMs}ms`);
         await timer(retryDelayMs);
-        this.timerCompensation = false;
         continue;
       }
 
@@ -718,24 +675,17 @@ class SessionLive {
 
         // Respawners never do this, only starter followers.
         // Edge Case: FOLLOWER transitioned from session with different segments from LEADER
-        if (leadersFirstSeqCounts.mediaSeqCount - 1 !== this.mediaSeqCount) {
-          this.mediaSeqCount = leadersFirstSeqCounts.mediaSeqCount - 1;
+        const leaderStartedOnCount = leadersFirstSeqCounts.mediaSeqCount;
+        if (leaderStartedOnCount !== this.mediaSeqCount) {
+          this.mediaSeqCount = leaderStartedOnCount;
           const transitSegs = await this.sessionLiveState.get("transitSegs");
           if (!this._isEmpty(transitSegs)) {
             this.vodSegments = transitSegs;
-            let discTagCount = 0;
-            const allBws = Object.keys(this.vodSegments);
-            for (let segIdx = 0; segIdx < this.vodSegments[allBws[0]].length; segIdx++) {
-              if (this.vodSegments[allBws[0]][segIdx].discontinuity) {
-                discTagCount++;
-              }
-            }
-            this.targetNumSeg = this.vodSegments[allBws[0]].length - (discTagCount - 1);
           }
         }
 
         // Prepare to load segments...
-        debug(`[${this.instanceId}]: Newest mseq from LIVE=${allMediaSeqCounts[0]} First mseq in store=${leadersFirstSeqCounts.liveSourceMseqCount}`);
+        debug(`[${this.instanceId}][${this.sessionId}]: Newest mseq from LIVE=${allMediaSeqCounts[0]} First mseq in store=${leadersFirstSeqCounts.liveSourceMseqCount}`);
         if (allMediaSeqCounts[0] === leadersFirstSeqCounts.liveSourceMseqCount) {
           this.pushAmount = 1; // Follower from start
         } else {
@@ -746,14 +696,6 @@ class SessionLive {
           //debug(`[${this.sessionId}]: NEW FOLLOWER: I tried to get 'transitSegs'. This is what I found ${JSON.stringify(transitSegs)}`);
           if (!this._isEmpty(transitSegs)) {
             this.vodSegments = transitSegs;
-            let discTagCount = 0;
-            const allBws = Object.keys(this.vodSegments);
-            for (let segIdx = 0; segIdx < this.vodSegments[allBws[0]].length; segIdx++) {
-              if (this.vodSegments[allBws[0]][segIdx].discontinuity) {
-                discTagCount++;
-              }
-            }
-            this.targetNumSeg = this.vodSegments[allBws[0]].length - (discTagCount - 1);
           }
         }
         debug(`[${this.sessionId}]: ...pushAmount=${this.pushAmount}`);
@@ -805,34 +747,35 @@ class SessionLive {
       let pushPromises = [];
       for (let i = 0; i < Object.keys(this.mediaManifestURIs).length; i++) {
         let bw = Object.keys(this.mediaManifestURIs)[i];
+        // will add new segments to live seg queue
         pushPromises.push(this._parseMediaManifest(this.liveSourceM3Us[bw].M3U, this.mediaManifestURIs[bw], bw));
         debug(`[${this.sessionId}]: Pushed pushPromise for bw=${bw}`);
       }
       // Segment Pushing
       debug(`[${this.sessionId}]: Executing Promises II: Segment Pushing`);
-      let results = await allSettled(pushPromises); //await Promise.all(pushPromises);
-      const removedDiscSeqList = results.map((item) => {
-        if (item.status === "rejected") {
-          return -1;
-        }
-        return item.value.removedDiscSeqs;
-      });
-      if (removedDiscSeqList.every((val, i, arr) => val === arr[0])) {
-        // if all variants removed equal amounts of disc-tags
-        this.discSeqCount += removedDiscSeqList[0];
+      await allSettled(pushPromises);
+
+      // UPDATE COUNTS, & Shift Segments in vodSegments and liveSegQueue if needed.
+      const leaderORFollower = isLeader ? "LEADER" : "NEW FOLLOWER";
+      const newTotalDuration = this._incrementAndShift(leaderORFollower);
+      if (newTotalDuration) {
+        debug(`[${this.sessionId}]: New Adjusted Playlist Duration=${newTotalDuration}s`);
       }
-      // UPDATE COUNTS, & Shift Segments in vodSegments
-      await this._incrementAndShift();
     }
 
     // -----------------------------------------------------
     // Leader writes to store so that Followers can read.
     // -----------------------------------------------------
     if (isLeader) {
-      debug(`[${this.sessionId}]: LEADER: Adding data to store!`);
       if (this.allowedToSet) {
-        await this.sessionLiveState.set("liveSegsForFollowers", this.liveSegsForFollowers);
-        await this.sessionLiveState.set("lastRequestedMediaSeqRaw", this.lastRequestedMediaSeqRaw);
+        const liveBws = Object.keys(this.liveSegsForFollowers);
+        const segListSize = this.liveSegsForFollowers[liveBws[0]].length;
+        // Do not replace old data with empty data
+        if (segListSize > 0) {
+          debug(`[${this.sessionId}]: LEADER: Adding data to store!`);
+          await this.sessionLiveState.set("liveSegsForFollowers", this.liveSegsForFollowers);
+          await this.sessionLiveState.set("lastRequestedMediaSeqRaw", this.lastRequestedMediaSeqRaw);
+        }
       }
 
       // [LASTLY]: LEADER does this for respawned-FOLLOWERS' sake.
@@ -841,8 +784,8 @@ class SessionLive {
         await timer(1000); // maybe remove
         const firstCounts = {
           liveSourceMseqCount: this.lastRequestedMediaSeqRaw,
-          mediaSeqCount: this.mediaSeqCount,
-          discSeqCount: this.discSeqCount,
+          mediaSeqCount: this.prevMediaSeqCount,
+          discSeqCount: this.prevDiscSeqCount,
         };
         debug(`[${this.sessionId}]: LEADER: I am adding 'firstCounts'=${JSON.stringify(firstCounts)} to Store for future followers`);
         await this.sessionLiveState.set("firstCounts", firstCounts);
@@ -858,39 +801,148 @@ class SessionLive {
     return;
   }
 
-  async _incrementAndShift() {
-    const vodBandwidths = Object.keys(this.vodSegments);
-    for (let j = 0; j < this.pushAmount; j++) {
+  _shiftSegments(opt) {
+    let _totalDur = 0;
+    let _segments = {};
+    let _name = "";
+    let _removedSegments = 0;
+    let _removedDiscontinuities = 0;
+
+    if (opt && opt.totalDur) {
+      _totalDur = opt.totalDur;
+    }
+    if (opt && opt.segments) {
+      _segments = JSON.parse(JSON.stringify(opt.segments)); // clone it
+    }
+    if (opt && opt.name) {
+      _name = opt.name || "NONE";
+    }
+    if (opt && opt.removedSegments) {
+      _removedSegments = opt.removedSegments;
+    }
+    if (opt && opt.removedDiscontinuities) {
+      _removedDiscontinuities = opt.removedDiscontinuities;
+    }
+    const bws = Object.keys(_segments);
+
+    /* When Total Duration is past the Limit, start Shifting V2L|LIVE segments if found */
+    while (_totalDur > TARGET_PLAYLIST_DURATION_SEC) {
+      // Skip loop if there are no more segments to remove...
+      if (_segments[bws[0]].length === 0) {
+        return { totalDuration: _totalDur, removedSegments: _removedSegments, removedDiscontinuities: _removedDiscontinuities, shiftedSegments: _segments };
+      }
+      debug(`[${this.sessionId}]: ${_name}: (${_totalDur})s/(${TARGET_PLAYLIST_DURATION_SEC})s - Playlist Duration is Over the Target. Shift needed!`);
+      let timeToRemove = 0;
       let incrementDiscSeqCount = false;
-      // Shift the top vod segment
-      for (let i = 0; i < vodBandwidths.length; i++) {
-        let seg = this.vodSegments[vodBandwidths[i]].shift();
-        if (seg) {
-          if (seg.discontinuity) {
-            this.vodSegments[vodBandwidths[i]].shift();
-            incrementDiscSeqCount = true;
+
+      // Shift Segments for each variant...
+      for (let i = 0; i < bws.length; i++) {
+        let seg = _segments[bws[i]].shift();
+        if (i === 0) {
+          debug(`[${this.sessionId}]: ${_name}: (${bws[i]}) Ejected from playlist->: ${JSON.stringify(seg, null, 2)}`);
+        }
+        if (seg && seg.discontinuity) {
+          incrementDiscSeqCount = true;
+          if (_segments[bws[i]].length > 0) {
+            seg = _segments[bws[i]].shift();
+            if (i === 0) {
+              debug(`[${this.sessionId}]: ${_name}: (${bws[i]}) Ejected from playlist->: ${JSON.stringify(seg, null, 2)}`);
+            }
           }
         }
+        if (seg && seg.duration) {
+          timeToRemove = seg.duration;
+        }
+      }
+      if (timeToRemove) {
+        _totalDur -= timeToRemove;
+        // Increment number of removed segments...
+        _removedSegments++;
       }
       if (incrementDiscSeqCount) {
-        this.discSeqCount++;
+        // Update Session Live Discontinuity Sequence Count
+        _removedDiscontinuities++;
       }
-      this.mediaSeqCount++;
     }
+    return { totalDuration: _totalDur, removedSegments: _removedSegments, removedDiscontinuities: _removedDiscontinuities, shiftedSegments: _segments };
+  }
 
-    // TODO: LASTLY: SHRINK IF NEEDED. (should only happen once if ever.)
-    // let extraSegments = (this.liveSegQueue[liveTargetBandwidth].length + this.vodSegments[vodBandwidths[0]].length) - this.targetNumSeg;
-    // if(extraSegments > 0) {
-    //   // POP top vod seg, 'extraSegments' times for all variants
-    //   for (let k = 0; k < extraSegments; k++) {
-    //     // Shift the top vod segment
-    //     for (let i = 0; i < vodBandwidths.length; i++) {
-    //       this.vodSegments[vodBandwidths[i]].shift();
-    //     }
-    //     this.mediaSeqCount++;
-    //   }
-    //   debug(`[${this.sessionId}]: Success! We shrunk manifest segment amount by ${extraSegments}_units`);
-    // }
+  /**
+   * Shifts V2L or LIVE items if total segment duration (V2L+LIVE) are over the target duration.
+   * It will also update and increment SessionLive's MediaSeqCount and DiscSeqCount based
+   * on what was shifted.
+   * @param {string} instanceName Name of instance "LEADER" | "FOLLOWER"
+   * @returns {number} The new total duration in seconds
+   */
+  _incrementAndShift(instanceName) {
+    if (!instanceName) {
+      instanceName = "UNKNOWN";
+    }
+    const vodBws = Object.keys(this.vodSegments);
+    const liveBws = Object.keys(this.liveSegQueue);
+    let vodTotalDur = 0;
+    let liveTotalDur = 0;
+    let totalDur = 0;
+    let removedSegments = 0;
+    let removedDiscontinuities = 0;
+
+    // Calculate Playlist Total Duration
+    this.vodSegments[vodBws[0]].forEach((seg) => {
+      if (seg.duration) {
+        vodTotalDur += seg.duration;
+      }
+    });
+    this.liveSegQueue[liveBws[0]].forEach((seg) => {
+      if (seg.duration) {
+        liveTotalDur += seg.duration;
+      }
+    });
+    totalDur = vodTotalDur + liveTotalDur;
+    debug(`[${this.sessionId}]: ${instanceName}: L2L dur->: ${liveTotalDur}s | V2L dur->: ${vodTotalDur}s | Total dur->: ${totalDur}s`);
+
+    /** --- SHIFT then INCREMENT --- **/
+
+    // Shift V2L Segments
+    const outputV2L = this._shiftSegments({
+      name: instanceName,
+      totalDur: totalDur,
+      segments: this.vodSegments,
+      removedSegments: removedSegments,
+      removedDiscontinuities: removedDiscontinuities,
+    });
+    // Update V2L Segments
+    this.vodSegments = outputV2L.shiftedSegments;
+    // Update values
+    totalDur = outputV2L.totalDuration;
+    removedSegments = outputV2L.removedSegments;
+    removedDiscontinuities = outputV2L.removedDiscontinuities;
+    // Shift LIVE Segments
+    const outputLIVE = this._shiftSegments({
+      name: instanceName,
+      totalDur: totalDur,
+      segments: this.liveSegQueue,
+      removedSegments: removedSegments,
+      removedDiscontinuities: removedDiscontinuities,
+    });
+    // Update LIVE Segments
+    this.liveSegQueue = outputLIVE.shiftedSegments;
+    // Update values
+    totalDur = outputLIVE.totalDuration;
+    removedSegments = outputLIVE.removedSegments;
+    removedDiscontinuities = outputLIVE.removedDiscontinuities;
+
+    // Update Session Live Discontinuity Sequence Count...
+    this.prevDiscSeqCount = this.discSeqCount;
+    this.discSeqCount += removedDiscontinuities;
+    // Update Session Live Media Sequence Count...
+    this.prevMediaSeqCount = this.mediaSeqCount;
+    this.mediaSeqCount += removedSegments;
+    if (this.discSeqCount !== this.prevDiscSeqCount) {
+      debug(`[${this.sessionId}]: ${instanceName}: Incrementing Dseq Count from {${this.prevDiscSeqCount}} -> {${this.discSeqCount}}`);
+    }
+    debug(`[${this.sessionId}]: ${instanceName}: Incrementing Mseq Count from [${this.prevMediaSeqCount}] -> [${this.mediaSeqCount}]`);
+    debug(`[${this.sessionId}]: ${instanceName}: Finished updating all Counts and Segment Queues!`);
+    return totalDur;
   }
 
   async _loadMediaManifest(bw) {
@@ -957,28 +1009,17 @@ class SessionLive {
         //debug(`[${this.sessionId}]: Current RAW Mseq:  [${m3u.get("mediaSequence")}]`);
         //debug(`[${this.sessionId}]: Previous RAW Mseq: [${this.lastRequestedMediaSeqRaw}]`);
 
-        // TODO: UPDATE target for number of segments in a manifest, if appropriate.
-        // if (m3u.items.PlaylistItem.length < this.targetNumSeg) {
-        //   debug(`[${this.sessionId}]: WE PLAN TO LOWER SEGMENT AMOUNT IN MANIFEST FROM (${this.targetNumSeg}) TO (${m3u.items.PlaylistItem.length})`);
-        //   this.targetNumSeg = m3u.items.PlaylistItem.length;
-        // }
-
         if (this.pushAmount >= 0) {
           this.lastRequestedMediaSeqRaw = m3u.get("mediaSequence");
         }
         this.targetDuration = m3u.get("targetDuration");
-        let amountRemovedDiscSeqs = 0;
         let startIdx = m3u.items.PlaylistItem.length - this.pushAmount;
         startIdx = startIdx < 0 ? 0 : startIdx;
         if (mediaManifestUri) {
           // push segments
-          amountRemovedDiscSeqs = this._addLiveSegmentsToQueue(startIdx, m3u.items.PlaylistItem, baseUrl, liveTargetBandwidth);
+          this._addLiveSegmentsToQueue(startIdx, m3u.items.PlaylistItem, baseUrl, liveTargetBandwidth);
         }
-        let resolveObj = {
-          removedDiscSeqs: amountRemovedDiscSeqs,
-          bw: liveTargetBandwidth,
-        };
-        resolve(resolveObj);
+        resolve();
       } catch (exc) {
         console.error("ERROR: " + exc);
         reject(exc);
@@ -986,8 +1027,15 @@ class SessionLive {
     });
   }
 
+  /**
+   * Collects 'new' PlaylistItems and converts them into custom SegmentItems,
+   * then Pushes them to the LiveSegQueue for all variants.
+   * @param {number} startIdx
+   * @param {m3u8.Item.PlaylistItem} playlistItems
+   * @param {string} baseUrl
+   * @param {string} liveTargetBandwidth
+   */
   _addLiveSegmentsToQueue(startIdx, playlistItems, baseUrl, liveTargetBandwidth) {
-    let amountRemovedDiscSeqs = 0;
     for (let i = startIdx; i < playlistItems.length; i++) {
       debug(`[${this.sessionId}]: Adding Live Segment(s) to Queue (for bw=${liveTargetBandwidth})`);
       let seg = {};
@@ -1056,30 +1104,11 @@ class SessionLive {
         if (daterangeData) {
           seg["daterange"] = daterangeData;
         }
-
+        // Push new Live Segments!
         this.liveSegQueue[liveTargetBandwidth].push(seg);
         this.liveSegsForFollowers[liveTargetBandwidth].push(seg);
-        let segCount = 0;
-        this.liveSegQueue[liveTargetBandwidth].map((seg) => {
-          if (seg.uri) {
-            segCount++;
-          }
-        });
-        debug(`[${this.sessionId}]: size of queue=${segCount}_targetNumseg=${this.targetNumSeg}`);
-        if (segCount > this.targetNumSeg) {
-          debug(`[${this.sessionId}]: liveTargetBandwidth=${liveTargetBandwidth}_seg=${JSON.stringify(seg, null, 2)}`);
-          seg = this.liveSegQueue[liveTargetBandwidth].shift();
-          if (seg) {
-            if (seg.discontinuity) {
-              this.liveSegQueue[liveTargetBandwidth].shift();
-              amountRemovedDiscSeqs++;
-            }
-          }
-          debug(`[${this.sessionId}]: After Shifting -> size of queue=${segCount}_targetNumseg=${this.targetNumSeg}`);
-        }
       }
     }
-    return amountRemovedDiscSeqs;
   }
 
   /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "3.0.7",
+  "version": "3.1.2",
   "description": "OTT TV Channel Engine",
   "main": "index.js",
   "scripts": {

package/spec/engine/playhead_live_spec.js

@@ -202,36 +202,42 @@ segment_0_8.ts
 
 const mockLiveSegments = {
   180000: [
-    { duration: 7, uri: "http://mock.mock.com/180000/seg09.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg10.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg11.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg12.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg13.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg14.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg15.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg16.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg09.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg10.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg11.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg12.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg13.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg14.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg15.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg16.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg17.ts" },
+    { duration: 6, uri: "http://mock.mock.com/180000/seg18.ts" },
     { discontinuity: true },
   ],
   1258000: [
-    { duration: 7, uri: "http://mock.mock.com/180000/seg09.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg10.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg11.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg12.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg13.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg14.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg15.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg16.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg09.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg10.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg11.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg12.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg13.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg14.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg15.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg16.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg17.ts" },
+    { duration: 6, uri: "http://mock.mock.com/1258000/seg18.ts" },
     { discontinuity: true },
   ],
   2488000: [
-    { duration: 7, uri: "http://mock.mock.com/180000/seg09.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg10.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg11.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg12.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg13.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg14.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg15.ts" },
-    { duration: 7, uri: "http://mock.mock.com/180000/seg16.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg09.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg10.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg11.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg12.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg13.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg14.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg15.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg16.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg17.ts" },
+    { duration: 6, uri: "http://mock.mock.com/2488000/seg18.ts" },
     { discontinuity: true },
   ],
 };