eyevinn-channel-engine 4.2.1 → 4.2.3

package/dist/engine/stream_switcher.d.ts

@@ -26,4 +26,5 @@ declare class StreamSwitcher {
     _loadPreroll(uri: any): Promise<{}>;
     _fetchParseM3u8(uri: any): Promise<any>;
     _mergeSegments(fromSegments: any, toSegments: any, prepend: any): {};
+    _insertTimedMetadata(segments: any, timedMetadata: any): void;
 }

package/dist/engine/stream_switcher.js

@@ -327,6 +327,7 @@ var StreamSwitcher = /** @class */ (function () {
                         // Insert preroll if available for current channel
                         if (this.prerollsCache[this.sessionId]) {
                             prerollSegments = this.prerollsCache[this.sessionId].segments;
+                            this._insertTimedMetadata(prerollSegments, scheduleObj.timedMetadata || {});
                             currVodSegments = this._mergeSegments(prerollSegments, currVodSegments, false);
                         }
                         // In risk that the SL-playhead might have updated some data after
@@ -516,6 +517,7 @@ var StreamSwitcher = /** @class */ (function () {
                         // Insert preroll, if available, for current channel
                         if (this.prerollsCache[this.sessionId]) {
                             prerollSegments = this.prerollsCache[this.sessionId].segments;
+                            this._insertTimedMetadata(prerollSegments, scheduleObj.timedMetadata || {});
                             eventSegments.currMseqSegs = this._mergeSegments(prerollSegments, eventSegments.currMseqSegs, false);
                         }
                         return [4 /*yield*/, sessionLive.setCurrentMediaAndDiscSequenceCount(currLiveCounts.mediaSeq, currLiveCounts.discSeq)];
@@ -808,6 +810,20 @@ var StreamSwitcher = /** @class */ (function () {
         });
         return OUTPUT_SEGMENTS;
     };
+    StreamSwitcher.prototype._insertTimedMetadata = function (segments, timedMetadata) {
+        var bandwidths = Object.keys(segments);
+        debug("[".concat(this.sessionId, "]: Inserting timed metadata ").concat(Object.keys(timedMetadata).join(',')));
+        bandwidths.forEach(function (bw) {
+            var daterangeData = segments[bw][0]["daterange"];
+            if (!daterangeData) {
+                daterangeData = {};
+                Object.keys(timedMetadata).forEach(function (k) {
+                    daterangeData[k] = timedMetadata[k];
+                });
+            }
+            segments[bw][0]["daterange"] = daterangeData;
+        });
+    };
     return StreamSwitcher;
 }());
 module.exports = StreamSwitcher;

package/dist/examples/autocreate.js

@@ -0,0 +1,99 @@
+"use strict";
+/*
+ * Reference implementation of Channel Engine library
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_1 = require("../index");
+var DEFAULT_ASSETS = [
+    {
+        id: 1,
+        title: "Tears of Steel",
+        uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/master.m3u8",
+    },
+    {
+        id: 2,
+        title: "VINN",
+        uri: "https://maitv-vod.lab.eyevinn.technology/VINN.mp4/master.m3u8",
+    },
+];
+var RefAssetManager = /** @class */ (function () {
+    function RefAssetManager(opts) {
+        this.assets = {};
+        this.assets['1'] = DEFAULT_ASSETS;
+        this.pos = {
+            '1': 0,
+        };
+    }
+    /**
+     *
+     * @param {Object} vodRequest
+     *   {
+     *      sessionId,
+     *      category,
+     *      playlistId
+     *   }
+     */
+    RefAssetManager.prototype.getNextVod = function (vodRequest) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var channelId = vodRequest.playlistId;
+            if (_this.pos[channelId] === undefined) {
+                _this.pos[channelId] = 0;
+                _this.assets[channelId] = DEFAULT_ASSETS;
+            }
+            if (_this.assets[channelId]) {
+                var vod = _this.assets[channelId][_this.pos[channelId]++];
+                if (_this.pos[channelId] > _this.assets[channelId].length - 1) {
+                    _this.pos[channelId] = 0;
+                }
+                var vodResponse = {
+                    id: vod.id,
+                    title: vod.title,
+                    uri: vod.uri,
+                };
+                resolve(vodResponse);
+            }
+            else {
+                reject("Invalid channelId provided");
+            }
+        });
+    };
+    return RefAssetManager;
+}());
+var RefChannelManager = /** @class */ (function () {
+    function RefChannelManager() {
+        this.channels = [];
+        this.channels.push({ id: "1", profile: this._getProfile() });
+    }
+    RefChannelManager.prototype.getChannels = function () {
+        //return [ { id: '1', profile: this._getProfile() }, { id: 'faulty', profile: this._getProfile() } ];
+        //return [{ id: "1", profile: this._getProfile() }];
+        return this.channels;
+    };
+    RefChannelManager.prototype.autoCreateChannel = function (channelId) {
+        if (!this.channels.find(function (ch) { return ch.id === channelId; })) {
+            this.channels.push({ id: channelId, profile: this._getProfile() });
+        }
+    };
+    RefChannelManager.prototype._getProfile = function () {
+        return [
+            { bw: 6134000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [1024, 458] },
+            { bw: 2323000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [640, 286] },
+            { bw: 1313000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [480, 214] },
+        ];
+    };
+    return RefChannelManager;
+}());
+var refAssetManager = new RefAssetManager();
+var refChannelManager = new RefChannelManager();
+var engineOptions = {
+    heartbeat: "/",
+    averageSegmentDuration: 2000,
+    channelManager: refChannelManager,
+    autoCreateSession: true,
+    defaultSlateUri: "https://maitv-vod.lab.eyevinn.technology/slate-consuo.mp4/master.m3u8",
+    slateRepetitions: 10,
+};
+var engine = new index_1.ChannelEngine(refAssetManager, engineOptions);
+engine.start();
+engine.listen(process.env.PORT || 8000);

