[stitcher] Refactor API structure (#157)

* Added new api structure

* Merge vast

* Changed some more stuff

* Added session related info

* Removed unused code

* Do not use tseep eval func

Author: matvp91

packages/player/src/hls-player.ts

@@ -1,6 +1,6 @@
 import Hls from "hls.js";
 import { assert } from "shared/assert";
-import { EventEmitter } from "tseep";
+import { EventEmitter } from "tseep/lib/ee-safe";
 import { EventManager } from "./event-manager";
 import { getLangCode } from "./helpers";
 import { getState, State } from "./state";
@@ -236,7 +236,7 @@ export class HlsPlayer {
   }
 
   get live() {
-    return this.hls_?.levels[this.hls_.currentLevel]?.details?.live ?? false;
+    return getState(this.state_, "live");
   }
 
   get cuePoints() {
@@ -396,7 +396,9 @@ export class HlsPlayer {
     const listen = this.eventManager_.listen(this.media_);
 
     listen("canplay", () => {
-      this.state_?.setReady();
+      const live =
+        this.hls_?.levels[this.hls_.currentLevel]?.details?.live ?? false;
+      this.state_?.setReady(live);
     });
 
     listen("play", () => {

packages/player/src/state.ts

@@ -36,6 +36,7 @@ interface StateProperties {
   volume: number;
   seeking: boolean;
   cuePoints: number[];
+  live: boolean;
 }
 
 const noState: StateProperties = {
@@ -52,6 +53,7 @@ const noState: StateProperties = {
   volume: 1,
   seeking: false,
   cuePoints: [],
+  live: false,
 };
 
 export class State implements StateProperties {
@@ -61,10 +63,11 @@ export class State implements StateProperties {
     this.requestTimingSync();
   }
 
-  setReady() {
+  setReady(live: boolean) {
     if (this.ready) {
       return;
     }
+    this.live = live;
     this.ready = true;
     this.requestTimingSync();
     this.params_.onEvent(Events.READY);
@@ -241,6 +244,7 @@ export class State implements StateProperties {
   volume = noState.volume;
   seeking = noState.seeking;
   cuePoints = noState.cuePoints;
+  live = noState.live;
 }
 
 export function getState<N extends keyof StateProperties>(

packages/stitcher/src/filters.ts

@@ -8,7 +8,7 @@ export interface Filter {
 
 export function formatFilterToQueryParam(filter?: Filter) {
   if (!filter) {
-    return undefined;
+    filter = {};
   }
   return btoa(JSON.stringify(filter));
 }

packages/stitcher/src/interstitials.ts

@@ -1,32 +1,90 @@
-import { createUrl } from "./lib/url";
-import { getAssetsFromVast } from "./vast";
-import type { DateRange } from "./parser";
+import { DateTime } from "luxon";
+import { HashGroup } from "./lib/hash-group";
+import { createUrl, replaceUrlParams } from "./lib/url";
+import { getAssetsFromVastData, getAssetsFromVastUrl } from "./vast";
+import type { DateRange, Segment } from "./parser";
 import type { Session } from "./session";
-import type { Interstitial, InterstitialAsset } from "./types";
-import type { DateTime } from "luxon";
+import type { Asset } from "./types";
 
-export function getStaticDateRanges(session: Session, isLive: boolean) {
-  return session.interstitials.map<DateRange>((interstitial) => {
-    const startDate = interstitial.dateTime;
-    const assetListUrl = getAssetListUrl(interstitial, session);
+// An item describes what we'd like to collect for a particular date.
+interface DateGroupItem {
+  timelineStyle: "HIGHLIGHT" | "PRIMARY";
+  replaceContent: boolean;
+  maxDuration?: number;
+}
+
+export function getStaticDateRanges(
+  session: Session,
+  segments: Segment[],
+  isLive: boolean,
+) {
+  const dateGroup = new HashGroup<number, DateGroupItem>({
+    getDefaultValue: () => ({
+      timelineStyle: "PRIMARY",
+      replaceContent: isLive ? true : false,
+    }),
+  });
+
+  // Collect dateRanges from splice points.
+  for (const segment of segments) {
+    if (segment.spliceInfo?.type !== "OUT" || !segment.programDateTime) {
+      continue;
+    }
+
+    const key = segment.programDateTime.toMillis();
+    const item = dateGroup.get(key);
+
+    item.timelineStyle = "HIGHLIGHT";
+    item.maxDuration = segment.spliceInfo.duration;
+  }
+
+  // Collect dateRanges from each event defined in the session.
+  for (const event of session.events) {
+    const key = event.dateTime.toMillis();
+    const item = dateGroup.get(key);
+
+    if (event.vast) {
+      // If we resolved the event by a vast, we know it's an ad and can mark it
+      // as HIGHLIGHT on the timeline.
+      item.timelineStyle = "HIGHLIGHT";
+    }
+
+    if (
+      !event.maxDuration ||
+      (item.maxDuration && event.maxDuration > item.maxDuration)
+    ) {
+      // If we have a max duration for this event, we'll save it for this interstitial. Always takes the
+      // largest maxDuration across events.
+      item.maxDuration = event.maxDuration;
+    }
+  }
+
+  return dateGroup.toEntries().map<DateRange>(([key, item]) => {
+    const startDate = DateTime.fromMillis(key);
+
+    const assetListUrl = createUrl("out/asset-list.json", {
+      dt: startDate.toISO(),
+      sid: session.id,
+      mdur: item.maxDuration,
+    });
 
     const clientAttributes: Record<string, number | string> = {
       RESTRICT: "SKIP,JUMP",
       "ASSET-LIST": assetListUrl,
       "CONTENT-MAY-VARY": "YES",
       "TIMELINE-OCCUPIES": "POINT",
-      "TIMELINE-STYLE": getTimelineStyle(interstitial),
+      "TIMELINE-STYLE": item.timelineStyle,
     };
 
-    if (!isLive) {
+    if (!item.replaceContent) {
       clientAttributes["RESUME-OFFSET"] = 0;
     }
 
-    if (interstitial.duration) {
-      clientAttributes["PLAYOUT-LIMIT"] = interstitial.duration;
+    if (item.maxDuration !== undefined) {
+      clientAttributes["PLAYOUT-LIMIT"] = item.maxDuration;
     }
 
-    const cue: string[] = ["ONCE"];
+    const cue: string[] = [];
     if (startDate.equals(session.startTime)) {
       cue.push("PRE");
     }
@@ -44,71 +102,53 @@ export function getStaticDateRanges(session: Session, isLive: boolean) {
   });
 }
 
-export async function getAssets(session: Session, dateTime: DateTime) {
-  const interstitial = session.interstitials.find((interstitial) =>
-    interstitial.dateTime.equals(dateTime),
+export async function getAssets(
+  session: Session,
+  dateTime: DateTime,
+  maxDuration?: number,
+): Promise<Asset[]> {
+  // Filter all events for a particular dateTime, we'll need to transform these to
+  // a list of assets.
+  const events = session.events.filter((event) =>
+    event.dateTime.equals(dateTime),
   );
 
-  if (!interstitial) {
-    return [];
-  }
-
-  const assets: InterstitialAsset[] = [];
-
-  for (const chunk of interstitial.chunks) {
-    if (chunk.type === "vast") {
-      const nextAssets = await getAssetsFromVast(chunk.data);
-      assets.push(...nextAssets);
-    }
-    if (chunk.type === "asset") {
-      assets.push(chunk.data);
+  const assets: Asset[] = [];
+
+  for (const event of events) {
+    if (event.vast) {
+      const { url, data } = event.vast;
+
+      // The event contains a VAST url.
+      if (url) {
+        const vastUrl = replaceUrlParams(url, {
+          maxDuration,
+        });
+        const vastAssets = await getAssetsFromVastUrl(vastUrl);
+        assets.push(...vastAssets);
+      }
+
+      // The event contains inline VAST data.
+      if (data) {
+        const vastAssets = await getAssetsFromVastData(data);
+        assets.push(...vastAssets);
+      }
     }
-  }
 
-  return assets;
-}
-
-export function mergeInterstitials(
-  source: Interstitial[],
-  interstitials: Interstitial[],
-) {
-  for (const interstitial of interstitials) {
-    const target = source.find((item) =>
-      item.dateTime.equals(interstitial.dateTime),
-    );
-
-    if (!target) {
-      source.push(interstitial);
-    } else {
-      // If we found a source for the particular dateTime, we push the
-      // other chunks at the end.
-      target.chunks.push(...interstitial.chunks);
+    // The event contains a list of assets, explicitly defined.
+    if (event.assets) {
+      assets.push(...event.assets);
     }
   }
-}
 
-function getAssetListUrl(interstitial: Interstitial, session?: Session) {
-  const assetListChunks = interstitial.chunks.filter(
-    (chunk) => chunk.type === "assetList",
-  );
-  if (assetListChunks.length === 1 && assetListChunks[0]) {
-    return assetListChunks[0].data.url;
+  // If we have a generic vast config on our session, use that one to resolve (eg; for live streams)
+  if (session.vast?.url) {
+    const vastUrl = replaceUrlParams(session.vast.url, {
+      maxDuration,
+    });
+    const tempAssets = await getAssetsFromVastUrl(vastUrl);
+    assets.push(...tempAssets);
   }
 
-  return createUrl("out/asset-list.json", {
-    dt: interstitial.dateTime.toISO(),
-    sid: session?.id,
-  });
-}
-
-function getTimelineStyle(interstitial: Interstitial) {
-  for (const chunk of interstitial.chunks) {
-    if (chunk.type === "asset" && chunk.data.kind === "ad") {
-      return "HIGHLIGHT";
-    }
-    if (chunk.type === "vast") {
-      return "HIGHLIGHT";
-    }
-  }
-  return "PRIMARY";
+  return assets;
 }

packages/stitcher/src/lib/hash-group.ts

@@ -0,0 +1,22 @@
+export class HashGroup<K, T> {
+  private map_ = new Map<K, T>();
+
+  constructor(
+    private params_: {
+      getDefaultValue: () => T;
+    },
+  ) {}
+
+  get(key: K) {
+    let value = this.map_.get(key);
+    if (!value) {
+      value = this.params_.getDefaultValue();
+      this.map_.set(key, value);
+    }
+    return value;
+  }
+
+  toEntries() {
+    return [...this.map_.entries()];
+  }
+}

packages/stitcher/src/lib/url.ts

@@ -65,3 +65,23 @@ export function createUrl(
 ) {
   return buildUrl(`${env.PUBLIC_STITCHER_ENDPOINT}/${path}`, params);
 }
+
+export function replaceUrlParams(
+  url: string,
+  params?: Record<string, string | number | undefined>,
+) {
+  const allParams = {
+    ...params,
+    // Default params defined below.
+    random: Math.floor(Math.random() * 10_000),
+  };
+
+  Object.entries(allParams).forEach(([key, value]) => {
+    if (value === undefined) {
+      return;
+    }
+    url = url.replaceAll(`{${key}}`, value.toString());
+  });
+
+  return url;
+}

packages/stitcher/src/parser/lexical-parse.ts

@@ -19,6 +19,7 @@ const EMPTY_TAGS = [
   "EXT-X-ENDLIST",
   "EXT-X-I-FRAMES-ONLY",
   "EXT-X-INDEPENDENT-SEGMENTS",
+  "EXT-X-CUE-IN",
 ] as const;
 
 const NUMBER_TAGS = [
@@ -40,7 +41,8 @@ export type Tag =
   | ["EXT-X-STREAM-INF", StreamInf]
   | ["EXT-X-MEDIA", Media]
   | ["EXT-X-MAP", MediaInitializationSection]
-  | ["EXT-X-DATERANGE", DateRange];
+  | ["EXT-X-DATERANGE", DateRange]
+  | ["EXT-X-CUE-OUT", CueOut];
 
 export interface ExtInf {
   duration: number;
@@ -63,6 +65,10 @@ export interface Media {
   channels?: string;
 }
 
+export interface CueOut {
+  duration: number;
+}
+
 function parseLine(line: string): Tag | null {
   const [name, param] = splitLine(line);
 
@@ -276,6 +282,29 @@ function parseLine(line: string): Tag | null {
       ];
     }
 
+    case "EXT-X-CUE-OUT": {
+      assert(param, "EXT-X-CUE-OUT: no param");
+
+      const attrs: Partial<CueOut> = {};
+
+      mapAttributes(param, (key, value) => {
+        switch (key) {
+          case "DURATION":
+            attrs.duration = Number.parseFloat(value);
+            break;
+        }
+      });
+
+      assert(attrs.duration, "EXT-X-CUE-OUT: no duration");
+
+      return [
+        name,
+        {
+          duration: attrs.duration,
+        },
+      ];
+    }
+
     default:
       return null;
   }