eyevinn-channel-engine 3.1.2 → 3.1.5

package/README.md

@@ -35,7 +35,11 @@ Then point your HLS video player to `http://localhost:8000/channels/1/master.m3u
 
 ## Master manifest filtering
 
-The engine supports a very simplistic and basic filtering of media playlists included in the master manifest. Currently supports to filter on video bandwidth and video height. To specify a filter provide the query parameter `filter` when loading the master manifest, e.g. `(type=="video"&&height>200)&&(type=="video"&&height<400)`. This needs to be URL encoded resulting in the following URL: `http://localhost:8000/channels/1/master.m3u8?filter=%28type%3D%3D%22video%22%26%26height%3E200%29%26%26%28type%3D%3D%22video%22%26%26height%3C400%29`
+The engine supports a very simplistic and basic filtering of media playlists included in the master manifest. Currently supports to filter on video bandwidth and video height. To specify a filter provide the query parameter `filter` when loading the master manifest, e.g. `(type=="video"ANDheight>200)AND(type=="video"ANDheight<400)`. This needs to be URL encoded resulting in the following URL: `http://localhost:8000/channels/1/master.m3u8?filter=%28type%3D%3D%22video%22ANDheight%3E200%29AND%28type%3D%3D%22video%22ANDheight%3C400%29`.
+
+To filter by video bandwidth use the `systemBitrate` keyword in the query, e.g. `(type=="video"ANDsystemBitrate>2121000)AND(type=="video"ANDsystemBitrate<6161000)`.
+
+You can also combine the filter conditions, e.g. `(type=="video"ANDheight>240)AND(type=="video"ANDsystemBitrate<4141000)`
 
 ## API
 

package/engine/session.js

