eyevinn-channel-engine 4.2.2 → 4.2.4

package/dist/engine/server.d.ts

@@ -55,7 +55,7 @@ export interface VodResponse {
     uri: string;
     offset?: number;
     diffMs?: number;
-    desiredDuraiton?: number;
+    desiredDuration?: number;
     type?: string;
     currentMetadata?: VodResponseMetadata;
     timedMetadata?: VodTimedMetadata;

package/dist/engine/session.d.ts

@@ -107,6 +107,7 @@ declare class Session {
     _tickAsync(): Promise<void>;
     _getNextVod(): Promise<any>;
     _loadSlate(afterVod: any, reps: any): Promise<any>;
+    _truncateVod(vodResponse: any): Promise<any>;
     _truncateSlate(afterVod: any, requestedDuration: any, vodUri: any): Promise<any>;
     _fillGap(afterVod: any, desiredDuration: any): Promise<any>;
     _getNextVodById(id: any): Promise<any>;

package/dist/engine/session.js

@@ -1768,19 +1768,19 @@ var Session = /** @class */ (function () {
     };
     Session.prototype._tickAsync = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var newVod, sessionState, isLeader, currentVod, vodResponse, _a, nextVodPromise, nextVodStart, _b, loadPromise, hlsOpts, loadStart, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, err_7, _r, length_1, endMseqValue, endMseqValueAudio, endMseqValueSubtitle, lastDiscontinuity, lastDiscontinuityAudio, lastDiscontinuitySubtitle, _s, vodPromise, gracePeriod, nextVodStart, _t, loadPromise, hlsOpts, loadStart, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, diffMs, err_8, startTS, _6, mSeq, currentVod_2, dSeq, mSeqOffset, reloadBehind, segments, playheadState, nextMseq, _7, err_9;
+            var newVod, sessionState, isLeader, currentVod, vodResponse, _a, nextVodPromise, nextVodStart, _b, loadPromise, hlsOpts, _c, mediaManifestLoader, audioManifestLoader, loadStart, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, err_7, _s, length_1, endMseqValue, endMseqValueAudio, endMseqValueSubtitle, lastDiscontinuity, lastDiscontinuityAudio, lastDiscontinuitySubtitle, _t, vodPromise, gracePeriod, nextVodStart, _u, loadPromise, hlsOpts, _v, mediaManifestLoader, audioManifestLoader, loadStart, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, diffMs, err_8, startTS, _8, mSeq, currentVod_2, dSeq, mSeqOffset, reloadBehind, segments, playheadState, nextMseq, _9, err_9;
             var _this = this;
-            return __generator(this, function (_8) {
-                switch (_8.label) {
+            return __generator(this, function (_10) {
+                switch (_10.label) {
                     case 0: return [4 /*yield*/, this._sessionState.getValues(["state", "assetId", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSeqSubtitle", "mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "discSeq", "discSeqAudio", "discSeqSubtitle", "nextVod"])];
                     case 1:
-                        sessionState = _8.sent();
+                        sessionState = _10.sent();
                         return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
                     case 2:
-                        isLeader = _8.sent();
+                        isLeader = _10.sent();
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
                     case 3:
-                        currentVod = _8.sent();
+                        currentVod = _10.sent();
                         if (!sessionState.state) {
                             sessionState.state = SessionState.VOD_INIT;
                         }
@@ -1788,23 +1788,23 @@ var Session = /** @class */ (function () {
                         switch (_a) {
                             case SessionState.VOD_INIT: return [3 /*break*/, 4];
                             case SessionState.VOD_INIT_BY_ID: return [3 /*break*/, 4];
-                            case SessionState.VOD_PLAYING: return [3 /*break*/, 30];
-                            case SessionState.VOD_NEXT_INITIATING: return [3 /*break*/, 36];
-                            case SessionState.VOD_NEXT_INIT: return [3 /*break*/, 37];
-                            case SessionState.VOD_RELOAD_INIT: return [3 /*break*/, 68];
-                            case SessionState.VOD_RELOAD_INITIATING: return [3 /*break*/, 90];
+                            case SessionState.VOD_PLAYING: return [3 /*break*/, 35];
+                            case SessionState.VOD_NEXT_INITIATING: return [3 /*break*/, 41];
+                            case SessionState.VOD_NEXT_INIT: return [3 /*break*/, 42];
+                            case SessionState.VOD_RELOAD_INIT: return [3 /*break*/, 78];
+                            case SessionState.VOD_RELOAD_INITIATING: return [3 /*break*/, 100];
                         }
-                        return [3 /*break*/, 94];
+                        return [3 /*break*/, 104];
                     case 4:
-                        _8.trys.push([4, 27, , 30]);
+                        _10.trys.push([4, 32, , 35]);
                         // Needed if store was reset
                         return [4 /*yield*/, this._sessionStateStore.clearLeaderCache()];
                     case 5:
                         // Needed if store was reset
-                        _8.sent();
+                        _10.sent();
                         return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
                     case 6:
-                        isLeader = _8.sent();
+                        isLeader = _10.sent();
                         nextVodPromise = void 0;
                         if (sessionState.state === SessionState.VOD_INIT) {
                             debug("[".concat(this._sessionId, "]: state=VOD_INIT"));
@@ -1814,96 +1814,105 @@ var Session = /** @class */ (function () {
                             debug("[".concat(this._sessionId, "]: state=VOD_INIT_BY_ID ").concat(sessionState.assetId));
                             nextVodPromise = this._getNextVodById(sessionState.assetId);
                         }
-                        if (!isLeader) return [3 /*break*/, 23];
+                        if (!isLeader) return [3 /*break*/, 28];
                         nextVodStart = Date.now();
                         return [4 /*yield*/, nextVodPromise];
                     case 7:
-                        vodResponse = _8.sent();
+                        vodResponse = _10.sent();
                         _b = sessionState;
                         return [4 /*yield*/, this._sessionState.set("nextVod", vodResponse)];
                     case 8:
-                        _b.nextVod = _8.sent();
+                        _b.nextVod = _10.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'nextVod', channel: this._sessionId, reqTimeMs: Date.now() - nextVodStart });
                         loadPromise = void 0;
-                        if (!vodResponse.type) {
-                            debug("[".concat(this._sessionId, "]: got first VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset || 0));
-                            hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments,
-                                forcedDemuxMode: this.use_demuxed_audio,
-                                dummySubtitleEndpoint: this.dummySubtitleEndpoint,
-                                subtitleSliceEndpoint: this.subtitleSliceEndpoint,
-                                shouldContainSubtitles: this.use_vtt_subtitles,
-                                expectedSubtitleTracks: this._subtitleTracks
-                            };
-                            newVod = new HLSVod(vodResponse.uri, [], vodResponse.unixTs, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
-                            if (vodResponse.timedMetadata) {
-                                Object.keys(vodResponse.timedMetadata).map(function (k) {
-                                    newVod.addMetadata(k, vodResponse.timedMetadata[k]);
-                                });
-                            }
-                            currentVod = newVod;
-                            loadPromise = currentVod.load();
+                        if (!!vodResponse.type) return [3 /*break*/, 12];
+                        debug("[".concat(this._sessionId, "]: got first VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset || 0));
+                        hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments,
+                            forcedDemuxMode: this.use_demuxed_audio,
+                            dummySubtitleEndpoint: this.dummySubtitleEndpoint,
+                            subtitleSliceEndpoint: this.subtitleSliceEndpoint,
+                            shouldContainSubtitles: this.use_vtt_subtitles,
+                            expectedSubtitleTracks: this._subtitleTracks
+                        };
+                        newVod = new HLSVod(vodResponse.uri, [], vodResponse.unixTs, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
+                        if (vodResponse.timedMetadata) {
+                            Object.keys(vodResponse.timedMetadata).map(function (k) {
+                                newVod.addMetadata(k, vodResponse.timedMetadata[k]);
+                            });
                         }
-                        else {
-                            if (vodResponse.type === 'gap') {
-                                loadPromise = new Promise(function (resolve, reject) {
-                                    _this._fillGap(null, vodResponse.desiredDuration)
-                                        .then(function (gapVod) {
-                                        currentVod = gapVod;
-                                        resolve(gapVod);
-                                    }).catch(reject);
-                                });
-                            }
+                        currentVod = newVod;
+                        if (!vodResponse.desiredDuration) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this._truncateVod(vodResponse)];
+                    case 9:
+                        _c = _10.sent(), mediaManifestLoader = _c.mediaManifestLoader, audioManifestLoader = _c.audioManifestLoader;
+                        loadPromise = currentVod.load(null, mediaManifestLoader, audioManifestLoader);
+                        return [3 /*break*/, 11];
+                    case 10:
+                        loadPromise = currentVod.load();
+                        _10.label = 11;
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        if (vodResponse.type === 'gap') {
+                            loadPromise = new Promise(function (resolve, reject) {
+                                _this._fillGap(null, vodResponse.desiredDuration)
+                                    .then(function (gapVod) {
+                                    currentVod = gapVod;
+                                    resolve(gapVod);
+                                }).catch(reject);
+                            });
                         }
+                        _10.label = 13;
+                    case 13:
                         loadStart = Date.now();
                         return [4 /*yield*/, loadPromise];
-                    case 9:
-                        _8.sent();
+                    case 14:
+                        _10.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
                         debug("[".concat(this._sessionId, "]: first VOD loaded"));
                         debug("[".concat(this._sessionId, "]: ").concat(currentVod.getDeltaTimes()));
                         debug("[".concat(this._sessionId, "]: playhead positions [V]=").concat(currentVod.getPlayheadPositions("video")));
                         debug("[".concat(this._sessionId, "]: playhead positions [A]=").concat(currentVod.getPlayheadPositions("audio")));
                         //debug(newVod);
-                        _c = sessionState;
+                        _d = sessionState;
                         return [4 /*yield*/, this._sessionState.set("mediaSeq", 0)];
-                    case 10:
+                    case 15:
                         //debug(newVod);
-                        _c.mediaSeq = _8.sent();
-                        _d = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("mediaSeqAudio", 0)];
-                    case 11:
-                        _d.mediaSeqAudio = _8.sent();
+                        _d.mediaSeq = _10.sent();
                         _e = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("mediaSeqSubtitle", 0)];
-                    case 12:
-                        _e.mediaSeqSubtitle = _8.sent();
+                        return [4 /*yield*/, this._sessionState.set("mediaSeqAudio", 0)];
+                    case 16:
+                        _e.mediaSeqAudio = _10.sent();
                         _f = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("discSeq", 0)];
-                    case 13:
-                        _f.discSeq = _8.sent();
+                        return [4 /*yield*/, this._sessionState.set("mediaSeqSubtitle", 0)];
+                    case 17:
+                        _f.mediaSeqSubtitle = _10.sent();
                         _g = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("discSeqAudio", 0)];
-                    case 14:
-                        _g.discSeqAudio = _8.sent();
+                        return [4 /*yield*/, this._sessionState.set("discSeq", 0)];
+                    case 18:
+                        _g.discSeq = _10.sent();
                         _h = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("discSeqSubtitle", 0)];
-                    case 15:
-                        _h.discSeqSubtitle = _8.sent();
+                        return [4 /*yield*/, this._sessionState.set("discSeqAudio", 0)];
+                    case 19:
+                        _h.discSeqAudio = _10.sent();
                         _j = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
-                    case 16:
-                        _j.vodMediaSeqVideo = _8.sent();
+                        return [4 /*yield*/, this._sessionState.set("discSeqSubtitle", 0)];
+                    case 20:
+                        _j.discSeqSubtitle = _10.sent();
                         _k = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
-                    case 17:
-                        _k.vodMediaSeqAudio = _8.sent();
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
+                    case 21:
+                        _k.vodMediaSeqVideo = _10.sent();
                         _l = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
+                    case 22:
+                        _l.vodMediaSeqAudio = _10.sent();
+                        _m = sessionState;
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqSubtitle", 0)];
-                    case 18:
-                        _l.vodMediaSeqSubtitle = _8.sent();
+                    case 23:
+                        _m.vodMediaSeqSubtitle = _10.sent();
                         return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now(), isLeader)];
-                    case 19:
-                        _8.sent();
+                    case 24:
+                        _10.sent();
                         this.produceEvent({
                             type: 'NOW_PLAYING',
                             data: {
@@ -1911,32 +1920,32 @@ var Session = /** @class */ (function () {
                                 title: this.currentMetadata.title,
                             }
                         });
-                        _m = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
-                    case 20:
-                        _m.state = _8.sent();
                         _o = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 25:
+                        _o.state = _10.sent();
+                        _p = sessionState;
                         return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 })];
-                    case 21:
-                        _o.currentVod = _8.sent();
+                    case 26:
+                        _p.currentVod = _10.sent();
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 22:
-                        _8.sent();
+                    case 27:
+                        _10.sent();
                         return [2 /*return*/];
-                    case 23:
+                    case 28:
                         debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_PLAYING"));
-                        _p = sessionState;
-                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
-                    case 24:
-                        _p.state = _8.sent();
                         _q = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 29:
+                        _q.state = _10.sent();
+                        _r = sessionState;
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 25:
-                        _q.currentVod = _8.sent();
+                    case 30:
+                        _r.currentVod = _10.sent();
                         return [2 /*return*/];
-                    case 26: return [3 /*break*/, 30];
-                    case 27:
-                        err_7 = _8.sent();
+                    case 31: return [3 /*break*/, 35];
+                    case 32:
+                        err_7 = _10.sent();
                         console.error("[".concat(this._sessionId, "]: Failed to init first VOD"));
                         if (this._assetManager.handleError) {
                             this._assetManager.handleError(new Error("Failed to init first VOD"), vodResponse);
@@ -1944,18 +1953,18 @@ var Session = /** @class */ (function () {
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'firstvod', channel: this._sessionId, err: err_7, vod: vodResponse });
                         debug(err_7);
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 28:
-                        _8.sent();
+                    case 33:
+                        _10.sent();
                         return [4 /*yield*/, this._insertSlate(currentVod)];
-                    case 29:
-                        currentVod = _8.sent();
+                    case 34:
+                        currentVod = _10.sent();
                         if (!currentVod) {
                             debug("No slate to load");
                             throw err_7;
                         }
-                        return [3 /*break*/, 30];
-                    case 30:
-                        if (!isLeader) return [3 /*break*/, 34];
+                        return [3 /*break*/, 35];
+                    case 35:
+                        if (!isLeader) return [3 /*break*/, 39];
                         // Handle edge case where store has been reset, but leader has not cleared cache.
                         if (this.prevVodMediaSeq.video === null) {
                             this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
@@ -1979,20 +1988,20 @@ var Session = /** @class */ (function () {
                                 this.prevMediaSeqOffset.subtitle = sessionState.mediaSeqSubtitle;
                             }
                         }
-                        if (!(sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video)) return [3 /*break*/, 33];
+                        if (!(sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video)) return [3 /*break*/, 38];
                         debug("[".concat(this._sessionId, "]: state=VOD_PLAYING, current[").concat(sessionState.vodMediaSeqVideo, "], prev[").concat(this.prevVodMediaSeq.video, "], total[").concat(currentVod.getLiveMediaSequencesCount(), "]"));
                         return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
-                    case 31:
-                        _8.sent();
+                    case 36:
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 32:
-                        currentVod = _8.sent();
+                    case 37:
+                        currentVod = _10.sent();
                         this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
                         this.prevVodMediaSeq.audio = sessionState.vodMediaSeqAudio;
                         this.prevVodMediaSeq.subtitle = sessionState.vodMediaSeqSubtitle;
-                        _8.label = 33;
-                    case 33: return [3 /*break*/, 35];
-                    case 34:
+                        _10.label = 38;
+                    case 38: return [3 /*break*/, 40];
+                    case 39:
                         // Handle edge case where Leader loaded next vod but Follower remained in state=VOD_PLAYING
                         if ((this.prevMediaSeqOffset.video !== null) & (sessionState.mediaSeq !== this.prevMediaSeqOffset.video)) {
                             debug("[".concat(this._sessionId, "]: state=VOD_PLAYING, current[").concat(sessionState.vodMediaSeqVideo, "], prev[").concat(this.prevVodMediaSeq.video, "], total[").concat(currentVod.getLiveMediaSequencesCount(), "]"));
@@ -2000,11 +2009,11 @@ var Session = /** @class */ (function () {
                             // Allow Follower to clear VodCache...
                             this.isAllowedToClearVodCache = true;
                         }
-                        _8.label = 35;
-                    case 35:
+                        _10.label = 40;
+                    case 40:
                         debug("[".concat(this._sessionId, "]: state=VOD_PLAYING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, "_").concat(sessionState.vodMediaSeqSubtitle, ", ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio"), "_").concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")"));
                         return [2 /*return*/];
-                    case 36:
+                    case 41:
                         debug("[".concat(this._sessionId, "]: state=VOD_NEXT_INITIATING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, "_").concat(sessionState.vodMediaSeqSubtitle, ", ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio"), "_").concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")"));
                         if (!isLeader) {
                             debug("[".concat(this._sessionId, "]: not the leader so just waiting for the VOD to be initiated"));
@@ -2012,18 +2021,18 @@ var Session = /** @class */ (function () {
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
                         return [2 /*return*/];
-                    case 37:
-                        _8.trys.push([37, 64, , 67]);
+                    case 42:
+                        _10.trys.push([42, 74, , 77]);
                         debug("[".concat(this._sessionId, "]: state=VOD_NEXT_INIT"));
-                        if (!isLeader) return [3 /*break*/, 59];
-                        if (!!currentVod) return [3 /*break*/, 39];
+                        if (!isLeader) return [3 /*break*/, 69];
+                        if (!!currentVod) return [3 /*break*/, 44];
                         debug("[".concat(this._sessionId, "]: no VOD to append to, assume first VOD to init"));
-                        _r = sessionState;
+                        _s = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_INIT)];
-                    case 38:
-                        _r.state = _8.sent();
+                    case 43:
+                        _s.state = _10.sent();
                         return [2 /*return*/];
-                    case 39:
+                    case 44:
                         length_1 = currentVod.getLiveMediaSequencesCount();
                         endMseqValue = void 0;
                         endMseqValueAudio = void 0;
@@ -2041,77 +2050,87 @@ var Session = /** @class */ (function () {
                         lastDiscontinuity = currentVod.getLastDiscontinuity();
                         lastDiscontinuityAudio = currentVod.getLastDiscontinuityAudio();
                         lastDiscontinuitySubtitle = currentVod.getLastDiscontinuitySubtitle();
-                        _s = sessionState;
+                        _t = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
-                    case 40:
-                        _s.state = _8.sent();
+                    case 45:
+                        _t.state = _10.sent();
                         vodPromise = this._getNextVod();
-                        if (!(length_1 === 1)) return [3 /*break*/, 42];
+                        if (!(length_1 === 1)) return [3 /*break*/, 47];
                         gracePeriod = (this.averageSegmentDuration / 2);
                         debug("[".concat(this._sessionId, "]: adding a grace period before calling nextVod: ").concat(gracePeriod, "ms"));
                         return [4 /*yield*/, timer(gracePeriod)];
-                    case 41:
-                        _8.sent();
-                        _8.label = 42;
-                    case 42:
+                    case 46:
+                        _10.sent();
+                        _10.label = 47;
+                    case 47:
                         nextVodStart = Date.now();
                         return [4 /*yield*/, vodPromise];
-                    case 43:
-                        vodResponse = _8.sent();
-                        _t = sessionState;
+                    case 48:
+                        vodResponse = _10.sent();
+                        _u = sessionState;
                         return [4 /*yield*/, this._sessionState.set("nextVod", vodResponse)];
-                    case 44:
-                        _t.nextVod = _8.sent();
+                    case 49:
+                        _u.nextVod = _10.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'nextVod', channel: this._sessionId, reqTimeMs: Date.now() - nextVodStart });
                         loadPromise = void 0;
-                        if (!vodResponse.type) {
-                            debug("[".concat(this._sessionId, "]: got next VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset));
-                            hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments,
-                                forcedDemuxMode: this.use_demuxed_audio,
-                                dummySubtitleEndpoint: this.dummySubtitleEndpoint,
-                                subtitleSliceEndpoint: this.subtitleSliceEndpoint,
-                                shouldContainSubtitles: this.use_vtt_subtitles,
-                                expectedSubtitleTracks: this._subtitleTracks
-                            };
-                            newVod = new HLSVod(vodResponse.uri, null, vodResponse.unixTs, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
-                            if (vodResponse.timedMetadata) {
-                                Object.keys(vodResponse.timedMetadata).map(function (k) {
-                                    newVod.addMetadata(k, vodResponse.timedMetadata[k]);
-                                });
-                            }
-                            this.produceEvent({
-                                type: 'NEXT_VOD_SELECTED',
-                                data: {
-                                    id: this.currentMetadata.id,
-                                    uri: vodResponse.uri,
-                                    title: this.currentMetadata.title || '',
-                                }
+                        if (!!vodResponse.type) return [3 /*break*/, 53];
+                        debug("[".concat(this._sessionId, "]: got next VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset));
+                        hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments,
+                            forcedDemuxMode: this.use_demuxed_audio,
+                            dummySubtitleEndpoint: this.dummySubtitleEndpoint,
+                            subtitleSliceEndpoint: this.subtitleSliceEndpoint,
+                            shouldContainSubtitles: this.use_vtt_subtitles,
+                            expectedSubtitleTracks: this._subtitleTracks
+                        };
+                        newVod = new HLSVod(vodResponse.uri, null, vodResponse.unixTs, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
+                        if (vodResponse.timedMetadata) {
+                            Object.keys(vodResponse.timedMetadata).map(function (k) {
+                                newVod.addMetadata(k, vodResponse.timedMetadata[k]);
                             });
-                            loadPromise = newVod.loadAfter(currentVod);
-                            if (vodResponse.diffMs) {
-                                this.diffCompensation = vodResponse.diffMs;
-                                if (this.diffCompensation) {
-                                    this.timePositionOffset = this.diffCompensation;
-                                    cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
-                                }
-                                else {
-                                    this.timePositionOffset = 0;
-                                }
-                            }
                         }
-                        else {
-                            loadPromise = new Promise(function (resolve, reject) {
-                                _this._fillGap(currentVod, vodResponse.desiredDuration)
-                                    .then(function (gapVod) {
-                                    newVod = gapVod;
-                                    resolve(newVod);
-                                }).catch(reject);
-                            });
+                        this.produceEvent({
+                            type: 'NEXT_VOD_SELECTED',
+                            data: {
+                                id: this.currentMetadata.id,
+                                uri: vodResponse.uri,
+                                title: this.currentMetadata.title || '',
+                            }
+                        });
+                        if (!vodResponse.desiredDuration) return [3 /*break*/, 51];
+                        return [4 /*yield*/, this._truncateVod(vodResponse)];
+                    case 50:
+                        _v = _10.sent(), mediaManifestLoader = _v.mediaManifestLoader, audioManifestLoader = _v.audioManifestLoader;
+                        loadPromise = newVod.loadAfter(currentVod, null, mediaManifestLoader, audioManifestLoader);
+                        return [3 /*break*/, 52];
+                    case 51:
+                        loadPromise = newVod.loadAfter(currentVod);
+                        _10.label = 52;
+                    case 52:
+                        if (vodResponse.diffMs) {
+                            this.diffCompensation = vodResponse.diffMs;
+                            if (this.diffCompensation) {
+                                this.timePositionOffset = this.diffCompensation;
+                                cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                            }
+                            else {
+                                this.timePositionOffset = 0;
+                            }
                         }
+                        return [3 /*break*/, 54];
+                    case 53:
+                        loadPromise = new Promise(function (resolve, reject) {
+                            _this._fillGap(currentVod, vodResponse.desiredDuration)
+                                .then(function (gapVod) {
+                                newVod = gapVod;
+                                resolve(newVod);
+                            }).catch(reject);
+                        });
+                        _10.label = 54;
+                    case 54:
                         loadStart = Date.now();
                         return [4 /*yield*/, ChaosMonkey.loadVod(loadPromise)];
-                    case 45:
-                        _8.sent();
+                    case 55:
+                        _10.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
                         this.leaderIsSettingNextVod = true;
                         debug("[".concat(this._sessionId, "]: next VOD loaded (").concat(newVod.getDeltaTimes(), ")"));
@@ -2119,57 +2138,57 @@ var Session = /** @class */ (function () {
                         debug("[".concat(this._sessionId, "]: playhead positions [A]=").concat(newVod.getPlayheadPositions("audio")));
                         currentVod = newVod;
                         debug("[".concat(this._sessionId, "]: msequences=").concat(currentVod.getLiveMediaSequencesCount(), "; audio msequences=").concat(currentVod.getLiveMediaSequencesCount("audio"), "; subtitle msequences=").concat(currentVod.getLiveMediaSequencesCount("subtitle")));
-                        _u = sessionState;
+                        _w = sessionState;
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
-                    case 46:
-                        _u.vodMediaSeqVideo = _8.sent();
-                        _v = sessionState;
+                    case 56:
+                        _w.vodMediaSeqVideo = _10.sent();
+                        _x = sessionState;
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
-                    case 47:
-                        _v.vodMediaSeqAudio = _8.sent();
-                        _w = sessionState;
+                    case 57:
+                        _x.vodMediaSeqAudio = _10.sent();
+                        _y = sessionState;
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqSubtitle", 0)];
-                    case 48:
-                        _w.vodMediaSeqSubtitle = _8.sent();
-                        _x = sessionState;
+                    case 58:
+                        _y.vodMediaSeqSubtitle = _10.sent();
+                        _z = sessionState;
                         return [4 /*yield*/, this._sessionState.set("mediaSeq", sessionState.mediaSeq + endMseqValue)];
-                    case 49:
-                        _x.mediaSeq = _8.sent();
-                        _y = sessionState;
+                    case 59:
+                        _z.mediaSeq = _10.sent();
+                        _0 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("mediaSeqAudio", sessionState.mediaSeqAudio + endMseqValueAudio)];
-                    case 50:
-                        _y.mediaSeqAudio = _8.sent();
-                        _z = sessionState;
+                    case 60:
+                        _0.mediaSeqAudio = _10.sent();
+                        _1 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("mediaSeqSubtitle", sessionState.mediaSeqSubtitle + endMseqValueSubtitle)];
-                    case 51:
-                        _z.mediaSeqSubtitle = _8.sent();
-                        _0 = sessionState;
+                    case 61:
+                        _1.mediaSeqSubtitle = _10.sent();
+                        _2 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity)];
-                    case 52:
-                        _0.discSeq = _8.sent();
-                        _1 = sessionState;
+                    case 62:
+                        _2.discSeq = _10.sent();
+                        _3 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("discSeqAudio", sessionState.discSeqAudio + lastDiscontinuityAudio)];
-                    case 53:
-                        _1.discSeqAudio = _8.sent();
-                        _2 = sessionState;
+                    case 63:
+                        _3.discSeqAudio = _10.sent();
+                        _4 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("discSeqSubtitle", sessionState.discSeqSubtitle + lastDiscontinuitySubtitle)];
-                    case 54:
-                        _2.discSeqSubtitle = _8.sent();
+                    case 64:
+                        _4.discSeqSubtitle = _10.sent();
                         debug("[".concat(this._sessionId, "]: new sequence data set in store V[").concat(sessionState.mediaSeq, "][").concat(sessionState.discSeq, "]_A[").concat(sessionState.mediaSeqAudio, "][").concat(sessionState.discSeqAudio, "]_S[").concat(sessionState.mediaSeqSubtitle, "][").concat(sessionState.discSeqSubtitle, "]"));
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 55:
-                        _8.sent();
-                        _3 = sessionState;
+                    case 65:
+                        _10.sent();
+                        _5 = sessionState;
                         return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 })];
-                    case 56:
-                        _3.currentVod = _8.sent();
+                    case 66:
+                        _5.currentVod = _10.sent();
                         this.leaderIsSettingNextVod = false;
                         return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now(), isLeader)];
-                    case 57:
-                        _8.sent();
+                    case 67:
+                        _10.sent();
                         return [4 /*yield*/, this._playheadState.set("diffCompensation", this.diffCompensation, isLeader)];
-                    case 58:
-                        _8.sent();
+                    case 68:
+                        _10.sent();
                         debug("[".concat(this._sessionId, "]: sharing durrent vods diffCompensation=").concat(this.diffCompensation));
                         this.produceEvent({
                             type: 'NOW_PLAYING',
@@ -2179,22 +2198,22 @@ var Session = /** @class */ (function () {
                             }
                         });
                         return [2 /*return*/];
-                    case 59:
+                    case 69:
                         debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_NEXT_INITIATING"));
                         this.waitingForNextVod = true;
-                        _4 = sessionState;
+                        _6 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
-                    case 60:
-                        _4.state = _8.sent();
+                    case 70:
+                        _6.state = _10.sent();
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
-                        _5 = sessionState;
+                        _7 = sessionState;
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 61:
-                        _5.currentVod = _8.sent();
+                    case 71:
+                        _7.currentVod = _10.sent();
                         return [4 /*yield*/, this._playheadState.get("diffCompensation")];
-                    case 62:
-                        diffMs = _8.sent();
+                    case 72:
+                        diffMs = _10.sent();
                         if (diffMs) {
                             this.diffCompensation = diffMs;
                             debug("[".concat(this._sessionId, "]: Setting diffCompensation=").concat(this.diffCompensation));
@@ -2206,10 +2225,10 @@ var Session = /** @class */ (function () {
                                 this.timePositionOffset = 0;
                             }
                         }
-                        _8.label = 63;
-                    case 63: return [3 /*break*/, 67];
-                    case 64:
-                        err_8 = _8.sent();
+                        _10.label = 73;
+                    case 73: return [3 /*break*/, 77];
+                    case 74:
+                        err_8 = _10.sent();
                         console.error("[".concat(this._sessionId, "]: Failed to init next VOD"));
                         debug("[".concat(this._sessionId, "]: ").concat(err_8));
                         if (this._assetManager.handleError) {
@@ -2217,34 +2236,34 @@ var Session = /** @class */ (function () {
                         }
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'nextvod', channel: this._sessionId, err: err_8, vod: vodResponse });
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 65:
-                        _8.sent();
+                    case 75:
+                        _10.sent();
                         return [4 /*yield*/, this._insertSlate(currentVod)];
-                    case 66:
-                        currentVod = _8.sent();
+                    case 76:
+                        currentVod = _10.sent();
                         if (!currentVod) {
                             debug("No slate to load");
                             throw err_8;
                         }
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
-                        return [3 /*break*/, 67];
-                    case 67: return [3 /*break*/, 95];
-                    case 68:
-                        _8.trys.push([68, 88, , 89]);
+                        return [3 /*break*/, 77];
+                    case 77: return [3 /*break*/, 105];
+                    case 78:
+                        _10.trys.push([78, 98, , 99]);
                         debug("[".concat(this._sessionId, "]: state=VOD_RELOAD_INIT"));
-                        if (!isLeader) return [3 /*break*/, 85];
+                        if (!isLeader) return [3 /*break*/, 95];
                         startTS = Date.now();
                         // 1) To tell Follower that, Leader is working on it!
-                        _6 = sessionState;
+                        _8 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING)];
-                    case 69:
+                    case 79:
                         // 1) To tell Follower that, Leader is working on it!
-                        _6.state = _8.sent();
+                        _8.state = _10.sent();
                         mSeq = this.switchDataForSession.mediaSeq;
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 70:
-                        currentVod_2 = _8.sent();
+                    case 80:
+                        currentVod_2 = _10.sent();
                         if (currentVod_2.sequenceAlwaysContainNewSegments) {
                             // (!) will need to compensate if using this setting on HLSVod Object.
                             Object.keys(this.switchDataForSession.transitionSegments).forEach(function (bw) {
@@ -2263,21 +2282,21 @@ var Session = /** @class */ (function () {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, this._sessionState.set("mediaSeq", mSeq)];
-                    case 71:
-                        _8.sent();
+                    case 81:
+                        _10.sent();
                         return [4 /*yield*/, this._playheadState.set("mediaSeq", mSeq, isLeader)];
-                    case 72:
-                        _8.sent();
+                    case 82:
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.set("discSeq", dSeq)];
-                    case 73:
-                        _8.sent();
+                    case 83:
+                        _10.sent();
                         // TODO: support demux^
                         debug("[".concat(this._sessionId, "]: Setting current media and discontinuity count -> [").concat(mSeq, "]:[").concat(dSeq, "]"));
                         // 3) Set new media segments/currentVod, to carry on the continuity from session-live
                         debug("[".concat(this._sessionId, "]: LEADER: making changes to current VOD. I will also update currentVod in store."));
                         return [4 /*yield*/, this._playheadState.getValues(["vodMediaSeqVideo"])];
-                    case 74:
-                        playheadState = _8.sent();
+                    case 84:
+                        playheadState = _10.sent();
                         nextMseq = playheadState.vodMediaSeqVideo + 1;
                         if (nextMseq > currentVod_2.getLiveMediaSequencesCount() - 1) {
                             nextMseq = currentVod_2.getLiveMediaSequencesCount() - 1;
@@ -2286,38 +2305,38 @@ var Session = /** @class */ (function () {
                         // TODO: Support reloading with audioSegments and SubtitleSegments as well |
                         // ---------------------------------------------------'
                         return [4 /*yield*/, currentVod_2.reload(nextMseq, segments, null, reloadBehind)];
-                    case 75:
+                    case 85:
                         // ---------------------------------------------------.
                         // TODO: Support reloading with audioSegments and SubtitleSegments as well |
                         // ---------------------------------------------------'
-                        _8.sent();
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod_2, { ttl: currentVod_2.getDuration() * 1000 })];
-                    case 76:
-                        _8.sent();
+                    case 86:
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.set("vodReloaded", 1)];
-                    case 77:
-                        _8.sent();
+                    case 87:
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
-                    case 78:
-                        _8.sent();
+                    case 88:
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
-                    case 79:
-                        _8.sent();
+                    case 89:
+                        _10.sent();
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqSubtitle", 0)];
-                    case 80:
-                        _8.sent();
+                    case 90:
+                        _10.sent();
                         return [4 /*yield*/, this._playheadState.set("vodMediaSeqVideo", 0, isLeader)];
-                    case 81:
-                        _8.sent();
+                    case 91:
+                        _10.sent();
                         return [4 /*yield*/, this._playheadState.set("vodMediaSeqAudio", 0, isLeader)];
-                    case 82:
-                        _8.sent();
+                    case 92:
+                        _10.sent();
                         return [4 /*yield*/, this._playheadState.set("vodMediaSeqSubtitle", 0, isLeader)];
-                    case 83:
-                        _8.sent();
+                    case 93:
+                        _10.sent();
                         return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now(), isLeader)];
-                    case 84:
-                        _8.sent();
+                    case 94:
+                        _10.sent();
                         // 4) Log to debug and cloudwatch
                         debug("[".concat(this._sessionId, "]: LEADER: Set new Reloaded VOD and vodMediaSeq counts in store."));
                         debug("[".concat(this._sessionId, "]: next VOD Reloaded (").concat(currentVod_2.getDeltaTimes(), ")"));
@@ -2325,38 +2344,38 @@ var Session = /** @class */ (function () {
                         debug("[".concat(this._sessionId, "]: msequences=").concat(currentVod_2.getLiveMediaSequencesCount()));
                         cloudWatchLog(!this.cloudWatchLogging, "engine-session", { event: "switchback", channel: this._sessionId, reqTimeMs: Date.now() - startTS });
                         return [2 /*return*/];
-                    case 85:
+                    case 95:
                         debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_RELOAD_INITIATING"));
-                        _7 = sessionState;
+                        _9 = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING)];
-                    case 86:
-                        _7.state = _8.sent();
-                        _8.label = 87;
-                    case 87: return [3 /*break*/, 89];
-                    case 88:
-                        err_9 = _8.sent();
+                    case 96:
+                        _9.state = _10.sent();
+                        _10.label = 97;
+                    case 97: return [3 /*break*/, 99];
+                    case 98:
+                        err_9 = _10.sent();
                         debug("Failed to init reload vod");
                         throw err_9;
-                    case 89: return [3 /*break*/, 95];
-                    case 90:
+                    case 99: return [3 /*break*/, 105];
+                    case 100:
                         debug("[".concat(this._sessionId, "]: state=VOD_RELOAD_INITIATING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, "_").concat(sessionState.vodMediaSeqSubtitle, ", ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio"), "_").concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")"));
-                        if (!!isLeader) return [3 /*break*/, 93];
+                        if (!!isLeader) return [3 /*break*/, 103];
                         debug("[".concat(this._sessionId, "]: not the leader so just waiting for the VOD to be reloaded"));
-                        if (!(sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod)) return [3 /*break*/, 92];
+                        if (!(sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod)) return [3 /*break*/, 102];
                         debug("[".concat(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"));
                         return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
-                    case 91:
-                        _8.sent();
-                        _8.label = 92;
-                    case 92:
+                    case 101:
+                        _10.sent();
+                        _10.label = 102;
+                    case 102:
                         this.waitingForNextVod = true;
-                        _8.label = 93;
-                    case 93:
+                        _10.label = 103;
+                    case 103:
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
                         return [2 /*return*/];
-                    case 94: throw new Error("Invalid state: " + sessionState.state);
-                    case 95: return [2 /*return*/];
+                    case 104: throw new Error("Invalid state: " + sessionState.state);
+                    case 105: return [2 /*return*/];
                 }
             });
         });
@@ -2455,6 +2474,39 @@ var Session = /** @class */ (function () {
             }
         });
     };
+    Session.prototype._truncateVod = function (vodResponse) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                var truncatedVod_1 = new HLSTruncateVod(vodResponse.uri, vodResponse.desiredDuration / 1000);
+                truncatedVod_1.load()
+                    .then(function () {
+                    var audioManifestLoader;
+                    var mediaManifestLoader = function (bw) {
+                        var mediaManifestStream = new Readable();
+                        mediaManifestStream.push(truncatedVod_1.getMediaManifest(bw));
+                        mediaManifestStream.push(null);
+                        return mediaManifestStream;
+                    };
+                    if (_this.use_demuxed_audio) {
+                        audioManifestLoader = function (audioGroupId, audioLanguage) {
+                            var mediaManifestStream = new Readable();
+                            mediaManifestStream.push(truncatedVod_1.getAudioManifest(audioGroupId, audioLanguage));
+                            mediaManifestStream.push(null);
+                            return mediaManifestStream;
+                        };
+                    }
+                    resolve({ mediaManifestLoader: mediaManifestLoader, audioManifestLoader: audioManifestLoader });
+                }).catch(function (err) {
+                    debug(err);
+                    reject(err);
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
     Session.prototype._truncateSlate = function (afterVod, requestedDuration, vodUri) {
         var _this = this;
         return new Promise(function (resolve, reject) {

package/dist/examples/truncate.d.ts

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

package/dist/examples/truncate.js

@@ -0,0 +1,92 @@
+"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,
+                    desiredDuration: 50000
+                };
+                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 this.channels;
+    };
+    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,
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "4.2.2",
+  "version": "4.2.4",
   "description": "OTT TV Channel Engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/engine/server.ts

@@ -99,7 +99,7 @@ export interface VodResponse {
   uri: string;
   offset?: number;
   diffMs?: number;
-  desiredDuraiton?: number;
+  desiredDuration?: number;
   type?: string;
   currentMetadata?: VodResponseMetadata;
   timedMetadata?: VodTimedMetadata;

package/engine/session.js

@@ -1331,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) => {
@@ -1509,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) {
@@ -1782,6 +1792,38 @@ class Session {
     });
   }
 
+  _truncateVod(vodResponse) {
+    return new Promise((resolve, reject) => {
+      try {
+        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 });
+          }).catch(err => {
+            debug(err);
+            reject(err);
+          });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
   _truncateSlate(afterVod, requestedDuration, vodUri) {
     return new Promise((resolve, reject) => {
       let nexVodUri = null;

package/examples/truncate.ts

@@ -0,0 +1,104 @@
+/*
+ * 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,
+          desiredDuration: 50000
+        };
+        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 this.channels;
+  }
+
+  _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,
+  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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "4.2.2",
+  "version": "4.2.4",
   "description": "OTT TV Channel Engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",