package/dist/{server.js → examples/default.js}

@@ -3,7 +3,7 @@
  * Reference implementation of Channel Engine library
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var index_1 = require("./index");
+var index_1 = require("../index");
 var STITCH_ENDPOINT = process.env.STITCH_ENDPOINT ||
     "http://lambda.eyevinn.technology/stitch/master.m3u8";
 var RefAssetManager = /** @class */ (function () {

package/dist/{server-demux.js → examples/demux.js}

@@ -3,7 +3,7 @@
  * Reference implementation of Channel Engine library using demuxed VOD assets.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var index_1 = require("./index");
+var index_1 = require("../index");
 var RefAssetManager = /** @class */ (function () {
     function RefAssetManager(opts) {
         this.assets = {

package/dist/{server-drm.js → examples/drm.js}

@@ -5,7 +5,7 @@
  * Playback: https://shaka-player-demo.appspot.com/demo/#audiolang=sv-SE;textlang=sv-SE;uilang=sv-SE;asset=http://localhost:8000/channels/1/master.m3u8;license=https://cwip-shaka-proxy.appspot.com/no_auth;panel=CUSTOM%20CONTENT;build=uncompiled
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var index_1 = require("./index");
+var index_1 = require("../index");
 var RefAssetManager = /** @class */ (function () {
     function RefAssetManager(opts) {
         this.assets = {

package/dist/{server-livemix.js → examples/livemix.js}

@@ -3,7 +3,7 @@
  * Reference implementation of Channel Engine library
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var index_1 = require("./index");
+var index_1 = require("../index");
 var uuidv4 = require('uuid').v4;
 var STITCH_ENDPOINT = process.env.STITCH_ENDPOINT || "http://lambda.eyevinn.technology/stitch/master.m3u8";
 var RefAssetManager = /** @class */ (function () {

package/dist/examples/multicodec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{server-multicodec.js → examples/multicodec.js}

@@ -3,7 +3,7 @@
  * Reference implementation of Channel Engine library
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-var index_1 = require("./index");
+var index_1 = require("../index");
 var RefAssetManager = /** @class */ (function () {
     function RefAssetManager(opts) {
         this.assets = {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "description": "OTT TV Channel Engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,9 +10,9 @@
     "test": "jasmine",
     "version:rc": "npm version prerelease --preid=rc",
     "postversion": "git push && git push --tags",
-    "start": "node dist/server.js",
-    "start-demux": "node dist/server-demux.js",
-    "start-livemix": "node dist/server-livemix.js"
+    "start": "node dist/examples/default.js",
+    "start-demux": "node dist/examples/demux.js",
+    "start-livemix": "node dist/examples/livemix.js"
   },
   "engines": {
     "node": ">=14 <20"

package/engine/server.ts

@@ -8,6 +8,7 @@ const SessionLive = require('./session_live.js');
 const StreamSwitcher = require('./stream_switcher.js');
 const EventStream = require('./event_stream.js');
 const SubtitleSlicer = require('./subtitle_slicer.js');
+const { timer }= require('./util.js');
 
 const { SessionStateStore } = require('./session_state.js');
 const { SessionLiveStateStore } = require('./session_live_state.js');
@@ -16,7 +17,7 @@ const { PlayheadStateStore } = require('./playhead_state.js');
 const { filterQueryParser, toHHMMSS, WaitTimeGenerator } = require('./util.js');
 const { version } = require('../package.json');
 
-const timer = ms => new Promise(res => setTimeout(res, ms));
+const AUTO_CREATE_CHANNEL_TIMEOUT = 3000;
 
 const sessions = {}; // Should be a persistent store...
 const sessionsLive = {}; // Should be a persistent store...
@@ -54,6 +55,7 @@ export interface ChannelEngineOpts {
   adXchangeUri?: string; // deprecated
   noSessionDataTags?: boolean;
   volatileKeyTTL?: number;
+  autoCreateSession?: boolean;
 }
 
 interface StreamerOpts {
@@ -85,13 +87,19 @@ export interface VodTimedMetadata {
   'class': string;
 }
 
+export interface LiveTimedMetadata {
+  'id': string;
+  'start-date': string;
+  'x-title'?: string;
+}
+
 export interface VodResponse {
   title: any;
   id: string;
   uri: string;
   offset?: number;
   diffMs?: number;
-  desiredDuraiton?: number;
+  desiredDuration?: number;
   type?: string;
   currentMetadata?: VodResponseMetadata;
   timedMetadata?: VodTimedMetadata;
@@ -142,6 +150,7 @@ export interface SubtitleTracks {
 
 export interface IChannelManager {
   getChannels: () => Channel[];
+  autoCreateChannel?: (channelId: string) => void;
 }
 
 export enum ScheduleStreamType {
@@ -158,6 +167,7 @@ export interface Schedule {
   end_time: number;
   uri: string;
   duration?: number;
+  timedMetadata?: LiveTimedMetadata;
 }
 
 export interface IStreamSwitchManager {
@@ -187,6 +197,7 @@ export class ChannelEngine {
   private logCloudWatchMetrics: boolean;
   private adCopyMgrUri?: string;
   private adXchangeUri?: string;
+  private autoCreateSession: boolean = false;
   
   constructor(assetMgr: IAssetManager, options?: ChannelEngineOpts) {
     this.options = options;
@@ -217,6 +228,9 @@ export class ChannelEngine {
     if (options && options.streamSwitchManager) {
       this.streamSwitchManager = options.streamSwitchManager;
     }
+    if (options && options.autoCreateSession !== undefined) {
+      this.autoCreateSession = options.autoCreateSession;
+    }
     this.assetMgr = assetMgr;
     this.monitorTimer = {};
     this.server = restify.createServer();
@@ -428,6 +442,7 @@ export class ChannelEngine {
   async updateChannelsAsync(channelMgr, options) {
     debug(`Do we have any new channels?`);
     const newChannels = channelMgr.getChannels().filter(channel => !sessions[channel.id]);
+    debug(newChannels);
     const addAsync = async (channel) => {
       debug(`Adding channel with ID ${channel.id}`);
       sessions[channel.id] = new Session(this.assetMgr, {
@@ -472,14 +487,14 @@ export class ChannelEngine {
       await sessions[channel.id].initAsync();
       await sessionsLive[channel.id].initAsync();
       if (!this.monitorTimer[channel.id]) {
-        this.monitorTimer[channel.id] = setInterval(async () => { await this._monitorAsync(sessions[channel.id], sessionsLive[channel.id]) }, 5000);
+        this.monitorTimer[channel.id] = setInterval(async () => { await this._monitorAsync(sessions[channel.id], sessionsLive[channel.id]) }, 5000);
       }
 
       await sessions[channel.id].startPlayheadAsync();
     };
 
     const addLiveAsync = async (channel) => {
-      debug(`Adding channel with ID ${channel.id}`);
+      debug(`Adding live channel with ID ${channel.id}`);
       await sessionsLive[channel.id].initAsync();
       await sessionsLive[channel.id].startPlayheadAsync();
     };
@@ -564,6 +579,16 @@ export class ChannelEngine {
     }
   }
 
+  async createChannel(channelId) {
+    if (!sessions[channelId]) {
+      if (this.options.channelManager.autoCreateChannel) {
+        this.options.channelManager.autoCreateChannel(channelId);
+        setTimeout(async () => { await this.updateChannelsAsync(this.options.channelManager, this.options) });
+        await timer(AUTO_CREATE_CHANNEL_TIMEOUT);
+      }  
+    }
+  }
+
   async getMasterManifest(channelId) {
     if (sessions[channelId]) {
       const session = sessions[channelId];
@@ -679,45 +704,22 @@ export class ChannelEngine {
     if (req.query['category']) {
       options.category = req.query['category'];
     }
+    if (this.autoCreateSession && req.query['channel']) {
+      debug(`Attempting to create channel with id ${req.query['channel']}`);
+      await this.createChannel(req.query['channel']);
+      debug(`Automatically created channel with id ${req.query['channel']}`);
+    }
+
     if (req.query['channel'] && sessions[req.query['channel']]) {
       session = sessions[req.query['channel']];
     } else if (req.query['session'] && sessions[req.query['session']]) {
       session = sessions[req.query['session']];
-    } else {
-      options.adCopyMgrUri = this.adCopyMgrUri;
-      options.adXchangeUri = this.adXchangeUri;
-      options.averageSegmentDuration = this.streamerOpts.defaultAverageSegmentDuration;
-      options.useDemuxedAudio = this.useDemuxedAudio;
-      options.dummySubtitleEndpoint = this.dummySubtitleEndpoint;
-      options.subtitleSliceEndpoint = this.subtitleSliceEndpoint;
-      options.useVTTSubtitles = this.useVTTSubtitles;
-      options.alwaysNewSegments = this.alwaysNewSegments;
-      options.playheadDiffThreshold = this.streamerOpts.defaultPlayheadDiffThreshold;
-      options.maxTickInterval = this.streamerOpts.defaultMaxTickInterval;
-      options.targetDurationPadding = this.streamerOpts.targetDurationPadding;
-      options.forceTargetDuration = this.streamerOpts.forceTargetDuration;
-      options.diffCompensationRate = this.streamerOpts.diffCompensationRate;
-      // if we are initiating a master manifest
-      // outside of specific Channel context,
-      // if slate options are set at the ChannelEngine level, then set these here
-      if (this.defaultSlateUri) {
-        options.slateUri = this.defaultSlateUri;
-      }
-      if (this.slateRepetitions) {
-        options.slateRepetitions = this.slateRepetitions;
-      }
-      if (this.slateDuration) {
-        options.slateDuration = this.slateDuration;
-      }
-      options.disabledPlayhead = true; // disable playhead for personalized streams
-      session = new Session(this.assetMgr, options, this.sessionStore);
-      await session.initAsync();
-      sessions[session.sessionId] = session;
     }
     if (req.query['startWithId']) {
       options.startWithId = req.query['startWithId'];
       debug(`New session to start with assetId=${options.startWithId}`);
     }
+
     if (session) {
       const eventStream = new EventStream(session);
       eventStreams[session.sessionId] = eventStream;

package/engine/session.js

@@ -782,7 +782,7 @@ class Session {
 
     let sessionState = await this._sessionState.getValues(
       ["state", "mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "discSeq", "discSeqAudio", "discSeqSubtitle", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSeqSubtitle"]);
-    let playheadState = await this._playheadState.getValues(["mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSubtitle"]);
+    let playheadState = await this._playheadState.getValues(["mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSubtitle", "playheadRef"]);
     let currentVod = await this._sessionState.getCurrentVod();
     if (!currentVod ||
       sessionState.vodMediaSeqVideo === null ||
@@ -802,9 +802,15 @@ class Session {
     }
     if (sessionState.state === SessionState.VOD_NEXT_INITIATING || sessionState.state === SessionState.VOD_RELOAD_INITIATING) {
       if (isLeader) {
+        const isOldVod = this._isOldVod(playheadState.playheadRef, currentVod.getDuration());
+        let nextState = SessionState.VOD_PLAYING;
+        if (isOldVod) {
+          nextState = SessionState.VOD_NEXT_INIT;
+        }
         const leaderAction = sessionState.state === SessionState.VOD_NEXT_INITIATING ? "initiated" : "reloaded";
-        debug(`[${this._sessionId}]: I am the leader and have just ${leaderAction} next VOD, let's move to VOD_PLAYING`);
-        sessionState.state = await this._sessionState.set("state", SessionState.VOD_PLAYING);
+        const leaderState = nextState === SessionState.VOD_NEXT_INIT ? "VOD_NEXT_INIT" : "VOD_PLAYING";
+        debug(`[${this._sessionId}]: I am the leader and have just ${leaderAction} next VOD, let's move to  ${leaderState}`);
+        sessionState.state = await this._sessionState.set("state", nextState);
       } else {
         debug(`[${this._sessionId}]: Return the last generated m3u8 to give the leader some time`);
         let m3u8 = await this._playheadState.getLastM3u8();
@@ -1325,7 +1331,12 @@ class Session {
                 })
               }
               currentVod = newVod;
-              loadPromise = currentVod.load();
+              if (vodResponse.desiredDuration) {
+                const { mediaManifestLoader, audioManifestLoader} = await this._truncateVod(vodResponse);
+                loadPromise = currentVod.load(null, mediaManifestLoader, audioManifestLoader);
+              } else {
+                loadPromise = currentVod.load();
+              }
             } else {
               if (vodResponse.type === 'gap') {
                 loadPromise = new Promise((resolve, reject) => {
@@ -1434,7 +1445,7 @@ class Session {
         debug(`[${this._sessionId}]: state=VOD_PLAYING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}_${sessionState.vodMediaSeqSubtitle}, ${currentVod.getLiveMediaSequencesCount()}_${currentVod.getLiveMediaSequencesCount("audio")}_${currentVod.getLiveMediaSequencesCount("subtitle")})`);
         return;
       case SessionState.VOD_NEXT_INITIATING:
-        debug(`[${this._sessionId}]: state=VOD_NEXT_INITIATING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}_${sessionState.vodMediaSeqSubtitle}, ${currentVod.getLiveMediaSequencesCount()}_${currentVod.getLiveMediaSequencesCount("audio")}_${currentVod.getLiveMediaSequencesCount("audio")}_${currentVod.getLiveMediaSequencesCount("subtitle")})`);
+        debug(`[${this._sessionId}]: state=VOD_NEXT_INITIATING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}_${sessionState.vodMediaSeqSubtitle}, ${currentVod.getLiveMediaSequencesCount()}_${currentVod.getLiveMediaSequencesCount("audio")}_${currentVod.getLiveMediaSequencesCount("subtitle")})`);
         if (!isLeader) {
           debug(`[${this._sessionId}]: not the leader so just waiting for the VOD to be initiated`);
         }
@@ -1503,7 +1514,12 @@ class Session {
                   title: this.currentMetadata.title || '',
                 }
               });
-              loadPromise = newVod.loadAfter(currentVod);
+              if (vodResponse.desiredDuration) {
+                const { mediaManifestLoader, audioManifestLoader} = await this._truncateVod(vodResponse);
+                loadPromise = newVod.loadAfter(currentVod, null, mediaManifestLoader, audioManifestLoader);
+              } else {
+                loadPromise = newVod.loadAfter(currentVod);
+              }
               if (vodResponse.diffMs) {
                 this.diffCompensation = vodResponse.diffMs;
                 if (this.diffCompensation) {
@@ -1542,7 +1558,7 @@ class Session {
             sessionState.discSeq = await this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity);
             sessionState.discSeqAudio = await this._sessionState.set("discSeqAudio", sessionState.discSeqAudio + lastDiscontinuityAudio);
             sessionState.discSeqSubtitle = await this._sessionState.set("discSeqSubtitle", sessionState.discSeqSubtitle + lastDiscontinuitySubtitle);
-            debug(`[${this._sessionId}]: new sequence data set in store [${sessionState.mediaSeq}][${sessionState.discSeq}]_[${sessionState.mediaSeqSubtitle}][${sessionState.discSeqSubtitle}]_[${sessionState.mediaSeqSubtitle}][${sessionState.discSeqSubtitle}]`);
+            debug(`[${this._sessionId}]: new sequence data set in store V[${sessionState.mediaSeq}][${sessionState.discSeq}]_A[${sessionState.mediaSeqAudio}][${sessionState.discSeqAudio}]_S[${sessionState.mediaSeqSubtitle}][${sessionState.discSeqSubtitle}]`);
             await this._sessionState.remove("nextVod");
             sessionState.currentVod = await this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 });
             this.leaderIsSettingNextVod = false;
@@ -1776,6 +1792,33 @@ class Session {
     });
   }
 
+  _truncateVod(vodResponse) {
+    return new Promise((resolve, reject) => {
+      const truncatedVod = new HLSTruncateVod(vodResponse.uri, vodResponse.desiredDuration / 1000);
+      truncatedVod.load()
+        .then(() => {
+          let audioManifestLoader;
+          const mediaManifestLoader = (bw) => {
+            let mediaManifestStream = new Readable();
+            mediaManifestStream.push(truncatedVod.getMediaManifest(bw));
+            mediaManifestStream.push(null);
+            return mediaManifestStream;
+          };
+          if (this.use_demuxed_audio) {
+            audioManifestLoader = (audioGroupId, audioLanguage) => {
+              let mediaManifestStream = new Readable();
+              mediaManifestStream.push(truncatedVod.getAudioManifest(audioGroupId, audioLanguage));
+              mediaManifestStream.push(null);
+              return mediaManifestStream;
+            };
+          }
+          resolve({ mediaManifestLoader, audioManifestLoader });
+        });
+    });
+
+
+  }
+
   _truncateSlate(afterVod, requestedDuration, vodUri) {
     return new Promise((resolve, reject) => {
       let nexVodUri = null;
@@ -1983,6 +2026,16 @@ class Session {
       return compensationSec;
     }
   }
+
+  _isOldVod(refTs, vodDur) {
+    const TIME_PADDING_MS = 20 * 1000 // 20secs
+    const VOD_DURATION_MS = vodDur * 1000;
+    const TIME_SINCE_VOD_STARTED_MS = (Date.now() - refTs) + TIME_PADDING_MS;
+    if (TIME_SINCE_VOD_STARTED_MS > VOD_DURATION_MS) {
+      return true;
+    }
+    return false;
+  }
 }
 
 module.exports = Session;

package/engine/stream_switcher.js

@@ -238,8 +238,10 @@ class StreamSwitcher {
           // Insert preroll if available for current channel
           if (this.prerollsCache[this.sessionId]) {
             const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            this._insertTimedMetadata(prerollSegments, scheduleObj.timedMetadata || {});
             currVodSegments = this._mergeSegments(prerollSegments, currVodSegments, false);
           }
+
           // In risk that the SL-playhead might have updated some data after
           // we reset last time... we should Reset SessionLive before sending new data.
           await sessionLive.resetLiveStoreAsync(0);
@@ -397,6 +399,7 @@ class StreamSwitcher {
           // Insert preroll, if available, for current channel
           if (this.prerollsCache[this.sessionId]) {
             const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            this._insertTimedMetadata(prerollSegments, scheduleObj.timedMetadata || {});
             eventSegments.currMseqSegs = this._mergeSegments(prerollSegments, eventSegments.currMseqSegs, false);
           }
 
@@ -639,6 +642,21 @@ class StreamSwitcher {
     });
     return OUTPUT_SEGMENTS;
   }
+
+  _insertTimedMetadata(segments, timedMetadata) {
+    const bandwidths = Object.keys(segments);
+    debug(`[${this.sessionId}]: Inserting timed metadata ${Object.keys(timedMetadata).join(',')}`);
+    bandwidths.forEach((bw) => {
+      let daterangeData = segments[bw][0]["daterange"];
+      if (!daterangeData) {
+        daterangeData = {};
+        Object.keys(timedMetadata).forEach((k) => {
+          daterangeData[k] = timedMetadata[k];
+        });
+      }
+      segments[bw][0]["daterange"] = daterangeData;
+    });
+  }
 }
 
 module.exports = StreamSwitcher;

package/examples/autocreate.ts

@@ -0,0 +1,112 @@
+/*
+ * Reference implementation of Channel Engine library
+ */
+
+import { ChannelEngine, ChannelEngineOpts, 
+  IAssetManager, IChannelManager, 
+  VodRequest, VodResponse, Channel, ChannelProfile
+} from "../index";
+
+const DEFAULT_ASSETS = [
+  {
+    id: 1,
+    title: "Tears of Steel",
+    uri: "https://maitv-vod.lab.eyevinn.technology/tearsofsteel_4k.mov/master.m3u8",
+  },
+  {
+    id: 2,
+    title: "VINN",
+    uri: "https://maitv-vod.lab.eyevinn.technology/VINN.mp4/master.m3u8",
+  },
+];
+
+class RefAssetManager implements IAssetManager {
+  private assets;
+  private pos;
+
+  constructor(opts?) {
+    this.assets = {};
+    this.assets['1'] = DEFAULT_ASSETS;
+    this.pos = {
+      '1': 0,
+    };
+  }
+
+  /**
+   *
+   * @param {Object} vodRequest
+   *   {
+   *      sessionId,
+   *      category,
+   *      playlistId
+   *   }
+   */
+  getNextVod(vodRequest: VodRequest): Promise<VodResponse> {
+    return new Promise((resolve, reject) => {
+      const channelId = vodRequest.playlistId;
+      if (this.pos[channelId] === undefined) {
+        this.pos[channelId] = 0;
+        this.assets[channelId] = DEFAULT_ASSETS;
+      }
+      if (this.assets[channelId]) {
+        let vod = this.assets[channelId][this.pos[channelId]++];
+        if (this.pos[channelId] > this.assets[channelId].length - 1) {
+          this.pos[channelId] = 0;
+        }
+        const vodResponse = {
+          id: vod.id,
+          title: vod.title,
+          uri: vod.uri,
+        };
+        resolve(vodResponse);
+      } else {
+        reject("Invalid channelId provided");
+      }
+    });
+  }
+}
+
+class RefChannelManager implements IChannelManager {
+  private channels: Channel[] = [];
+
+  constructor() {
+    this.channels.push({ id: "1", profile: this._getProfile() });
+  }
+
+  getChannels(): Channel[] {
+    //return [ { id: '1', profile: this._getProfile() }, { id: 'faulty', profile: this._getProfile() } ];
+    //return [{ id: "1", profile: this._getProfile() }];
+    return this.channels;
+  }
+
+  autoCreateChannel(channelId: string) {
+    if (!this.channels.find((ch) => ch.id === channelId)) {      
+      this.channels.push({ id: channelId, profile: this._getProfile() });
+    }
+  }
+
+  _getProfile(): ChannelProfile[] {
+    return [
+      { bw: 6134000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [1024, 458] },
+      { bw: 2323000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [640, 286] },
+      { bw: 1313000, codecs: "avc1.4d001f,mp4a.40.2", resolution: [480, 214] },
+    ];
+  }
+}
+
+const refAssetManager = new RefAssetManager();
+const refChannelManager = new RefChannelManager();
+
+const engineOptions: ChannelEngineOpts = {
+  heartbeat: "/",
+  averageSegmentDuration: 2000,
+  channelManager: refChannelManager,
+  autoCreateSession: true,
+  defaultSlateUri:
+    "https://maitv-vod.lab.eyevinn.technology/slate-consuo.mp4/master.m3u8",
+  slateRepetitions: 10,
+};
+
+const engine = new ChannelEngine(refAssetManager, engineOptions);
+engine.start();
+engine.listen(process.env.PORT || 8000);