@@ -395,27 +395,27 @@ class Session {
     if (!this._sessionState) {
       throw new Error('Session not ready');
     }
-    const sessionState = await this._sessionState.getValues(["mediaSeq", "discSeq", "vodMediaSeqVideo"]);
+    const sessionState = await this._sessionState.getValues(["vodMediaSeqVideo", "discSeq"]);
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
 
-    /*
-      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;
+      debug(`[${this._sessionId}]: Recently Loaded Next Vod. PlayheadState not up-to-date. Return the last generated m3u8`);
+      const m3u8 = await this._playheadState.getLastM3u8();
+      if (m3u8) {
+        return m3u8;
+      } else {
+        debug(`[${this._sessionId}]: We don't have any previously generated m3u8`);
+      }
     }
 
-    if (playheadState.vodMediaSeqVideo === 0 || this.waitingForNextVod) { 
-      this.waitingForNextVod = false;
+    if (playheadState.vodMediaSeqVideo < 2) { 
       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.`);
+        debug(`[${this._sessionId}]: Not a leader and first|second media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
         await this._sessionState.clearCurrentVodCache(); // force reading up from shared store
       }
     }
+    
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
@@ -461,19 +461,11 @@ class Session {
   }
 
   async incrementAsync() {
-    await this._tickAsync();
+    await this._tickAsync(); 
     const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
     let sessionState = await this._sessionState.getValues(
       ["state", "mediaSeq", "discSeq", "vodMediaSeqVideo", "vodMediaSeqAudio"]);
     let playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo", "vodMediaSeqAudio"]);
-    if (playheadState.vodMediaSeqVideo < 2) {
-      // This is due to the possibility that we miss the tick where vodMediaSeqVideo is 0
-      // The worst case scenario is that we clear cache two times in a row on a switch
-      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.`);
-        await this._sessionState.clearCurrentVodCache(); // force reading up from shared store
-      }
-    }
     let currentVod = await this._sessionState.getCurrentVod();
     if (!currentVod ||
         sessionState.vodMediaSeqVideo === null ||
@@ -512,12 +504,19 @@ class Session {
       sessionState.vodMediaSeqAudio = await this._sessionState.set("vodMediaSeqAudio", currentVod.getLiveMediaSequencesCount() - 1);
       sessionState.state = await this._sessionState.set("state", SessionState.VOD_NEXT_INIT);
     }
+
     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);
     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);
+
+    if (!isLeader && playheadState.vodMediaSeqVideo < 2) {
+      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();
+    }
+
     return m3u8;
   }
 
@@ -740,11 +739,10 @@ 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);
@@ -828,6 +826,10 @@ 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',
@@ -838,10 +840,6 @@ 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

@@ -242,24 +242,28 @@ class SessionLive {
     // Make it possible to add & share new segments
     this.allowedToSet = true;
     const allBws = Object.keys(segments);
-    for (let i = 0; i < allBws.length; i++) {
-      const bw = allBws[i];
-      if (!this.vodSegments[bw]) {
-        this.vodSegments[bw] = [];
-      }
+    if (this._isEmpty(this.vodSegments)) {
+      for (let i = 0; i < allBws.length; i++) {
+        const bw = allBws[i];
+        if (!this.vodSegments[bw]) {
+          this.vodSegments[bw] = [];
+        }
 
-      if (segments[bw][0].discontinuity) {
-        segments[bw].shift();
-      }
+        if (segments[bw][0].discontinuity) {
+          segments[bw].shift();
+        }
 
-      for (let segIdx = 0; segIdx < segments[bw].length; segIdx++) {
-        this.vodSegments[bw].push(segments[bw][segIdx]);
-      }
-      if (!segments[bw][segments[bw].length - 1].discontinuity) {
-        this.vodSegments[bw].push({ discontinuity: true, cue: { in: true } });
-      } else {
-        segments[bw][segments[bw].length - 1]["cue"] = { in: true };
+        for (let segIdx = 0; segIdx < segments[bw].length; segIdx++) {
+          this.vodSegments[bw].push(segments[bw][segIdx]);
+        }
+        if (!segments[bw][segments[bw].length - 1].discontinuity) {
+          this.vodSegments[bw].push({ discontinuity: true, cue: { in: true } });
+        } else {
+          segments[bw][segments[bw].length - 1]["cue"] = { in: true };
+        }
       }
+    } else {
+      debug(`[${this.sessionId}]: 'vodSegments' not empty = Using 'transitSegs'`);
     }
 
     debug(`[${this.sessionId}]: Setting CurrentMediaSequenceSegments. First seg is: [${this.vodSegments[allBws[0]][0].uri}]`);
@@ -301,6 +305,11 @@ class SessionLive {
       if (leadersMediaSeqCount !== null) {
         this.mediaSeqCount = leadersMediaSeqCount;
         debug(`[${this.sessionId}]: Setting mediaSeqCount to: [${this.mediaSeqCount}]`);
+        const transitSegs = await this.sessionLiveState.get("transitSegs");
+        if (!this._isEmpty(transitSegs)) {
+          debug(`[${this.sessionId}]: Getting and loading 'transitSegs'`);
+          this.vodSegments = transitSegs;
+        }
       }
       if (leadersDiscSeqCount !== null) {
         this.discSeqCount = leadersDiscSeqCount;
@@ -644,6 +653,9 @@ class SessionLive {
         // 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);
+        if (isLeader) {
+          this.timerCompensation = false;
+        }
         continue;
       }
 
@@ -1037,7 +1049,6 @@ class SessionLive {
    */
   _addLiveSegmentsToQueue(startIdx, playlistItems, baseUrl, liveTargetBandwidth) {
     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;
@@ -1105,6 +1116,7 @@ class SessionLive {
           seg["daterange"] = daterangeData;
         }
         // Push new Live Segments!
+        debug(`[${this.sessionId}]: Adding Live Segment to Queue (for bw=${liveTargetBandwidth})\n${seg.uri ? seg.uri : ''}`);
         this.liveSegQueue[liveTargetBandwidth].push(seg);
         this.liveSegsForFollowers[liveTargetBandwidth].push(seg);
       }

package/engine/util.js

@@ -1,29 +1,33 @@
-const { version } = require('../package.json');
+const { version } = require("../package.json");
 
 const filterQueryParser = (filterQuery) => {
   const conditions = filterQuery.match(/\(([^\(\)]*?)\)/g);
 
   let filter = {};
+  
+  if (!conditions) {
+    return filter;
+  }
   conditions.map((c) => {
-    const m = c.match(/\(type=="(.*?)"(&&|\|\|)(.*?)(<|>)(.*)\)/);
+    const m = c.match(/\(type=="(.*?)"(AND|\|\|)(.*?)(<|>)(.*)\)/);
     if (m) {
       const type = m[1];
       const operator = m[2];
       const key = m[3];
       const comp = m[4];
       const value = m[5];
-      
+
       if (!filter[type]) {
         filter[type] = {};
       }
-      if (operator === "&&") {
+      if (operator === "AND") {
         if (!filter[type][key]) {
           filter[type][key] = {};
         }
         if (comp === "<") {
-          filter[type][key].high = parseInt(value, 10); 
+          filter[type][key].high = parseInt(value, 10);
         } else if (comp === ">") {
-          filter[type][key].low = parseInt(value, 10); 
+          filter[type][key].low = parseInt(value, 10);
         }
       }
     }
@@ -32,42 +36,85 @@ const filterQueryParser = (filterQuery) => {
 };
 
 const applyFilter = (profiles, filter) => {
-  return profiles.filter(profile => {
-    if (filter.video && filter.video.systemBitrate) {
-      return (profile.bw >= filter.video.systemBitrate.low && 
-        profile.bw <= filter.video.systemBitrate.high);
-    } else if (filter.video && filter.video.height) {
-      return (profile.resolution[1] >= filter.video.height.low &&
-        profile.resolution[1] <= filter.video.height.high);
+  let filteredProfiles = {};
+  const supportedFilterKeys = ["systemBitrate", "height"];
+
+  if (!filter.video) {
+    return profiles;
+  }
+
+  const keys = Object.keys(filter.video);
+  if (supportedFilterKeys.every((supportedKey) => !keys.includes(supportedKey))) {
+    return profiles;
+  }
+
+  if (filter.video.systemBitrate) {
+    filteredProfiles = profiles.filter((profile) => {
+      if (filter.video.systemBitrate.low && filter.video.systemBitrate.high) {
+        return profile.bw >= filter.video.systemBitrate.low && profile.bw <= filter.video.systemBitrate.high;
+      } else if (filter.video.systemBitrate.low && !filter.video.systemBitrate.high) {
+        return profile.bw >= filter.video.systemBitrate.low;
+      } else if (!filter.video.systemBitrate.low && filter.video.systemBitrate.high) {
+        return profile.bw <= filter.video.systemBitrate.high;
+      }
+      return true;
+    });
+  }
+
+  if (filter.video.height) {
+    let toFilter = profiles;
+    if (!ItemIsEmpty(filteredProfiles)) {
+      toFilter = filteredProfiles;
     }
+    filteredProfiles = toFilter.filter((profile) => {
+      if (filter.video.height.low && filter.video.height.high) {
+        return profile.resolution[1] >= filter.video.height.low && profile.resolution[1] <= filter.video.height.high;
+      } else if (filter.video.height.low) {
+        return profile.resolution[1] >= filter.video.height.low;
+      } else if (filter.video.height.high) {
+        return profile.resolution[1] <= filter.video.height.high;
+      }
+      return true;
+    });
+  }
+
+  return filteredProfiles;
+};
+
+const ItemIsEmpty = (obj) => {
+  if (!obj) {
     return true;
-  });
+  }
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      return false;
+    }
+  }
+  return true;
 };
 
 const cloudWatchLog = (silent, type, logEntry) => {
   if (!silent) {
     logEntry.type = type;
-    logEntry.time = (new Date()).toISOString();
+    logEntry.time = new Date().toISOString();
     console.log(JSON.stringify(logEntry));
   }
 };
 
 const m3u8Header = (instanceId) => {
   let m3u8 = "";
-  m3u8 += `## Created with Eyevinn Channel Engine library (version=${version}${instanceId ? "<" + instanceId + ">" : "" })\n`;
+  m3u8 += `## Created with Eyevinn Channel Engine library (version=${version}${instanceId ? "<" + instanceId + ">" : ""})\n`;
   m3u8 += "##    https://www.npmjs.com/package/eyevinn-channel-engine\n";
   return m3u8;
 };
 
 const toHHMMSS = (secs) => {
-  var sec_num = parseInt(secs, 10)
-  var hours   = Math.floor(sec_num / 3600)
-  var minutes = Math.floor(sec_num / 60) % 60
-  var seconds = sec_num % 60
-
-  return [hours,minutes,seconds]
-      .map(v => v < 10 ? "0" + v : v)
-      .join(":")
+  var sec_num = parseInt(secs, 10);
+  var hours = Math.floor(sec_num / 3600);
+  var minutes = Math.floor(sec_num / 60) % 60;
+  var seconds = sec_num % 60;
+
+  return [hours, minutes, seconds].map((v) => (v < 10 ? "0" + v : v)).join(":");
 };
 
 const logerror = (sessionId, err) => {
@@ -81,5 +128,5 @@ module.exports = {
   cloudWatchLog,
   m3u8Header,
   toHHMMSS,
-  logerror
-}
+  logerror,
+};

package/package.json

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

package/spec/engine/util_spec.js

@@ -2,7 +2,7 @@ const { filterQueryParser, applyFilter } = require('../../engine/util.js');
 
 describe("Filter Query parser", () => {
   it("can handle systemBitrate low/high range", () => {
-    const filterQuery = `(type=="video"&&systemBitrate>100000)&&(type=="video"&&systemBitrate<800000)`;
+    const filterQuery = `(type=="video"ANDsystemBitrate>100000)AND(type=="video"ANDsystemBitrate<800000)`;
     const filter = filterQueryParser(filterQuery);
   
     expect(filter.video.systemBitrate.low).toEqual(100000);
@@ -10,12 +10,19 @@ describe("Filter Query parser", () => {
   });
 
   it("can handle resolution low/high range", () => {
-    const filterQuery = `(type=="video"&&height>600)&&(type=="video"&&height<1080)`;
+    const filterQuery = `(type=="video"ANDheight>600)AND(type=="video"ANDheight<1080)`;
     const filter = filterQueryParser(filterQuery);
 
     expect(filter.video.height.low).toEqual(600);
     expect(filter.video.height.high).toEqual(1080);  
   });
+
+  it("can handle a faulty filter query", () => {
+    const filterQuery = `type=video&height=600&type=video&height=1080`;
+    const filter = filterQueryParser(filterQuery);
+
+    expect(filter).toEqual({}); 
+  });
 });
 
 describe("Profile filter", () => {
@@ -60,10 +67,68 @@ describe("Profile filter", () => {
 
   
   it ("can filter out video tracks with height min 200 and max 400", () => {
-    const filterQuery = `(type=="video"&&height>200)&&(type=="video"&&height<400)`;
+    const filterQuery = `(type=="video"ANDheight>200)AND(type=="video"ANDheight<400)`;
+    const filter = filterQueryParser(filterQuery);
+
+    const filteredProfiles = applyFilter(PROFILE, filter);
+    expect(filteredProfiles.length).toEqual(2);
+  });
+
+  it ("can filter out video tracks with bitrate min 1414000 and max 3232000", () => {
+    const filterQuery = `(type=="video"ANDsystemBitrate>1414000)AND(type=="video"ANDsystemBitrate<3232000)`;
+    const filter = filterQueryParser(filterQuery);
+
+    const filteredProfiles = applyFilter(PROFILE, filter);
+    expect(filteredProfiles.length).toEqual(1);
+    expect(filteredProfiles[0].bw).toEqual(2323000);
+  });
+
+  it ("can filter out video tracks with bitrate min 1414000 and height min 300", () => {
+    const filterQuery = `(type=="video"ANDsystemBitrate>1414000)AND(type=="video"ANDheight>300)`;
+    const filter = filterQueryParser(filterQuery);
+
+    const filteredProfiles = applyFilter(PROFILE, filter);
+    expect(filteredProfiles.length).toEqual(1);
+    expect(filteredProfiles[0].bw).toEqual(6134000);
+  });
+
+  it ("can filter out video tracks with bitrate min 1414000", () => {
+    const filterQuery = `(type=="video"ANDsystemBitrate>1414000)`;
     const filter = filterQueryParser(filterQuery);
 
     const filteredProfiles = applyFilter(PROFILE, filter);
     expect(filteredProfiles.length).toEqual(2);
+    expect(filteredProfiles[1].bw).toEqual(2323000);
+    expect(filteredProfiles[0].bw).toEqual(6134000);
+  });
+
+  it ("can filter out video tracks with bitrate max 1414000", () => {
+    const filterQuery = `(type=="video"ANDsystemBitrate<1414000)`;
+    const filter = filterQueryParser(filterQuery);
+
+    const filteredProfiles = applyFilter(PROFILE, filter);
+    expect(filteredProfiles.length).toEqual(1);
+    expect(filteredProfiles[0].bw).toEqual(1313000);
   });
+
+  it ("can filter out video tracks with height min 250", () => {
+    const filterQuery = `(type=="video"ANDheight>250)`;
+    const filter = filterQueryParser(filterQuery);
+
+    const filteredProfiles = applyFilter(PROFILE, filter);
+    expect(filteredProfiles.length).toEqual(2);
+    expect(filteredProfiles[1].bw).toEqual(2323000);
+    expect(filteredProfiles[0].bw).toEqual(6134000);
+  });
+
+  it ("can filter out video tracks with height max 300", () => {
+    const filterQuery = `(type=="video"ANDheight<300)`;
+    const filter = filterQueryParser(filterQuery);
+
+    const filteredProfiles = applyFilter(PROFILE, filter);
+    expect(filteredProfiles.length).toEqual(2);
+    expect(filteredProfiles[1].bw).toEqual(1313000);
+    expect(filteredProfiles[0].bw).toEqual(2323000);
+  });
+
 });