eyevinn-channel-engine 3.3.3 → 3.3.6

package/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:slim
+FROM node:12.16.1-alpine
 
 WORKDIR /app
 

package/engine/session.js

@@ -566,14 +566,16 @@ class Session {
     if (currentVod) {
       try {
 
+        let manifestMseq = playheadState.mediaSeq + playheadState.vodMediaSeqVideo;
         if (currentVod.sequenceAlwaysContainNewSegments) {
           const mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
           debug(`[${this._sessionId}]: {${mediaSequenceValue}}_{${currentVod.getLastSequenceMediaSequenceValue()}}`);
+          manifestMseq = playheadState.mediaSeq + mediaSequenceValue;
         }
 
         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`);
+        debug(`[${this._sessionId}]: [${manifestMseq}][${sessionState.discSeq}][+${this.targetDurationPadding || 0}] Current media manifest for ${bw} requested`);
         this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
         this.prevMediaSeqOffset.video = playheadState.mediaSeq;
         return m3u8;
@@ -1234,34 +1236,33 @@ class Session {
           try {
             debug(`[${this._sessionId}]: state=VOD_RELOAD_INIT`);
             if (isLeader) {
-
               const startTS = Date.now();
-
               // 1) To tell Follower that, Leader is working on it!
               sessionState.state = await this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING);
-
               // 2) Set new 'offset' sequences, to carry on the continuity from session-live 
               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;
-              } 
+                Object.keys(this.switchDataForSession.transitionSegments).forEach(bw => {
+                  let shiftedSeg = this.switchDataForSession.transitionSegments[bw].shift();
+                  if (shiftedSeg && shiftedSeg.discontinuity) {
+                    shiftedSeg = this.switchDataForSession.transitionSegments[bw].shift();
+                  }
+                });
+              }
               const dSeq = this.switchDataForSession.discSeq;
               const mSeqOffset = this.switchDataForSession.mediaSeqOffset;
               const reloadBehind = this.switchDataForSession.reloadBehind;
               const segments = this.switchDataForSession.transitionSegments;
-
               if ([mSeq,dSeq,mSeqOffset,reloadBehind,segments].includes(null)) {
                 debug(`[${this._sessionId}]: LEADER: Cannot Reload VOD, missing switch-back data`);
                 return;
               }
-
               await this._sessionState.set("mediaSeq", mSeq);
               await this._playheadState.set("mediaSeq", mSeq);
               await this._sessionState.set("discSeq", dSeq);
               debug(`[${this._sessionId}]: Setting current media and discontinuity count -> [${mSeq}]:[${dSeq}]`);
-
               // 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"]);
@@ -1270,8 +1271,10 @@ class Session {
                 nextMseq = currentVod.getLiveMediaSequencesCount() - 1;
               }
 
-              // TODO: Support reloading with audioSegments as well
-
+              // ---------------------------------------------------.
+              // TODO: Support reloading with audioSegments as well |
+              // ---------------------------------------------------'
+              
               await currentVod.reload(nextMseq, segments, null, reloadBehind);
               await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
               await this._sessionState.set("vodReloaded", 1);
@@ -1280,13 +1283,12 @@ class Session {
               await this._playheadState.set("vodMediaSeqVideo", 0);
               await this._playheadState.set("vodMediaSeqAudio", 0);
               await this._playheadState.set("playheadRef", Date.now());
+               // 4) Log to debug and cloudwatch
               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;
             } else {
               debug(`[${this._sessionId}]: not a leader so will go directly to state VOD_RELOAD_INITIATING`);

package/engine/session_live.js

@@ -85,7 +85,7 @@ class SessionLive {
     if (resetDelay === null || resetDelay < 0) {
       resetDelay = RESET_DELAY;
     }
-
+    debug(`[${this.instanceId}][${this.sessionId}]: LEADER: Resetting SessionLive values in Store ${resetDelay === 0 ? "Immediately" : `after a delay=(${resetDelay}ms)`}`);
     await timer(resetDelay);
     await this.sessionLiveState.set("liveSegsForFollowers", null);
     await this.sessionLiveState.set("lastRequestedMediaSeqRaw", null);
@@ -95,7 +95,7 @@ class SessionLive {
       mediaSeqCount: null,
       discSeqCount: null,
     });
-    debug(`[${this.instanceId}][${this.sessionId}]: LEADER: Resetting SessionLive values in Store ${resetDelay === 0 ? "Immediately" : `after a delay=(${resetDelay}ms)`}`);
+    debug(`[${this.instanceId}][${this.sessionId}]: LEADER: SessionLive values in Store have now been reset!`);
   }
 
   async resetSession() {
@@ -218,6 +218,7 @@ class SessionLive {
         this.masterManifestUri = masterManifestUri;
         if (this.sessionLiveProfile) {
           this._filterLiveProfiles();
+          debug(`[${this.sessionId}]: Filtered Live profiles! (${Object.keys(this.mediaManifestURIs).length}) profiles left!`);
         }
       } catch (err) {
         this.masterManifestUri = null;
@@ -253,14 +254,30 @@ class SessionLive {
         if (segments[bw][0].discontinuity) {
           segments[bw].shift();
         }
-
+        let cueInExists = null;
         for (let segIdx = 0; segIdx < segments[bw].length; segIdx++) {
-          this.vodSegments[bw].push(segments[bw][segIdx]);
+          const v2lSegment = segments[bw][segIdx];
+          if (v2lSegment.cue) {
+            if (v2lSegment.cue["in"]) {
+              cueInExists = true;
+            } else {
+              cueInExists = false;
+            }
+          }
+          this.vodSegments[bw].push(v2lSegment);
         }
-        if (!segments[bw][segments[bw].length - 1].discontinuity) {
-          this.vodSegments[bw].push({ discontinuity: true, cue: { in: true } });
+
+        const endIdx = segments[bw].length - 1;
+        if (!segments[bw][endIdx].discontinuity) {
+          const finalSegItem = { discontinuity: true };
+          if (!cueInExists) {
+            finalSegItem["cue"] = { in: true };
+          }
+          this.vodSegments[bw].push(finalSegItem);
         } else {
-          segments[bw][segments[bw].length - 1]["cue"] = { in: true };
+          if (!cueInExists) {
+            segments[bw][endIdx]["cue"] = { in: true };
+          }
         }
       }
     } else {
@@ -545,6 +562,18 @@ class SessionLive {
       let attempts = 10;
       //  CHECK AGAIN CASE 1: Store Empty
       while (!leadersMediaSeqRaw && attempts > 0) {
+        if (!leadersMediaSeqRaw) {
+          isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
+          if (isLeader) {
+            debug(`[${this.instanceId}]: I'm the new leader`);
+            return;
+          }
+        }
+
+        if (!this.allowedToSet) {
+          debug(`[${this.sessionId}]: We are about to switch away from LIVE. Abort fetching from Store`);
+          break;
+        }
         const segDur = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
         const waitTimeMs = parseInt(segDur / 3, 10);
         debug(`[${this.sessionId}]: FOLLOWER: Leader has not put anything in store... Will check again in ${waitTimeMs}ms (Tries left=[${attempts}])`);
@@ -555,19 +584,25 @@ class SessionLive {
       }
 
       if (!leadersMediaSeqRaw) {
-        isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
-        if (isLeader) {
-          debug(`[${this.instanceId}]: I'm the new leader`);
-          return;
-        } else {
-          debug(`[${this.instanceId}]: The leader is still alive`);
-          return;
-        }
+        debug(`[${this.instanceId}]: The leader is still alive`);
+        return;
       }
 
       attempts = 10;
       //  CHECK AGAIN CASE 2: Store Old
       while (leadersMediaSeqRaw <= this.lastRequestedMediaSeqRaw && attempts > 0) {
+        if (!this.allowedToSet) {
+          debug(`[${this.sessionId}]: We are about to switch away from LIVE. Abort fetching from Store`);
+          break;
+        }
+        if (leadersMediaSeqRaw <= this.lastRequestedMediaSeqRaw) {
+          isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
+          if (isLeader) {
+            debug(`[${this.instanceId}][${this.sessionId}]: I'm the new leader`);
+            return;
+          }
+        }
+
         const segDur = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
         const waitTimeMs = parseInt(segDur / 3, 10);
         debug(`[${this.sessionId}]: FOLLOWER: Cannot find anything NEW in store... Will check again in ${waitTimeMs}ms (Tries left=[${attempts}])`);
@@ -576,18 +611,10 @@ class SessionLive {
         leadersMediaSeqRaw = await this.sessionLiveState.get("lastRequestedMediaSeqRaw");
         attempts--;
       }
-
-      if (leadersMediaSeqRaw <= this.lastRequestedMediaSeqRaw) {
-        isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
-        if (isLeader) {
-          debug(`[${this.instanceId}][${this.sessionId}]: I'm the new leader`);
-          return;
-        } else {
-          debug(`[${this.instanceId}][${this.sessionId}]: The leader is still alive`);
-          return;
-        }
+      if(leadersMediaSeqRaw <= this.lastRequestedMediaSeqRaw) {
+        debug(`[${this.instanceId}][${this.sessionId}]: The leader is still alive`);
+        return;
       }
-
       // Follower updates its manifest building blocks (segment holders & counts)
       this.lastRequestedMediaSeqRaw = leadersMediaSeqRaw;
       this.liveSegsForFollowers = await this.sessionLiveState.get("liveSegsForFollowers");
@@ -601,7 +628,7 @@ class SessionLive {
     // ---------------------------------
     let FETCH_ATTEMPTS = 10;
     this.liveSegsForFollowers = {};
-
+    let bandwidthsToSkipOnRetry = [];
     while (FETCH_ATTEMPTS > 0) {
       if (isLeader) {
         debug(`[${this.sessionId}]: LEADER: Trying to fetch manifests for all bandwidths\n Attempts left=[${FETCH_ATTEMPTS}]`);
@@ -619,9 +646,15 @@ class SessionLive {
       let manifestList = [];
       this.pushAmount = 0;
       try {
+        if (bandwidthsToSkipOnRetry.length > 0) {
+          debug(`[${this.sessionId}]: (X) Skipping loadMedia promises for bws ${JSON.stringify(bandwidthsToSkipOnRetry)}`);
+        }
         // Collect Live Source Requesting Promises
         for (let i = 0; i < Object.keys(this.mediaManifestURIs).length; i++) {
           let bw = Object.keys(this.mediaManifestURIs)[i];
+          if (bandwidthsToSkipOnRetry.includes(bw)) {
+            continue;
+          }
           livePromises.push(this._loadMediaManifest(bw));
           debug(`[${this.sessionId}]: Pushed loadMedia promise for bw=[${bw}]`);
         }
@@ -642,16 +675,28 @@ class SessionLive {
         continue;
       }
 
-      const allMediaSeqCounts = manifestList.map((item) => {
-        if (item.status === "rejected") {
-          return item.reason.mediaSeq;
+      // Store the results locally
+      manifestList.forEach((variantItem) => {
+        const bw = variantItem.value.bandwidth;
+        if (!this.liveSourceM3Us[bw]) {
+          this.liveSourceM3Us[bw] = {};
         }
-        return item.value.mediaSeq;
+        this.liveSourceM3Us[bw] = variantItem.value;
       });
 
+      const allStoredMediaSeqCounts = Object.keys(this.liveSourceM3Us).map((variant) => this.liveSourceM3Us[variant].mediaSeq);
+
       // Handle if mediaSeqCounts are NOT synced up!
-      if (!allMediaSeqCounts.every((val, i, arr) => val === arr[0])) {
-        debug(`[${this.sessionId}]: Live Mseq counts=[${allMediaSeqCounts}]`);
+      if (!allStoredMediaSeqCounts.every((val, i, arr) => val === arr[0])) {
+        debug(`[${this.sessionId}]: Live Mseq counts=[${allStoredMediaSeqCounts}]`);
+        // Figure out what bw's are behind.
+        const higestMediaSeqCount = Math.max(...allStoredMediaSeqCounts);
+        bandwidthsToSkipOnRetry = Object.keys(this.liveSourceM3Us).filter((bw) => {
+          if (this.liveSourceM3Us[bw].mediaSeq === higestMediaSeqCount) {
+            return true;
+          }
+          return false;
+        });
         // Decrement fetch counter
         FETCH_ATTEMPTS--;
         // Calculate retry delay time. Default=1000
@@ -672,7 +717,7 @@ class SessionLive {
         continue;
       }
 
-      currentMseqRaw = allMediaSeqCounts[0];
+      currentMseqRaw = allStoredMediaSeqCounts[0];
 
       if (!isLeader) {
         let leadersFirstSeqCounts = await this.sessionLiveState.get("firstCounts");
@@ -733,7 +778,6 @@ class SessionLive {
         if (currentMseqRaw === leadersFirstSeqCounts.liveSourceMseqCount) {
           this.pushAmount = 1; // Follower from start
         } else {
-
           // TODO: To support and account for past discontinuity tags in the Live Source stream,
           // we will need to get the real 'current' discontinuity-sequence count from Leader somehow.
 
@@ -773,7 +817,7 @@ class SessionLive {
       const leadersCurrentMseqRaw = await this.sessionLiveState.get("lastRequestedMediaSeqRaw");
       const counts = await this.sessionLiveState.get("firstCounts");
       const leadersFirstMseqRaw = counts.liveSourceMseqCount;
-      if (leadersCurrentMseqRaw !== null && leadersCurrentMseqRaw !== currentMseqRaw) {
+      if (leadersCurrentMseqRaw !== null && leadersCurrentMseqRaw > currentMseqRaw) {
         // if leader never had any segs from prev mseq
         if (leadersFirstMseqRaw !== null && leadersFirstMseqRaw === leadersCurrentMseqRaw) {
           // Follower updates it's manifest ingedients (segment holders & counts)
@@ -821,8 +865,8 @@ class SessionLive {
         // 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);
+          await this.sessionLiveState.set("liveSegsForFollowers", this.liveSegsForFollowers);
         }
       }
 
@@ -1030,8 +1074,8 @@ class SessionLive {
           const resolveObj = {
             M3U: m3u,
             mediaSeq: m3u.get("mediaSequence"),
+            bandwidth: liveTargetBandwidth,
           };
-          this.liveSourceM3Us[liveTargetBandwidth] = resolveObj;
           resolve(resolveObj);
         } catch (exc) {
           debug(`[${this.sessionId}]: Error when parsing latest manifest`);

package/engine/stream_switcher.js

@@ -307,9 +307,6 @@ class StreamSwitcher {
           liveSegments = await sessionLive.getCurrentMediaSequenceSegments();
           liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
 
-          await sessionLive.resetSession();
-          sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
-
           if (scheduleObj && !scheduleObj.duration) {
             debug(`[${this.sessionId}]: Cannot switch VOD. No duration specified for schedule item: [${scheduleObj.assetId}]`);
           }
@@ -331,6 +328,9 @@ class StreamSwitcher {
           await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq, liveCounts.discSeq);
           await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount);
 
+          await sessionLive.resetSession();
+          sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
+
           this.working = false;
           this.streamTypeLive = false;
           debug(`[${this.sessionId}]: [ Switched from LIVE->V2L ]`);
@@ -349,8 +349,6 @@ class StreamSwitcher {
           this.eventId = scheduleObj.eventId;
           liveSegments = await sessionLive.getCurrentMediaSequenceSegments();
           liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
-          await sessionLive.resetSession();
-          sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
 
           eventSegments = await session.getTruncatedVodSegments(scheduleObj.uri, scheduleObj.duration / 1000);
           if (!eventSegments) {
@@ -369,9 +367,11 @@ class StreamSwitcher {
             const prerollSegments = this.prerollsCache[this.sessionId].segments;
             eventSegments = this._mergeSegments(prerollSegments, eventSegments, true);
           }
-
           await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
 
+          await sessionLive.resetSession();
+          sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
+          
           this.working = false;
           this.streamTypeLive = false;
           debug(`[${this.sessionId}]: Switched from LIVE->VOD`);
@@ -626,7 +626,10 @@ class StreamSwitcher {
       } else {
         const lastSeg = toSegments[bw][toSegments[bw].length - 1];
         if (lastSeg.uri && !lastSeg.discontinuity) {
-          toSegments[bw].push({ discontinuity: true });
+          toSegments[bw].push({ discontinuity: true, cue: { in: true } });
+          OUTPUT_SEGMENTS[bw] = toSegments[bw].concat(fromSegments[targetBw]);
+        } else if (lastSeg.discontinuity && !lastSeg.cue) {
+          toSegments[bw][toSegments[bw].length - 1].cue = { in: true }
           OUTPUT_SEGMENTS[bw] = toSegments[bw].concat(fromSegments[targetBw]);
         } else {
           OUTPUT_SEGMENTS[bw] = toSegments[bw].concat(fromSegments[targetBw]);

package/package.json

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