eyevinn-channel-engine 3.1.3 → 3.1.6

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

@@ -44,6 +44,8 @@ class Session {
     this.maxTickInterval = DEFAULT_MAX_TICK_INTERVAL;
     this.diffCompensation = null;
     this.waitingForNextVod = false;
+    this.leaderIsSettingNextVod = false;
+    this.isSwitchingBackFromLive = false;
 
     if (config) {
       if (config.sessionId) {
@@ -258,6 +260,8 @@ class Session {
       throw new Error('Session not ready');
     }
 
+    this.isSwitchingBackFromLive = true;
+
     let isLeader = await this._sessionStateStore.isLeader(this._instanceId);
     if (!isLeader) {
       debug(`[${this._sessionId}]: FOLLOWER: Invalidate cache to ensure having the correct VOD!`);
@@ -278,6 +282,7 @@ class Session {
       if (!isLeader || vodReloaded) {
         debug(`[${this._sessionId}]: FOLLOWER: leader is alive, and has presumably updated currentVod. Clearing the cache now`);
         await this._sessionState.clearCurrentVodCache();
+        this.isSwitchingBackFromLive = false;
         return;
       }
     }
@@ -313,6 +318,7 @@ class Session {
       await this._playheadState.set("vodMediaSeqAudio", 0);
       await this._playheadState.set("playheadRef", Date.now());
     }
+    this.isSwitchingBackFromLive = false;
   }
 
   async getCurrentMediaSequenceSegments() {
@@ -350,6 +356,9 @@ class Session {
     if (!this._sessionState) {
       throw new Error('Session not ready');
     }
+    
+    this.isSwitchingBackFromLive = true;
+
     const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
     if (isLeader) {
       await this._sessionState.set("mediaSeq", _mediaSeq);
@@ -357,6 +366,7 @@ class Session {
       await this._sessionState.set("discSeq", _discSeq);
       debug(`[${this._sessionId}]: Setting current media and discontinuity count -> [${_mediaSeq}]:[${_discSeq}]`);
     }
+    this.isSwitchingBackFromLive = false;
   }
 
   async getCurrentMediaAndDiscSequenceCount() {
@@ -395,16 +405,36 @@ class Session {
     if (!this._sessionState) {
       throw new Error('Session not ready');
     }
-    const sessionState = await this._sessionState.getValues(["discSeq"]);
+    // Be sure that the leader is not in the middle of setting new vod data in store.
+    // Followers will never run this part...
+    let tries = 4;
+    while(tries > 0 && this.leaderIsSettingNextVod) {
+      debug(`[${this._sessionId}]: Leader is setting the next vod. Waiting 500ms_${tries}`);
+      await timer(500);
+      tries--;
+    }
+
+    const sessionState = await this._sessionState.getValues(["vodMediaSeqVideo", "discSeq"]);
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
 
-    if (playheadState.vodMediaSeqVideo === 0) { 
+    if (playheadState.vodMediaSeqVideo > sessionState.vodMediaSeqVideo) {
+      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 < 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 {
@@ -450,8 +480,16 @@ class Session {
   }
 
   async incrementAsync() {
-    await this._tickAsync();
+    await this._tickAsync(); 
     const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
+    // Avoid reading old values if new ones are on their way...
+    let tries = 10;
+    while (tries > 0 && this.isSwitchingBackFromLive) {
+      debug(`[${this._sessionId}]: Leader is currently setting new data in store. Waiting 500ms_${tries}`);
+      await timer(500);
+      tries--;
+    }
+
     let sessionState = await this._sessionState.getValues(
       ["state", "mediaSeq", "discSeq", "vodMediaSeqVideo", "vodMediaSeqAudio"]);
     let playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo", "vodMediaSeqAudio"]);
@@ -487,12 +525,13 @@ class Session {
       sessionState.vodMediaSeqVideo = await this._sessionState.increment("vodMediaSeqVideo");
       sessionState.vodMediaSeqAudio = await this._sessionState.increment("vodMediaSeqAudio");
     }
-
+    
     if (sessionState.vodMediaSeqVideo >= currentVod.getLiveMediaSequencesCount() - 1) {
       sessionState.vodMediaSeqVideo = await this._sessionState.set("vodMediaSeqVideo", currentVod.getLiveMediaSequencesCount() - 1);
       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);
@@ -727,11 +766,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);
@@ -815,6 +853,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',
@@ -825,10 +867,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 {
@@ -932,16 +970,19 @@ class Session {
             await ChaosMonkey.loadVod(loadPromise);
             cloudWatchLog(!this.cloudWatchLogging, 'engine-session',
               { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
+            this.leaderIsSettingNextVod = true;
             debug(`[${this._sessionId}]: next VOD loaded (${newVod.getDeltaTimes()})`);
             debug(`[${this._sessionId}]: ${newVod.getPlayheadPositions()}`);
             currentVod = newVod;
             debug(`[${this._sessionId}]: msequences=${currentVod.getLiveMediaSequencesCount()}`);
-            await this._sessionState.remove("nextVod");
-            sessionState.currentVod = await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
             sessionState.vodMediaSeqVideo = await this._sessionState.set("vodMediaSeqVideo", 0);
             sessionState.vodMediaSeqAudio = await this._sessionState.set("vodMediaSeqAudio", 0);
             sessionState.mediaSeq = await this._sessionState.set("mediaSeq", sessionState.mediaSeq + length);
             sessionState.discSeq = await this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity);
+            debug(`[${this._sessionId}]: new sequence data set in store [${sessionState.mediaSeq}][${sessionState.discSeq}]`);
+            await this._sessionState.remove("nextVod");
+            sessionState.currentVod = await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
+            this.leaderIsSettingNextVod = false;
             await this._playheadState.set("playheadRef", Date.now());
             this.produceEvent({
               type: 'NOW_PLAYING',

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 (segments[bw][0].discontinuity) {
-        segments[bw].shift();
-      }
+    if (this._isEmpty(this.vodSegments)) {
+      for (let i = 0; i < allBws.length; i++) {
+        const bw = allBws[i];
+        if (!this.vodSegments[bw]) {
+          this.vodSegments[bw] = [];
+        }
 
-      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 };
+        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 };
+        }
       }
+    } 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;
@@ -1040,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;
@@ -1108,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.3",
+  "version": "3.1.6",
   "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);
+  });
+
 });