eyevinn-channel-engine 3.0.0 → 3.0.4

package/.github/workflows/nodejs.yml

@@ -9,7 +9,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x]
+        node-version: [12.x, 14.x]
 
     steps:
     - uses: actions/checkout@v1

package/README.md

@@ -18,12 +18,18 @@ To run the basic reference implementation included in this repository you run:
 $ npm start
 ```
 
-And to run the basic reference implementation for using demuxed VODs you run:
+To run the basic reference implementation for using demuxed VODs you run:
 
 ```
 $ npm run start-demux
 ```
 
+And to run the basic reference implementation for using live-mixing you run:
+
+```
+$ npm run start-livemix
+```
+
 
 Then point your HLS video player to `http://localhost:8000/channels/1/master.m3u8` to start playing the linear live stream.
 
@@ -122,8 +128,6 @@ engine.start();
 engine.listen(process.env.port || 8000);
 ```
 
-Note that this feature is currently in beta which means that it is close to production-ready but has not been run in production yet. We appreciate all efforts to try this out and provide feedback.
-
 
 ## Live Mixing (BETA)
 
@@ -137,8 +141,9 @@ class MyStreamSwitchManager {
   getSchedule(channelId) -> [ { eventId, assetId, title, type, start_time, end_time, uri, duration } ]
 }
 ```
+When using **Live Mixing** in **High-Availablilty** mode, it is important to know that the class's  `getSchedule(channelId)` function will be called by each channel-engine instance. Meaning that it is crucial that the implementation of this function will return the same response for each and every channel-engine instance, as they are expecting to be recieving identical lists in order to be synced up for live mixing. 
 
-The class's `getSchedule(channelId)` function should return a list of event objects in the following format:
+The class's `getSchedule(channelId)` function should return a promise containing the list of events as an object in the following format below:
 
 ```
 {
@@ -204,6 +209,7 @@ Below are examples of a Live stream event and a VOD event respectively:
 (*Important Note: When it comes to VOD events. Desired `duration` has priority over `end_time`. Meaning that you will only resume VOD2Live content after the asset in the VOD event has finished. This may change in the future.*) 
 
 
+
 Then create an instance of the class and reference it as the `streamSwitchManager` in your engineOptions, just like you'd do with the channel manager. 
 
 ```
@@ -244,7 +250,7 @@ If the connection to the Live stream ends or if the current time has passed the
 
 Note that this feature is also currently in beta which means that it is close to production-ready but has not been run in production yet. We appreciate all efforts to try this out and provide feedback.
 
