@norskvideo/norsk-sdk 0.0.322

package/src/sdk.ts

@@ -0,0 +1,726 @@
+import * as grpc from "@grpc/grpc-js";
+import { MediaClient } from "@norskvideo/norsk-api/lib/media_grpc_pb";
+import {
+  Version,
+  CurrentLoad,
+  Log_Level,
+} from "@norskvideo/norsk-api/lib/shared/common_pb";
+import {
+  Wave,
+  NorskStatusEvent,
+  SineWave,
+} from "@norskvideo/norsk-api/lib/media_pb";
+import { Empty } from "@bufbuild/protobuf";
+import { debuglog, norskHost, norskPort } from "./shared/utils";
+import { MediaNodeState, PinToKey } from "./media_nodes/common";
+import {
+  AudioSignalGeneratorNode,
+  AudioSignalGeneratorSettings,
+  BrowserInputNode,
+  BrowserInputSettings,
+  DeckLinkInputNode,
+  DeckLinkInputSettings,
+  ImageFileInputNode,
+  ImageFileInputSettings,
+  LocalFileInputSettings,
+  M3u8InputNode,
+  M3u8MediaInputSettings,
+  Mp4FileInputNode,
+  Mp4FileInputSettings,
+  NorskInput,
+  RtmpServerInputNode,
+  RtmpServerInputSettings,
+  RtpInputNode,
+  RtpInputSettings,
+  SrtInputNode,
+  SrtInputSettings,
+  TsFileInputNode,
+  UdpTsInputNode,
+  UdpTsInputSettings,
+  WebVttFileInputNode,
+  WhipInputNode,
+  WhipInputSettings,
+} from "./media_nodes/input";
+import {
+  Gain,
+  NorskProcessor,
+  LocalWebRTCNode,
+  LocalWebRTCSettings,
+  NorskDuplex,
+} from "./media_nodes/processor";
+import {
+  HlsAudioOutputNode,
+  HlsAudioOutputSettings,
+  HlsMasterOutputNode,
+  HlsMasterOutputSettings,
+  HlsMasterPushOutputNode,
+  HlsMasterPushOutputSettings,
+  HlsTsAudioOutputNode,
+  HlsTsAudioOutputSettings,
+  HlsTsAudioPushOutputNode,
+  HlsTsAudioPushOutputSettings,
+  HlsTsCombinedPushOutputNode,
+  HlsTsCombinedPushOutputSettings,
+  HlsTsVideoOutputNode,
+  HlsTsVideoOutputSettings,
+  HlsTsVideoPushOutputNode,
+  HlsTsVideoPushOutputSettings,
+  HlsVideoOutputNode,
+  HlsVideoOutputSettings,
+  HlsWebVttOutputNode,
+  HlsWebVttOutputSettings,
+  HlsWebVttPushOutputNode,
+  HlsWebVttPushOutputSettings,
+  Mp4FileOutputNode,
+  Mp4FileOutputSettings,
+  NorskOutput,
+  RtmpOutputNode,
+  RtmpOutputSettings,
+  SrtOutputNode,
+  SrtOutputSettings,
+  TsFileOutputNode,
+  TsFileOutputSettings,
+  TsUdpOutputNode,
+  TsUdpOutputSettings,
+  WebRTCWhipOutputNode,
+  WebRTCWhipOutputSettings,
+} from "./media_nodes/output";
+import { StreamKey, StreamMetadata } from "./media_nodes/types";
+import { hardwareInfo, NorskSystem } from "./system";
+
+export * from "./types";
+export * from "./system";
+export * from "./media_nodes/types";
+export * from "./media_nodes/input";
+export * from "./media_nodes/output";
+export * from "./media_nodes/processor";
+export * from "./media_nodes/common";
+export { AudioCodec } from "@norskvideo/norsk-api/lib/media_pb";
+export * from "./system";
+export { Version } from "@norskvideo/norsk-api/lib/shared/common_pb";
+
+/** @public */
+export type Log = {
+  level:
+  | "emergency"
+  | "alert"
+  | "critical"
+  | "error"
+  | "warning"
+  | "notice"
+  | "info"
+  | "debug";
+  timestamp: Date;
+  message: string;
+};
+
+/**
+ * @public
+ * Top level Norsk configuration
+ */
+export interface NorskSettings {
+  /**
+   * Callback URL to listen on for gRPC session with Norsk Media
+   * Defaults to $NORSK_HOST:$NORSK_PORT if the environment variables are set
+   * where NORSK_HOST defaults to "127.0.0.1" and NORSK_PORT to "6790"
+   * (so "127.0.0.1:6790" if neither variable is set)
+   */
+  url?: string;
+  onAttemptingToConnect?: () => void;
+  onConnecting?: () => void;
+  onReady?: () => void;
+  onFailedToConnect?: () => void;
+  /** Code to execute if the Norsk node is shutdown - by default if logs and exits the client application */
+  onShutdown?: () => void;
+  onCurrentLoad?: (load: CurrentLoad) => void;
+  onHello?: (version: Version) => void;
+  onLogEvent?: (log: Log) => void;
+  /**
+   * Manually handle license events, such as missing/invalid licenses and
+   * sandbox timeout. (Logs messages to console by default.)
+   */
+  onLicenseEvent?: (message: string) => void;
+}
+
+/**
+ * @public
+ * The entrypoint for all Norsk Media applications
+ *
+ * @example
+ * ```ts
+ * const norsk = new Norsk();
+ * ```
+ */
+export class Norsk {
+  /** @internal */
+  client: MediaClient;
+  /** @internal */
+  nodes: MediaNodeState[];
+  /** @internal */
+  settings: NorskSettings;
+  /** @internal */
+  connectivityState: number;
+  /** @internal */
+  statusStream?: grpc.ClientReadableStream<NorskStatusEvent>;
+  /** @internal */
+  publicWebPort?: number;
+
+  /**
+   * Implements the {@link NorskInput} interface
+   */
+  public input: NorskInput;
+  /**
+   * Implements the {@link NorskOutput} interface
+   */
+  public output: NorskOutput;
+  /**
+   * Implements the {@link NorskDuplex} interface
+   */
+  public duplex: NorskDuplex;
+  /**
+   * Implements the {@link NorskProcessor} interface
+   */
+  public processor: NorskProcessor;
+  /**
+   * Implements the {@link NorskSystem} interface
+   */
+  public system: NorskSystem;
+
+  /**
+   * Norsk Runtime version informatio
+   */
+  public version: Version;
+
+  /* @internal */
+  public resolveVersion: () => void;
+
+  /* @internal */
+  public initialised: Promise<void>;
+
+  /** @internal */
+  async registerNode<N extends MediaNodeState>(node: N): Promise<N> {
+    this.nodes.push(node);
+    return node;
+  }
+
+  public close() {
+    this.processor.close();
+    for (var n of this.nodes) {
+      n.close();
+    }
+    this.statusStream?.cancel();
+    try {
+      this.client.close();
+    } catch { }
+  }
+
+  /** @internal */
+  handleStatusEvent(data: NorskStatusEvent) {
+    const messageCase = data.message.case;
+    switch (messageCase) {
+      case undefined:
+        break;
+      case "hello": {
+        debuglog(
+          "Norsk status channel connected: %s",
+          data.message.value.version
+        );
+        this.publicWebPort = data.message.value.publicWebPort;
+        if (data.message.value.version === undefined) {
+          throw new Error("Norsk version is undefined");
+        } else {
+          this.version = data.message.value.version;
+        }
+        this.settings.onHello &&
+          data.message.value.version &&
+          this.settings.onHello(data.message.value.version);
+        this.resolveVersion();
+        break;
+      }
+      case "currentLoad": {
+        this.settings.onCurrentLoad &&
+          this.settings.onCurrentLoad(data.message.value);
+        break;
+      }
+      case "licenseEvent": {
+        if (this.settings.onLicenseEvent) {
+          this.settings.onLicenseEvent(data.message.value);
+        } else {
+          console.log(data.message.value);
+        }
+        break;
+      }
+      case "logEvent": {
+        var level:
+          | "emergency"
+          | "alert"
+          | "critical"
+          | "error"
+          | "warning"
+          | "notice"
+          | "info"
+          | "debug";
+
+        switch (data.message.value.level) {
+          case Log_Level.EMERGENCY:
+            level = "emergency";
+            break;
+          case Log_Level.ALERT:
+            level = "alert";
+            break;
+          case Log_Level.CRITICAL:
+            level = "critical";
+            break;
+          case Log_Level.ERROR:
+            level = "error";
+            break;
+          case Log_Level.WARNING:
+            level = "warning";
+            break;
+          case Log_Level.NOTICE:
+            level = "notice";
+            break;
+          case Log_Level.INFO:
+            level = "info";
+            break;
+          case Log_Level.DEBUG:
+            level = "debug";
+            break;
+        }
+        var log: Log = {
+          level: level,
+          message: data.message.value.msg,
+          timestamp: new Date(Number(data.message.value.timestamp) / 1000),
+        };
+        if (this.settings.onLogEvent) {
+          this.settings.onLogEvent(log);
+        } else {
+          debuglog("Norsk log event: %o", log);
+        }
+        break;
+      }
+      default:
+        const exhaustiveCheck: never = messageCase;
+        throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+    }
+  }
+
+  /** @internal */
+  connectivityStateWatcher() {
+    var channel = this.client.getChannel();
+    var connectivityState = channel.getConnectivityState(true);
+
+    switch (connectivityState) {
+      case 0: {
+        if (this.connectivityState == 1 || this.connectivityState == 2) {
+          this.settings.onShutdown && this.settings.onShutdown();
+        }
+        // Idle
+        this.settings.onAttemptingToConnect &&
+          this.settings.onAttemptingToConnect();
+        break;
+      }
+      case 1: {
+        // Connecting
+        this.settings.onConnecting && this.settings.onConnecting();
+        break;
+      }
+      case 2: {
+        // Ready
+        this.settings.onReady && this.settings.onReady();
+        this.statusStream = this.client.createStatusChannel(new Empty());
+        this.statusStream.on("data", this.handleStatusEvent.bind(this));
+        this.statusStream.on("error", () => {
+          return;
+        });
+        break;
+      }
+      case 3: {
+        // Transient failure
+        this.settings.onFailedToConnect && this.settings.onFailedToConnect();
+        break;
+      }
+      case 4: {
+        // Shutdown
+        this.settings.onShutdown && this.settings.onShutdown();
+        break;
+      }
+    }
+    debuglog("Channel connectivity state change: %d", connectivityState);
+
+    this.connectivityState = connectivityState;
+    channel.watchConnectivityState(connectivityState, Infinity, () => {
+      this.connectivityStateWatcher();
+    });
+  }
+
+  /** @public */
+  public static async connect(
+    settings?: NorskSettings
+  ) {
+    settings = settings ?? {};
+    if (!settings.onShutdown) {
+      settings.onShutdown = () => {
+        console.log("Norsk has shutdown");
+        process.exit(1)
+      }
+    }
+    let norsk = new Norsk(settings);
+    await norsk.initialised;
+    return norsk;
+  }
+
+  /** @internal */
+  constructor(norskSettings: NorskSettings) {
+    this.connectivityState = 0;
+    this.client = new MediaClient(
+      norskSettings.url ? norskSettings.url : norskHost() + ":" + norskPort(),
+      grpc.credentials.createInsecure()
+    );
+    this.settings = norskSettings;
+    this.connectivityStateWatcher();
+    this.initialised = new Promise((resolve, reject) => {
+      this.resolveVersion = resolve;
+    });
+    this.nodes = [];
+    this.input = {
+      rtmpServer: async (settings: RtmpServerInputSettings) =>
+        RtmpServerInputNode.create(settings, this.client),
+      localTsFile: async (settings: LocalFileInputSettings) =>
+        TsFileInputNode.create(settings, this.client),
+      srt: async (settings: SrtInputSettings) =>
+        SrtInputNode.create(settings, this.client),
+      whip: async (settings: WhipInputSettings) =>
+        WhipInputNode.create(settings, this.client),
+      m3u8Media: async (settings: M3u8MediaInputSettings) =>
+        M3u8InputNode.create(settings, this.client),
+      udpTs: async (settings: UdpTsInputSettings) =>
+        UdpTsInputNode.create(settings, this.client),
+      localWebVttFile: async (settings: LocalFileInputSettings) =>
+        WebVttFileInputNode.create(settings, this.client),
+      imageFile: async (settings: ImageFileInputSettings) =>
+        ImageFileInputNode.create(settings, this.client),
+      localMp4File: async (settings: Mp4FileInputSettings) =>
+        Mp4FileInputNode.create(settings, this.client),
+      rtp: async (settings: RtpInputSettings) =>
+        RtpInputNode.create(settings, this.client),
+      audioSignal: async (settings: AudioSignalGeneratorSettings) =>
+        AudioSignalGeneratorNode.create(settings, this.client),
+      browser: async (settings: BrowserInputSettings) =>
+        BrowserInputNode.create(settings, this.client),
+      deckLink: async (settings: DeckLinkInputSettings) =>
+        DeckLinkInputNode.create(settings, this.client),
+    };
+
+    this.output = {
+      hlsVideo: async (settings: HlsVideoOutputSettings) =>
+        HlsVideoOutputNode.create(settings, this.client),
+      hlsAudio: async (
+        settings: HlsAudioOutputSettings
+      ): Promise<HlsAudioOutputNode> =>
+        HlsAudioOutputNode.create(settings, this.client),
+      hlsWebVtt: async (settings: HlsWebVttOutputSettings) =>
+        HlsWebVttOutputNode.create(settings, this.client),
+      hlsWebVttPush: async (settings: HlsWebVttPushOutputSettings) =>
+        HlsWebVttPushOutputNode.create(settings, this.client),
+      hlsTsVideo: async (settings: HlsTsVideoOutputSettings) =>
+        HlsTsVideoOutputNode.create(settings, this.client),
+      tsUdp: async (settings: TsUdpOutputSettings) =>
+        TsUdpOutputNode.create(settings, this.client),
+      srt: async (settings: SrtOutputSettings) =>
+        SrtOutputNode.create(settings, this.client),
+      hlsTsAudio: async (settings: HlsTsAudioOutputSettings) =>
+        HlsTsAudioOutputNode.create(settings, this.client),
+      hlsTsVideoPush: async (settings: HlsTsVideoPushOutputSettings) =>
+        HlsTsVideoPushOutputNode.create(settings, this.client),
+      hlsTsAudioPush: async (settings: HlsTsAudioPushOutputSettings) =>
+        HlsTsAudioPushOutputNode.create(settings, this.client),
+      hlsTsCombinedPush: async (settings: HlsTsCombinedPushOutputSettings) =>
+        HlsTsCombinedPushOutputNode.create(settings, this.client),
+      hlsMaster: async (settings: HlsMasterOutputSettings) =>
+        HlsMasterOutputNode.create(
+          settings,
+          this.client
+        ),
+      hlsMasterPush: async (settings: HlsMasterPushOutputSettings) =>
+        HlsMasterPushOutputNode.create(settings, this.client),
+      webRTCWhip: async (settings: WebRTCWhipOutputSettings) =>
+        WebRTCWhipOutputNode.create(settings, this.client),
+
+      rtmp: async (settings: RtmpOutputSettings) =>
+        RtmpOutputNode.create(settings, this.client),
+      localTsFile: async (settings: TsFileOutputSettings) =>
+        TsFileOutputNode.create(settings, this.client),
+      localMp4File: async (settings: Mp4FileOutputSettings) =>
+        Mp4FileOutputNode.create(settings, this.client),
+    };
+    this.processor = new NorskProcessor(this.client);
+    this.system = {
+      hardwareInfo: async () => hardwareInfo(this.client),
+    };
+    this.duplex = {
+      localWebRTC: async (settings: LocalWebRTCSettings) =>
+        LocalWebRTCNode.create(
+          settings,
+          this.client
+        ),
+    };
+
+    // Rob's notes: Help, I need somebody to do this properly without 'any' and 'ignore'
+    for (var i in this.output) {
+      let k = i as keyof NorskOutput;
+      let original = this.output[k];
+      let fn = async (s: any) => {
+        let n = await original(s);
+        return this.registerNode(n);
+      };
+
+      //@ts-ignore
+      this.output[k] = fn;
+    }
+    for (var i in this.input) {
+      let k = i as keyof NorskInput;
+      let original = this.input[k];
+      let fn = async (s: any) => {
+        let n = await original(s);
+        return this.registerNode(n);
+      };
+
+      //@ts-ignore
+      this.input[k] = fn;
+    }
+  }
+}
+
+/**
+ * @public
+ * Filters a context to only the audio streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The audio streams in the media context
+ */
+export function audioStreams(
+  streams: readonly StreamMetadata[]
+): StreamMetadata[] {
+  return streams.filter((stream) => stream.message.case === "audio");
+}
+
+/**
+ * @public
+ * Filters a context to only the video streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The video streams in the media context
+ */
+export function videoStreams(
+  streams: readonly StreamMetadata[]
+): StreamMetadata[] {
+  return streams.filter((stream) => stream.message.case === "video");
+}
+
+/**
+ * @public
+ * Filters a context to only the subtitle streams within it
+ * @param streams - The media context from which to return the streams
+ * @returns The subtitle streams in the media context
+ */
+export function subtitleStreams(
+  streams: readonly StreamMetadata[]
+): StreamMetadata[] {
+  return streams.filter((stream) => stream.message.case === "subtitle");
+}
+
+/**
+ * @public
+ * Returns the stream keys for audio streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The audio stream keys in the media context
+ */
+export function audioStreamKeys(
+  streams: readonly StreamMetadata[]
+): StreamKey[] {
+  return removeUndefined(
+    audioStreams(streams).map((stream) => stream.streamKey)
+  );
+}
+
+/**
+ * @public
+ * Returns the stream keys for video streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The video stream keys in the media context
+ */
+export function videoStreamKeys(
+  streams: readonly StreamMetadata[]
+): StreamKey[] {
+  return removeUndefined(
+    videoStreams(streams).map((stream) => stream.streamKey)
+  );
+}
+
+/**
+ * @public
+ * Returns the stream keys for subtitle streams in a media context
+ * @param streams - The media context from which to return the stream keys
+ * @returns The subtitle stream keys in the media context
+ */
+export function subtitleStreamKeys(
+  streams: readonly StreamMetadata[]
+): StreamKey[] {
+  return removeUndefined(
+    subtitleStreams(streams).map((stream) => stream.streamKey)
+  );
+}
+
+function removeUndefined<T>(values: readonly (T | undefined)[]): T[] {
+  // This isn't really typechecked as you would like :(
+  return values.filter((v): v is T => v !== undefined);
+}
+
+/** @public */
+export function newSilentMatrix(rows: number, cols: number): Gain[][] {
+  return new Array(rows).fill(0).map(() => new Array(cols).fill(null));
+}
+
+/** @public */
+export function mkSine(freq: number) {
+  return new Wave({ message: { case: "sine", value: new SineWave({ freq }) } });
+}
+
+/**
+ * @public
+ * Select all the audio and video streams from the input
+ * @param streams - The streams from the inbound Context
+ * @returns Array of selected StreamKeys
+ */
+export function selectAV(streams: readonly StreamMetadata[]): StreamKey[] {
+  const audio = audioStreamKeys(streams);
+  const video = videoStreamKeys(streams);
+  return audio.concat(video);
+}
+
+/** @public */
+export function selectSubtitles(
+  streams: readonly StreamMetadata[]
+): StreamKey[] {
+  return subtitleStreamKeys(streams);
+}
+
+/** @public */
+export function selectAudio(streams: readonly StreamMetadata[]): StreamKey[] {
+  return audioStreamKeys(streams);
+}
+
+/** @public */
+export function selectVideo(streams: readonly StreamMetadata[]): StreamKey[] {
+  return videoStreamKeys(streams);
+}
+
+/** @public */
+export function selectAllVideos(
+  count: number
+): (streams: readonly StreamMetadata[]) => StreamKey[] {
+  return (streams: readonly StreamMetadata[]) => {
+    const video = videoStreamKeys(streams);
+    if (video.length == count) {
+      return video;
+    }
+    return [];
+  };
+}
+
+/** @public */
+export function selectAllAudios(
+  count: number
+): (streams: readonly StreamMetadata[]) => StreamKey[] {
+  return (streams: readonly StreamMetadata[]) => {
+    const audio = audioStreamKeys(streams);
+    if (audio.length == count) {
+      return audio;
+    }
+    return [];
+  };
+}
+
+/**
+ * @public
+ * Generate encryption parameters from from an encryption KeyID and Key,
+ * in the form KEYID:KEY, both 16byte hexadecimal
+ */
+export function mkEncryption(
+  encryption: string | undefined
+): { encryptionKey: string; encryptionKeyId: string } | undefined {
+  let encryption_params = encryption
+    ? encryption.split(":").map((s) => s.trim())
+    : undefined;
+  if (encryption_params && encryption_params.length !== 2) {
+    console.log(
+      "Warning: bad encryption format, must have two fields (hexadecimal key id and hexadecimal key)"
+    );
+    encryption_params = undefined;
+  }
+  return encryption_params
+    ? {
+      encryptionKeyId: encryption_params[0],
+      encryptionKey: encryption_params[1],
+    }
+    : undefined;
+}
+
+/** @public */
+export const videoToPin = <Pins extends string>(pin: Pins) => {
+  return (streams: StreamMetadata[]): PinToKey<Pins> => {
+    const video = videoStreamKeys(streams);
+    if (video.length == 1) {
+      // I want to do this, but it loses the types
+      //       return { [pin]: video };
+      let o: PinToKey<Pins> = {};
+      o[pin] = video;
+      return o;
+    }
+    return undefined;
+  };
+};
+
+/** @public */
+export const audioToPin = <Pins extends string>(pin: Pins) => {
+  return (streams: StreamMetadata[]): PinToKey<Pins> => {
+    const audio = audioStreamKeys(streams);
+    if (audio.length >= 1) {
+      // I want to do this, but it loses the types
+      //       return { [pin]: video };
+      let o: PinToKey<Pins> = {};
+      o[pin] = audio;
+      return o;
+    }
+    return undefined;
+  };
+};
+
+/** @public */
+export const avToPin = <Pins extends string>(pin: Pins) => {
+  return (streams: StreamMetadata[]): PinToKey<Pins> => {
+    const audio = audioStreamKeys(streams);
+    const video = videoStreamKeys(streams);
+    const keys = audio.concat(video);
+    if (keys.length > 1) {
+      // I want to do this, but it loses the types
+      //       return { [pin]: video };
+      let o: PinToKey<Pins> = {};
+      o[pin] = keys;
+      return o;
+    }
+    return undefined;
+  };
+};
+
+/** @public */
+export const subtitlesToPin = <Pins extends string>(pin: Pins) => {
+  return (streams: StreamMetadata[]): PinToKey<Pins> => {
+    const subs = subtitleStreamKeys(streams);
+    if (subs.length == 1) {
+      let o: PinToKey<Pins> = {};
+      o[pin] = subs;
+      return o;
+    }
+    return undefined;
+  };
+};