@norskvideo/norsk-sdk 0.0.322

package/lib/src/media_nodes/processor.d.ts

@@ -0,0 +1,515 @@
+import { MediaClient } from "@norskvideo/norsk-api/lib/media_grpc_pb";
+import { StreamStatsSampling, Subscription } from "@norskvideo/norsk-api/lib/media_pb";
+import { FrameRate } from "../types";
+import { AutoSinkMediaNode, MediaNodeState, SourceMediaNode, SourceNodeSettings, StreamStatsMixin } from "./common";
+import { AacProfile, AudioLevels, ChannelLayout, ComposeMissingStreamBehaviour, Db, NetintH264, NetintHevc, NvidiaH264, NvidiaHevc, PixelFormat, SampleAspectRatio, Resolution, SampleRate, SentenceBuildMode, SimpleEasing, StabilizationMode, StreamKey, X264Codec, X265Codec, MultiStreamStats } from "./types";
+import { PlainMessage } from "@bufbuild/protobuf";
+interface ProcessorMediaNode<Pins extends string> extends SourceMediaNode, AutoSinkMediaNode<Pins> {
+}
+declare class ProcessorMediaNode<Pins extends string> {
+    constructor(client: MediaClient, subscribeFn: (subscription: Subscription) => void);
+}
+interface AutoProcessorMediaNode<Pins extends string> extends SourceMediaNode, AutoSinkMediaNode<Pins> {
+}
+declare class AutoProcessorMediaNode<Pins extends string> {
+    constructor(client: MediaClient, subscribeFn: (subscription: Subscription) => void);
+}
+/** @public */
+export interface ProcessorNodeSettings<T extends MediaNodeState> extends SourceNodeSettings<T> {
+}
+/** @public */
+export interface HardSwitcherSettings<Pins extends string> extends ProcessorNodeSettings<HardSwitcherNode<Pins>> {
+    activeSource: Pins;
+    outputSource: string;
+}
+/**
+ * @public
+ * {@link NorskControl.hardSwitcher}
+ */
+export declare class HardSwitcherNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    switchSource(newSource: Pins): void;
+    close(): void;
+}
+/** @public */
+export interface SmoothSwitcherSettings<Pins extends string> extends ProcessorNodeSettings<SmoothSwitcherNode<Pins>> {
+    activeSource?: Pins;
+    outputSource: string;
+    transitionDurationMs?: number;
+    outputResolution: Resolution;
+    sampleRate: SampleRate;
+}
+/**
+ * @public
+ * {@link NorskControl.smoothSwitcher}
+ */
+export declare class SmoothSwitcherNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    switchSource(newSource: Pins): void;
+    close(): void;
+}
+/**
+ * @public
+ * Settings for an {@link StreamStatsNode}
+ */
+export interface StreamStatsSettings extends ProcessorNodeSettings<StreamStatsNode>, StreamStatsMixin {
+    /**
+     * Called periodically with the stream stats
+     * @param stats - The statistics for the stream
+     * @eventProperty
+     */
+    onStreamStats: (stats: MultiStreamStats) => void;
+    /**
+     * Sampling rates for stream stats, in seconds
+     */
+    statsSampling?: PlainMessage<StreamStatsSampling>;
+}
+/**
+ * @public
+ * Monitor statistics about a media stream. Create a new instance of this node with {@link NorskControl.streamStats}.
+ */
+export declare class StreamStatsNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    close(): void;
+}
+/**
+ * @public
+ * Settings for an {@link AudioLevelsNode}
+ */
+export interface AudioLevelsSettings extends ProcessorNodeSettings<AudioLevelsNode> {
+    /**
+     * Called with the audio level data
+     * @param levels - The level data for the audio stream
+     * @eventProperty
+     */
+    onData: (levels: AudioLevels) => void;
+    intervalFrames?: number;
+}
+/**
+ * @public
+ * Monitor audio levels. Create a new instance of this node with {@link NorskControl.audioLevels}.
+ */
+export declare class AudioLevelsNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+/** @public */
+export interface TimestampNudgerSettings extends ProcessorNodeSettings<TimestampNudgerNode> {
+    nudge?: number;
+}
+/**
+ * @public
+ * {@link NorskTransform.timestampNudge}
+ */
+export declare class TimestampNudgerNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    nudge(nudge: number): void;
+    close(): void;
+}
+/** @public */
+export interface StreamKeyOverrideSettings extends ProcessorNodeSettings<StreamKeyOverrideNode> {
+    streamKey: StreamKey;
+}
+/**
+ * @public
+ * {@link NorskTransform.streamKeyOverride}
+ */
+export declare class StreamKeyOverrideNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    close(): void;
+}
+/** @public */
+export interface MetadataOverrideSettings extends ProcessorNodeSettings<MetadataOverrideNode>, MetadataOverrideSettingsUpdate {
+}
+/** @public */
+export interface MetadataOverrideSettingsUpdate {
+    video?: {
+        /** Override the bitrate metadata of a compressed video stream, or `0` to clear */
+        bitrate?: number;
+    };
+    audio?: {
+        /** Override the bitrate metadata of a compressed audio stream, or `0` to clear */
+        bitrate?: number;
+        /** Override the language metadata of an audio stream, or `""` to clear */
+        language?: string;
+    };
+    subtitles?: {
+        /** Override the language metadata of a subtitles stream, or `""` to clear */
+        language?: string;
+    };
+}
+/**
+ * @public
+ * {@link NorskTransform.metadataOverride}
+ */
+export declare class MetadataOverrideNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    updateConfig(settings: MetadataOverrideSettingsUpdate): void;
+    close(): void;
+}
+/** @public */
+export interface SyncSettings extends ProcessorNodeSettings<SyncNode> {
+}
+/**
+ * @public
+ * {@link NorskTransform.sync}
+ */
+export declare class SyncNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    close(): void;
+}
+/** @public */
+export interface OpusSettings {
+    kind: "opus";
+}
+/** @public */
+export interface AacSettings {
+    kind: "aac";
+    sampleRate: SampleRate;
+    profile: AacProfile;
+}
+/** @public */
+export interface AudioEncoderSettings extends ProcessorNodeSettings<AudioEncoderNode> {
+    channelLayout: ChannelLayout;
+    bitrate: number;
+    outputRenditionName: string;
+    codec: OpusSettings | AacSettings;
+}
+/**
+ * @public
+ * {@link NorskTransform.audioEncoder}
+ */
+export declare class AudioEncoderNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+/** @public */
+export interface OffsetRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** @public */
+export interface ComposePart<Pins> {
+    pin: Pins;
+    sourceRect: OffsetRect;
+    destRect: OffsetRect;
+    zIndex: number;
+    opacity: number;
+    id?: string;
+    transition?: PartTransition;
+    referenceResolution?: Resolution;
+}
+/** @public */
+export interface PartTransition {
+    durationMs: number;
+    easing?: SimpleEasing;
+}
+/** @public */
+export interface ComposeVideoSettings<Pins extends string> extends ProcessorNodeSettings<ComposeVideoNode<Pins>> {
+    referenceStream: Pins;
+    parts: readonly ComposePart<Pins>[];
+    referenceResolution?: Resolution;
+    outputResolution: Resolution;
+    outputPixelFormat?: PixelFormat;
+    missingStreamBehaviour?: ComposeMissingStreamBehaviour;
+    onTransitionComplete?: () => void;
+}
+/** @public */
+export interface ComposeVideoSettingsUpdate<Pins extends string> {
+    parts: readonly ComposePart<Pins>[];
+}
+/**
+ * @public
+ * {@link NorskTransform.composeOverlay}
+ */
+export declare class ComposeVideoNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    updateConfig(settings: ComposeVideoSettingsUpdate<Pins>): void;
+    close(): void;
+}
+/** @public */
+export interface AudioMixerSource<Pins> {
+    /** The name of the InputPin for this source */
+    pin: Pins;
+    /** A vector of gains for this source, one for each channel */
+    channelGains?: readonly Gain[];
+}
+/** @public */
+export interface AudioMixerSettings<Pins extends string> extends ProcessorNodeSettings<AudioMixerNode<Pins>> {
+    /** The sources to mix */
+    sources: readonly AudioMixerSource<Pins>[];
+    /** The name of the output source */
+    outputSource: string;
+    /** The sample rate of the output */
+    sampleRate?: SampleRate;
+}
+/** @public */
+export interface AudioMixerSettingsUpdate<Pins extends string> {
+    sources: readonly AudioMixerSource<Pins>[];
+}
+/**
+ * @public
+ * {@link NorskTransform.audioMixer}
+ */
+export declare class AudioMixerNode<Pins extends string> extends ProcessorMediaNode<Pins> {
+    updateConfig(settings: AudioMixerSettingsUpdate<Pins>): void;
+    close(): void;
+}
+/**
+ * @public
+ * A relative change in decibels, expressing a power ratio.
+ *
+ * A value of 0dB means no change, positive values mean an increase in power, and negative values mean a decrease in power.
+ */
+export declare type Gain = Db;
+/** @public Config for the {@link AudioMatrixMixerNode} */
+export interface AudioMatrixMixerSettings extends ProcessorNodeSettings<AudioMatrixMixerNode> {
+    /** The NxM matrix of gains from N input channels to M output channels */
+    channelGains: readonly Gain[][];
+    /** The desired output channel layout, such as "5.1" */
+    outputChannelLayout: ChannelLayout;
+}
+/** @public Config update for the {@link AudioMatrixMixerNode}.
+ * Call {@link AudioMatrixMixerNode.updateConfig} for updating the config.
+ */
+export interface AudioMatrixMixerSettingsUpdate {
+    /** The NxM updated matrix of gains from N input channels to M output channels */
+    channelGains: readonly Gain[][];
+}
+/**
+ * @public Mix N audio channels to M audio channels with a matrix of gains.
+ * Use {@link NorskTransform.audioMatrixMixer} to create one.
+ */
+export declare class AudioMatrixMixerNode extends AutoProcessorMediaNode<"audio"> {
+    /** @public */
+    updateConfig(settings: AudioMatrixMixerSettingsUpdate): void;
+    close(): void;
+}
+/** @public */
+export interface AudioGainSettings extends ProcessorNodeSettings<AudioGainNode> {
+    /** A vector of gains for this source, one for each channel */
+    channelGains: readonly Gain[];
+}
+/** @public */
+export interface AudioGainSettingsUpdate {
+    /** A vector of gains for this source, one for each channel */
+    channelGains?: readonly Gain[];
+}
+/**
+ * @public
+ * {@link NorskTransform.audioGain}
+ */
+export declare class AudioGainNode extends AutoProcessorMediaNode<"audio"> {
+    updateConfig(settings: AudioGainSettingsUpdate): void;
+    close(): void;
+}
+/** @public */
+export interface AudioSplitMultichannelSettings extends ProcessorNodeSettings<AudioSplitMultichannelNode> {
+    outputStreamKey: StreamKey;
+}
+/**
+ * @public
+ * {@link NorskTransform.audioSplitMultichannel}
+ */
+export declare class AudioSplitMultichannelNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+/** @public */
+export interface AudioBuildMultichannelSettings extends ProcessorNodeSettings<AudioBuildMultichannelNode> {
+    channelLayout: ChannelLayout;
+    channelList: readonly StreamKey[];
+    outputStreamKey: StreamKey;
+}
+/**
+ * @public
+ * {@link NorskTransform.audioBuildMultichannel}
+ */
+export declare class AudioBuildMultichannelNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+/** @public */
+export interface AwsTranscribeSettings extends ProcessorNodeSettings<AwsTranscribeNode> {
+    awsRegion: string;
+    outputStreamId: number;
+    language: string;
+    sentenceBuildMode: SentenceBuildMode;
+    sentenceStabilizationMode: StabilizationMode;
+}
+/**
+ * @public
+ * {@link NorskTransform.awsTranscribe}
+ */
+export declare class AwsTranscribeNode extends AutoProcessorMediaNode<"audio"> {
+    close(): void;
+}
+/**
+ * @public
+ * Methods that allow you to both ingest and egest media from your application
+ * at the same time
+ */
+export interface NorskDuplex {
+    /**
+     * Playback audio/video via webrtc to a browser, and accept audio/video input from a browser.
+     * The browser client must conform to a custom protocol as implemented in the hosted test page.
+     * For general WebRTC ingest prefer the WHIP input node, and for egest to a downstream media server
+     * use the WHIP output node.
+     * @param settings - Options for the webrtc node
+     */
+    localWebRTC(settings: LocalWebRTCSettings): Promise<LocalWebRTCNode>;
+}
+/** @public */
+export interface VideoEncodeLadderRung {
+    name: string;
+    width: number;
+    height: number;
+    frameRate?: FrameRate;
+    /**
+     * Specifies the input video's Sample Aspect Ratio (SAR) to be used by the
+     * encoder in width:height
+     */
+    sar?: SampleAspectRatio;
+    codec: X264Codec | X265Codec | NvidiaH264 | NvidiaHevc | NetintH264 | NetintHevc;
+}
+/** @public */
+export interface VideoEncodeLadderSettings extends ProcessorNodeSettings<VideoEncodeLadderNode> {
+    rungs: readonly VideoEncodeLadderRung[];
+}
+/**
+ * @public
+ * {@link NorskTransform.videoEncodeLadder}
+ */
+export declare class VideoEncodeLadderNode extends AutoProcessorMediaNode<"video"> {
+    close(): void;
+}
+/** @public */
+export interface VideoTransformSettings extends ProcessorNodeSettings<VideoTransformNode> {
+    resolution?: Resolution;
+    frameRate?: FrameRate;
+    sar?: SampleAspectRatio;
+}
+/**
+ * @public
+ * {@link NorskTransform.videoTransform}
+ */
+export declare class VideoTransformNode extends AutoProcessorMediaNode<"video"> {
+    close(): void;
+}
+/** @public */
+export interface DropRandom {
+    kind: "random";
+    percentage: number;
+}
+/** @public */
+export interface DropEvery {
+    kind: "every";
+    every: number;
+}
+/** @public */
+export interface ChaosMonkeySettings extends ProcessorNodeSettings<ChaosMonkeyNode> {
+    frameDrop?: DropRandom | DropEvery;
+}
+/**
+ * @public
+ * {@link NorskTransform.chaosMonkey}
+ */
+export declare class ChaosMonkeyNode extends AutoProcessorMediaNode<"audio" | "video" | "subtitle"> {
+    close(): void;
+}
+/** @public */
+export interface LocalWebRTCSettings extends ProcessorNodeSettings<LocalWebRTCNode>, StreamStatsMixin {
+}
+/**
+ * @public
+ * {@link NorskDuplex.localWebRTC}
+ */
+export declare class LocalWebRTCNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    /** @public The URL of the local player */
+    playerUrl: string;
+    close(): void;
+}
+/**
+ * @public
+ * Methods that allow you to manipulate your media streams
+ */
+export interface NorskTransform {
+    /**
+     * Encode a video stream to one or more renditions
+     * @param settings - Encode ladder settings
+     */
+    videoEncodeLadder(settings: VideoEncodeLadderSettings): Promise<VideoEncodeLadderNode>;
+    /**
+     * Transform a video stream (rescale, etc)
+     * @param settings - Transform settings
+     */
+    videoTransform(settings: VideoTransformSettings): Promise<VideoTransformNode>;
+    /**
+     * Interferes with a stream by dropping frames
+     * @param settings - Chaos monkey settings
+     */
+    chaosMonkey(settings: ChaosMonkeySettings): Promise<ChaosMonkeyNode>;
+    /**
+     * Compose multiple video streams together into a single output
+     * @param settings - Composition setting
+     */
+    composeOverlay<Pins extends string>(settings: ComposeVideoSettings<Pins>): Promise<ComposeVideoNode<Pins>>;
+    awsTranscribe(settings: AwsTranscribeSettings): Promise<AwsTranscribeNode>;
+    /**
+     * Mix multiple audio streams together into a single output,
+     * with optional gain control on each input.
+     * @param settings - Settings for the mixer, including the gain vectors
+     */
+    audioMixer<Pins extends string>(settings: AudioMixerSettings<Pins>): Promise<AudioMixerNode<Pins>>;
+    /**
+     * Given an audio stream of N channels, mix it down to M channels through a matrix of NxM gains.
+     * @param settings - Settings for the mixer, including the gain matrix
+     */
+    audioMatrixMixer(settings: AudioMatrixMixerSettings): Promise<AudioMatrixMixerNode>;
+    /**
+     * Apply gain to an audio stream
+     * @param settings - Settings for the gain node
+     */
+    audioGain(settings: AudioGainSettings): Promise<AudioGainNode>;
+    audioBuildMultichannel(settings: AudioBuildMultichannelSettings): Promise<AudioBuildMultichannelNode>;
+    audioSplitMultichannel(settings: AudioSplitMultichannelSettings): Promise<AudioSplitMultichannelNode>;
+    audioEncoder(settings: AudioEncoderSettings): Promise<AudioEncoderNode>;
+    timestampNudge(settings: TimestampNudgerSettings): Promise<TimestampNudgerNode>;
+    streamKeyOverride(settings: StreamKeyOverrideSettings): Promise<StreamKeyOverrideNode>;
+    metadataOverride(settings: MetadataOverrideSettings): Promise<MetadataOverrideNode>;
+    sync(settings: SyncSettings): Promise<SyncNode>;
+}
+/**
+ * @public
+ * Methods that allow you to control and monitor media streams
+ */
+export interface NorskControl {
+    /**
+     * Switch between multiple input sources via a hard cut. May be used to switch between
+     * sources of possibly different configurations or without decoding.
+     * @param settings - Options for the switcher
+     */
+    hardSwitcher<Pins extends string>(settings: HardSwitcherSettings<Pins>): Promise<HardSwitcherNode<Pins>>;
+    /**
+     * Switch between multiple input sources without interruption, via a transition.
+     * @param settings - Options for the switcher
+     */
+    smoothSwitcher<Pins extends string>(settings: SmoothSwitcherSettings<Pins>): Promise<SmoothSwitcherNode<Pins>>;
+    /**
+     * Record statistical information about media streams, including bitrate,
+     * frame rate, and number of keyframes, measured over some configurable
+     * sampling windows.
+     * @param settings - Callback and sampling intervals
+     */
+    streamStats(settings: StreamStatsSettings): Promise<StreamStatsNode>;
+    /**
+     * Monitor the volume of an audio stream
+     * @param settings - Callback and options for the level data
+     */
+    audioLevels(settings: AudioLevelsSettings): Promise<AudioLevelsNode>;
+}
+/** @public */
+export declare class NorskProcessor {
+    /**
+     * Implements the {@link NorskControl} interface
+     */
+    control: NorskControl;
+    /**
+     * Implements the {@link NorskTransform} interface
+     */
+    transform: NorskTransform;
+    close(): Promise<void>;
+    constructor(client: MediaClient);
+}
+export {};
+//# sourceMappingURL=processor.d.ts.map