-## Demo
+## Support
 
 If you want help to get started to build a service of your own based on this library you can hire an [Eyevinn Video-Dev Team](https://video-dev.team) to help you out.
 

package/engine/server.js

@@ -167,12 +167,18 @@ class ChannelEngine {
 
     const StreamSwitchLoop = async (timeIntervalMs) => {
       while(true) {
-        const ts_1 = Date.now();
-        await this.updateStreamSwitchAsync()
-        const ts_2 = Date.now();
-        let interval = (timeIntervalMs - (ts_2 - ts_1)) < 0 ? 50 : (timeIntervalMs - (ts_2 - ts_1)); 
-        await timer(interval)
-        debug(`SteamSwitchLoop waited for all channels. Next tick in: ${interval}ms`)
+        try {
+          const ts_1 = Date.now();
+          await this.updateStreamSwitchAsync()
+          const ts_2 = Date.now();
+          let interval = (timeIntervalMs - (ts_2 - ts_1)) < 0 ? 50 : (timeIntervalMs - (ts_2 - ts_1)); 
+          await timer(interval)
+          debug(`StreamSwitchLoop waited for all channels. Next tick in: ${interval}ms`)
+        } catch (err) {
+          console.error(err)
+          debug(`StreamSwitchLoop iteration failed. Trying Again in 1000ms!`);
+          await timer(1000);
+        }
       }
     }
     StreamSwitchLoop(this.streamSwitchTimeIntervalMs);
@@ -188,6 +194,7 @@ class ChannelEngine {
         let status = null;
         try {
           status = await switcher.streamSwitcher(sessions[channel], sessionsLive[channel]);
+          debug(`[${channel}]: streamSwitcher returned switchstatus=${status}`);
           if (status === undefined) {
             debug(`[WARNING]: switcherStatus->${status}. Setting value to previous status->${prevStatus}`);
             status = prevStatus;
@@ -200,7 +207,13 @@ class ChannelEngine {
         debug(`Tried to switch stream on a non-existing channel=[${channel}]. Switching Ignored!)`);
       }
     }
-    await Promise.all(channels.map(channel => getSwitchStatusAndPerformSwitch(channel)));
+    try {
+      await Promise.all(channels.map(channel => getSwitchStatusAndPerformSwitch(channel)));
+    } catch (err) {
+      debug('Problem occured when updating streamSwitchers');
+      throw new Error (err);
+    }
+
   }
 
   async updateChannelsAsync(channelMgr, options) {
@@ -521,7 +534,7 @@ class ChannelEngine {
           await timer(500);
         }
         let body = null;
-        debug(`switcherStatus[req.params[1]]=[${switcherStatus[req.params[1]]}]`);
+        debug(`switcherStatus[${req.params[1]}]=[${switcherStatus[req.params[1]]}]`);
         if (switcherStatus[req.params[1]]) {
           debug(`[${req.params[1]}]: Responding with Live-stream manifest`);
           body = await sessionLive.getCurrentMediaManifestAsync(req.params[0]);
@@ -663,8 +676,9 @@ class ChannelEngine {
     let sessionResets = [];
     for (const sessionId of Object.keys(sessions)) {
       const session = sessions[sessionId];
-      if (session) {
-        await session.resetAsync();
+      const sessionLive = sessionsLive[sessionId];
+      if (session && sessionLive) {
+        await session.resetAsync(); 
         sessionResets.push(sessionId);
       } else {
         const err = new errs.NotFoundError('Invalid session');

package/engine/session.js

@@ -43,6 +43,7 @@ class Session {
     this.playheadDiffThreshold = DEFAULT_PLAYHEAD_DIFF_THRESHOLD;
     this.maxTickInterval = DEFAULT_MAX_TICK_INTERVAL;
     this.diffCompensation = null;
+    this.waitingForNextVod = false;
 
     if (config) {
       if (config.sessionId) {
@@ -244,7 +245,7 @@ class Session {
     try {
       const hlsVod = await this._truncateSlate(null, duration, vodUri);
       let vodSegments = hlsVod.getMediaSegments();
-      Object.keys(vodSegments).forEach(bw => vodSegments[bw].unshift({ discontinuity: true }));
+      Object.keys(vodSegments).forEach(bw => vodSegments[bw].unshift({ discontinuity: true, cue: { in: true } }));
       return vodSegments;
     } catch (exc) {
       debug(`[${this._sessionId}]: Failed to generate truncated VOD!`);
@@ -362,6 +363,7 @@ class Session {
       throw new Error('Session not ready');
     }
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
+    const discSeqOffset = await this._sessionState.get("discSeq");
     if (playheadState.vodMediaSeqVideo === 0) {
       const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
       if (!isLeader) {
@@ -372,7 +374,7 @@ class Session {
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
-        const discSeqCount = currentVod.getLastUsedDiscSeq();
+        const discSeqCount = discSeqOffset + currentVod.discontinuities[playheadState.vodMediaSeqVideo];
         debug(`[${this._sessionId}]: MediaSeq: (${(playheadState.mediaSeq + playheadState.vodMediaSeqVideo)}) and DiscSeq: (${discSeqCount}) requested `);
         return {
           'mediaSeq': (playheadState.mediaSeq + playheadState.vodMediaSeqVideo),
@@ -756,6 +758,13 @@ class Session {
       sessionState.state = SessionState.VOD_INIT;
     }
 
+    if (!isLeader && this.waitingForNextVod) {
+      // By now Leader should have added the next Vod in store
+      debug(`[${this._sessionId}]: Not leader! New VOD loaded during last tick. Invalidate current VOD cache`);
+      await this._sessionState.clearCurrentVodCache();
+      this.waitingForNextVod = false;
+    }
+
     switch (sessionState.state) {
       case SessionState.VOD_INIT:
       case SessionState.VOD_INIT_BY_ID:
@@ -842,10 +851,13 @@ class Session {
           }
         }
       case SessionState.VOD_PLAYING:
-        if (!isLeader && sessionState.vodMediaSeqVideo === 0) {
-          debug(`[${this._sessionId}]: First mediasequence in VOD and I am not the leader so invalidate current VOD cache and fetch the new one from the leader`);
-          await this._sessionState.clearCurrentVodCache();
-          currentVod = await this._sessionState.getCurrentVod();
+        if (!isLeader) {
+          if (sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod) {
+            debug(`[${this._sessionId}]: Not leader! Invalidate current VOD cache and fetch the new one from the leader`);
+            await this._sessionState.clearCurrentVodCache();
+            currentVod = await this._sessionState.getCurrentVod();
+            this.waitingForNextVod = false;
+          }
         }
         debug(`[${this._sessionId}]: state=VOD_PLAYING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}, ${currentVod.getLiveMediaSequencesCount()})`);
         return;
@@ -853,10 +865,11 @@ class Session {
         debug(`[${this._sessionId}]: state=VOD_NEXT_INITIATING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}, ${currentVod.getLiveMediaSequencesCount()})`);
         if (!isLeader) {
           debug(`[${this._sessionId}]: not the leader so just waiting for the VOD to be initiated`);
-          if (sessionState.vodMediaSeqVideo === 0) {
+          if (sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod) {
             debug(`[${this._sessionId}]: First mediasequence in VOD and I am not the leader so invalidate current VOD cache and fetch the new one from the leader`);
             await this._sessionState.clearCurrentVodCache();
           }
+          this.waitingForNextVod = true;
         }
         return;
       case SessionState.VOD_NEXT_INIT:
@@ -938,6 +951,7 @@ class Session {
             return;
           } else {
             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);
             sessionState.currentVod = await this._sessionState.getCurrentVod();
           }

package/engine/session_live.js

@@ -1,4 +1,4 @@
-const debug = require("debug")("engine-sessionLive");
+const debug = require("debug")("engine-session-live");
 const allSettled = require("promise.allsettled");
 const crypto = require("crypto");
 const m3u8 = require("@eyevinn/m3u8");
@@ -136,7 +136,7 @@ class SessionLive {
         if (!this.masterManifestUri) {
           await timer(3000);
           continue;
-        }
+        } 
         if (this.playheadState === PlayheadState.STOPPED) {
           debug(`[${this.sessionId}]: Playhead has Stopped, clearing local session and store.`);
           this.waitForPlayhead = false;
@@ -254,7 +254,9 @@ class SessionLive {
         this.vodSegments[bw].push(segments[bw][segIdx]);
       }
       if (!segments[bw][segments[bw].length - 1].discontinuity) {
-        this.vodSegments[bw].push({ discontinuity: true });
+        this.vodSegments[bw].push({ discontinuity: true, cue: { in: true } });
+      } else {
+        segments[bw][segments[bw].length - 1]["cue"] = { in: true };
       }
     }
 
@@ -287,6 +289,13 @@ class SessionLive {
     // Don't use what Session gave you. Use the Leaders number if it's available
     const isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
     let liveCounts = await this.sessionLiveState.get("firstCounts");
+    if (liveCounts === null) {
+      liveCounts = {
+        liveSourceMseqCount: null,
+        mediaSeqCount: null,
+        discSeqCount: null,
+      };
+    }
     if (isLeader) {
       liveCounts.discSeqCount = this.discSeqCount;
       await this.sessionLiveState.set("firstCounts", liveCounts);
@@ -345,7 +354,7 @@ class SessionLive {
       currentMediaSequenceSegments[liveTargetBandwidth] = [];
       // In case we switch back before we've depleted all transitional segments
       currentMediaSequenceSegments[liveTargetBandwidth] = this.vodSegments[vodTargetBandwidth].concat(this.liveSegQueue[liveTargetBandwidth]);
-      currentMediaSequenceSegments[liveTargetBandwidth].push({ discontinuity: true });
+      currentMediaSequenceSegments[liveTargetBandwidth].push({ discontinuity: true, cue: { in: true } });
       debug(`[${this.sessionId}]: Getting current media segments for bw=${bw}`);
     }
 
@@ -477,33 +486,31 @@ class SessionLive {
     const vodBws = Object.keys(this.vodSegments);
     const liveBws = Object.keys(this.liveSegsForFollowers);
     const size = this.liveSegsForFollowers[liveBws[0]].length;
-    debug(`[${this.sessionId}]: [size=${size}]->this.liveSegsForFollowers=${Object.keys(this.liveSegsForFollowers)} `);
+
+    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 < size; k++) {
+    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 || seg && seg.cue) {
-          if (seg.discontinuity) {
-            incrementDiscSeqCount = true;
-          }
-          seg = this.vodSegments[vodBws[i]].shift();
-        }
-        if (seg && seg.discontinuity || seg && seg.cue) {
-          if (seg.discontinuity) {
-            incrementDiscSeqCount = true;
-          }
+        if (seg && seg.discontinuity) {
+          incrementDiscSeqCount = true;
           this.vodSegments[vodBws[i]].shift();
         }
       }
       if (incrementDiscSeqCount) {
-        this.mediaSeqCount++;
+        this.discSeqCount++;
       }
-      // Push to bottom, new live source segment on all variants
-      for (let i = 0; i < liveBws.length; i++) {
-        const bw = liveBws[i];
-        const liveSegFromLeader = this.liveSegsForFollowers[bw][k];
+    }
+    // Push to bottom, new live source segment on 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] = [];
         }
@@ -512,27 +519,21 @@ class SessionLive {
         let segCount = 0;
         this.liveSegQueue[bw].map((seg) => {if (seg.uri) { segCount++ }});
         if (segCount > this.targetNumSeg) {
-          seg = this.liveSegQueue[bw].shift();
-          if (seg && seg.discontinuity || seg && seg.cue) {
-            if (seg.discontinuity) {
-              incrementDiscSeqCount = true;
-            }
+          let seg = this.liveSegQueue[bw].shift();
+          if (seg && seg.discontinuity) {
+            incrementDiscSeqCount = true;
             seg = this.liveSegQueue[bw].shift();
           }
-          if (seg && seg.discontinuity || seg && seg.cue) {
-            if (seg.discontinuity) {
-              incrementDiscSeqCount = true;
-            }
-            this.liveSegQueue[bw].shift();
-          }
         }
-        debug(`[${this.sessionId}]: Pushed a segment to 'liveSegQueue'`);
-      }
+        debug(`[${this.sessionId}]: Pushed segment (${liveSegFromLeader.uri ? liveSegFromLeader.uri : "Disc-tag"}) to 'liveSegQueue'`);
+      });
       if (incrementDiscSeqCount) {
         this.discSeqCount++;
       }
-      this.mediaSeqCount++;
     }
+    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!`);
   }
 
@@ -792,13 +793,22 @@ class SessionLive {
       let pushPromises = [];
       for (let i = 0; i < Object.keys(this.mediaManifestURIs).length; i++) {
         let bw = Object.keys(this.mediaManifestURIs)[i];
-        pushPromises.push(this._parseMediaManifest(this.liveSourceM3Us[bw].M3U, bw, this.mediaManifestURIs[bw], bw));
-        //debug(`[${this.sessionId}]: Pushed pushPromise for bw=${bw}`);
+        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`);
-      await Promise.all(pushPromises);
+      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];
+      }
       // UPDATE COUNTS, & Shift Segments in vodSegments
       await this._incrementAndShift();
     }
@@ -814,7 +824,7 @@ class SessionLive {
       }
 
       // [LASTLY]: LEADER does this for respawned-FOLLOWERS' sake.
-      if (this.firstTime) {
+      if (this.firstTime && this.allowedToSet) {
         // Buy some time for followers (NOT Respawned) to fetch their own L.S m3u8.
         await timer(1000); // maybe remove
         const firstCounts = {
@@ -843,17 +853,11 @@ class SessionLive {
       // Shift the top vod segment
       for (let i = 0; i < vodBandwidths.length; i++) {
         let seg = this.vodSegments[vodBandwidths[i]].shift();
-        if (seg && seg.discontinuity || seg && seg.cue) {
-          if (seg.discontinuity) {
-            incrementDiscSeqCount = true;
-          }
-          seg = this.vodSegments[vodBandwidths[i]].shift();
-        }
-        if (seg && seg.discontinuity || seg && seg.cue) {
+        if (seg) {
           if (seg.discontinuity) {
+            this.vodSegments[vodBandwidths[i]].shift();
             incrementDiscSeqCount = true;
           }
-          this.vodSegments[vodBandwidths[i]].shift();
         }
       }
       if (incrementDiscSeqCount) {
@@ -905,8 +909,12 @@ class SessionLive {
     return new Promise((resolve, reject) => {
       parser.on("m3u", (m3u) => {
         try {
-          let manifestObj = this._miniparse(m3u, bw, mediaManifestUri, liveTargetBandwidth);
-          resolve(manifestObj);
+          const resolveObj = {
+            M3U: m3u,
+            mediaSeq: m3u.get("mediaSequence"),
+          };
+          this.liveSourceM3Us[liveTargetBandwidth] = resolveObj;
+          resolve(resolveObj);
         } catch (exc) {
           debug(`[${this.sessionId}]: Error when parsing latest manifest`);
           reject(exc);
@@ -919,33 +927,7 @@ class SessionLive {
     });
   }
 
-  _miniparse(m3u, bw, mediaManifestUri, liveTargetBandwidth) {
-    if (m3u === null) {
-      throw new Error("No m3u object provided");
-    }
-    return new Promise(async (resolve, reject) => {
-      try {
-        const resolveObj = {
-          M3U: m3u,
-          mediaSeq: m3u.get("mediaSequence"),
-        };
-
-        this.liveSourceM3Us[liveTargetBandwidth] = resolveObj;
-
-        resolve(resolveObj);
-      } catch (exc) {
-        console.error("ERROR: " + exc);
-        reject({
-          message: exc,
-          bandwidth: liveTargetBandwidth,
-          m3u8: null,
-          mediaSeq: -1,
-        });
-      }
-    });
-  }
-
-  _parseMediaManifest(m3u, bw, mediaManifestUri, liveTargetBandwidth) {
+  _parseMediaManifest(m3u, mediaManifestUri, liveTargetBandwidth) {
     return new Promise(async (resolve, reject) => {
       try {
         if (!this.liveSegQueue[liveTargetBandwidth]) {
@@ -954,7 +936,6 @@ class SessionLive {
         if (!this.liveSegsForFollowers[liveTargetBandwidth]) {
           this.liveSegsForFollowers[liveTargetBandwidth] = [];
         }
-
         let baseUrl = "";
         const m = mediaManifestUri.match(/^(.*)\/.*?$/);
         if (m) {
@@ -972,20 +953,18 @@ class SessionLive {
 
         this.lastRequestedMediaSeqRaw = m3u.get("mediaSequence");
         this.targetDuration = m3u.get("targetDuration");
-
-        // Switch out relative URIs if they are used, with absolute URLs
+        let amountRemovedDiscSeqs = 0;
+        let startIdx = m3u.items.PlaylistItem.length - this.pushAmount;
+        startIdx = startIdx < 0 ? 0 : startIdx;
         if (mediaManifestUri) {
-          // CREATE NEW MANIFEST
-          let startIdx;
-          startIdx = m3u.items.PlaylistItem.length - this.pushAmount;
-          if (startIdx < 0) {
-            startIdx = 0;
-          }
           // push segments
-          this._addLiveSegmentsToQueue(startIdx, m3u.items.PlaylistItem, baseUrl, liveTargetBandwidth);
+          amountRemovedDiscSeqs = this._addLiveSegmentsToQueue(startIdx, m3u.items.PlaylistItem, baseUrl, liveTargetBandwidth);
         }
-
-        resolve(this.lastRequestedMediaSeqRaw);
+        let resolveObj = {
+          removedDiscSeqs: amountRemovedDiscSeqs,
+          bw: liveTargetBandwidth
+        }
+        resolve(resolveObj);
       } catch (exc) {
         console.error("ERROR: " + exc);
         reject(exc);
@@ -994,53 +973,61 @@ class SessionLive {
   }
 
   _addLiveSegmentsToQueue(startIdx, playlistItems, baseUrl, liveTargetBandwidth) {
-    let incrementDiscSeqCount = false;
+    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 = {};
       let playlistItem = playlistItems[i];
       let segmentUri;
+      let cueData = null;
+      let daterangeData = null;
       let attributes = playlistItem["attributes"].attributes;
-
       if (playlistItem.properties.discontinuity) {
         this.liveSegQueue[liveTargetBandwidth].push({ discontinuity: true });
         this.liveSegsForFollowers[liveTargetBandwidth].push({ discontinuity: true });
       }
       if ("cuein" in attributes) {
-        this.liveSegQueue[liveTargetBandwidth].push({ cue: { in: true } });
-        this.liveSegsForFollowers[liveTargetBandwidth].push({ cue: { in: true } });
+        if (!cueData) {
+          cueData = {};
+        }
+        cueData["in"] = true;
       }
       if ("cueout" in attributes) {
-        this.liveSegQueue[liveTargetBandwidth].push({ cue: { out: true, duration: attributes["cueout"] }, });
-        this.liveSegsForFollowers[liveTargetBandwidth].push({ cue: { out: true, duration: attributes["cueout"] } });
-      }
+        if (!cueData) {
+          cueData = {};
+        }
+        cueData["out"] = true;
+        cueData["duration"] = attributes["cueout"];
+       }
       if ("cuecont" in attributes) {
-        this.liveSegQueue[liveTargetBandwidth].push({ cue: { cont: true } });
-        this.liveSegsForFollowers[liveTargetBandwidth].push({ cue: { cont: true } });
+        if (!cueData) {
+          cueData = {};
+        }
+        cueData["cont"] = true;
       }
       if ("scteData" in attributes) {
-        this.liveSegQueue[liveTargetBandwidth].push({ cue: { scteData: attributes["scteData"] } });
-        this.liveSegsForFollowers[liveTargetBandwidth].push({ cue: { scteData: attributes["scteData"] } });
+        if (!cueData) {
+          cueData = {};
+        }
+        cueData["scteData"] = attributes["scteData"];
       }
       if ("assetData" in attributes) {
-        this.liveSegQueue[liveTargetBandwidth].push({ cue: { assetData: attributes["assetData"] } });
-        this.liveSegsForFollowers[liveTargetBandwidth].push({ cue: { assetData: attributes["assetData"] } });
+        if (!cueData) {
+          cueData = {};
+        }
+        cueData["assetData"] = attributes["assetData"];
       }
       if ("daterange" in attributes) {
-        this.liveSegQueue[liveTargetBandwidth].push({
-          daterange: { 
-            id: attributes["daterange"]["ID"],
-            "start-date": attributes["daterange"]["START-DATE"],
-            "planned-duration": parseFloat(attributes["daterange"]["PLANNED-DURATION"]),
-          }
-        });
-        this.liveSegsForFollowers[liveTargetBandwidth].push({
-          daterange: { 
-            id: attributes["daterange"]["ID"],
-            "start-date": attributes["daterange"]["START-DATE"],
-            "planned-duration": parseFloat(attributes["daterange"]["PLANNED-DURATION"]),
-          }
-        });
+        if(!daterangeData) {
+          daterangeData = {}
+        }
+        daterangeData = {
+          id: attributes["daterange"]["ID"],
+          "start-date": attributes["daterange"]["START-DATE"],
+          "planned-duration": parseFloat(
+            attributes["daterange"]["PLANNED-DURATION"]
+          ),
+        };
       }
       if (playlistItem.properties.uri) {
         if (playlistItem.properties.uri.match("^http")) {
@@ -1050,6 +1037,10 @@ class SessionLive {
         }
         seg["duration"] = playlistItem.properties.duration;
         seg["uri"] = segmentUri;
+        seg["cue"] = cueData;
+        if (daterangeData) {
+          seg["daterange"] = daterangeData;
+        }
 
         this.liveSegQueue[liveTargetBandwidth].push(seg);
         this.liveSegsForFollowers[liveTargetBandwidth].push(seg);
@@ -1057,25 +1048,19 @@ class SessionLive {
         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 && seg.discontinuity || seg && seg.cue) {
+          if (seg) {
             if (seg.discontinuity) {
-              incrementDiscSeqCount = true;
+              this.liveSegQueue[liveTargetBandwidth].shift();
+              amountRemovedDiscSeqs++;
             }
-            seg = this.liveSegQueue[liveTargetBandwidth].shift();
-          }
-          if (seg && seg.discontinuity || seg && seg.cue) {
-            if (seg.discontinuity) {
-              incrementDiscSeqCount = true;
-            }
-            this.liveSegQueue[liveTargetBandwidth].shift();
           }
+          debug(`[${this.sessionId}]: After Shifting -> size of queue=${segCount}_targetNumseg=${this.targetNumSeg}`);
         }
       }
     }
-    if (incrementDiscSeqCount) {
-      this.discSeqCount++;
-    }
+    return amountRemovedDiscSeqs;
   }
 
   /*
@@ -1168,9 +1153,6 @@ class SessionLive {
         m3u8 += "#EXT-X-DISCONTINUITY\n";
       }
       if (seg.cue) {
-        if (seg.cue.in){
-          m3u8 += "#EXT-X-CUE-IN" + "\n";
-        }
         if(seg.cue.out) {
           if (seg.cue.scteData) {
             m3u8 += "#EXT-OATCLS-SCTE35:" + seg.cue.scteData + "\n";
@@ -1196,6 +1178,10 @@ class SessionLive {
         }
         m3u8 += "#EXT-X-DATERANGE:" + dateRangeAttributes + "\n";
       }
+      // Mimick logic used in hls-vodtolive
+      if (seg.cue && seg.cue.in){
+        m3u8 += "#EXT-X-CUE-IN" + "\n";
+      }
       if (seg.uri) {
         m3u8 += "#EXTINF:" + seg.duration.toFixed(3) + ",\n";
         m3u8 += seg.uri + "\n";

package/engine/session_live_state.js

@@ -1,5 +1,5 @@
 const SharedStateStore = require('./shared_state_store.js');
-const debug = require("debug")("sessionLive-state-store");
+const debug = require("debug")("session-live-state-store");
 
 class SharedSessionLiveState {
   constructor(store, sessionId, instanceId, opts) {