@norskvideo/norsk-sdk 1.0.343 → 1.0.344

package/dist/norsk-sdk.d.ts

@@ -5,10 +5,10 @@ import { CmafAudioMessage } from '@norskvideo/norsk-api/lib/media_pb';
 import { CmafMultiVariantMessage } from '@norskvideo/norsk-api/lib/media_pb';
 import { CmafVideoMessage } from '@norskvideo/norsk-api/lib/media_pb';
 import { CmafWebVttMessage } from '@norskvideo/norsk-api/lib/media_pb';
-import { Context } from '@norskvideo/norsk-api/lib/media_pb';
 import { CurrentLoad } from '@norskvideo/norsk-api/lib/shared/common_pb';
 import { ExplicitChannel } from '@norskvideo/norsk-api/lib/media_pb';
 import { FileTsInputMessage } from '@norskvideo/norsk-api/lib/media_pb';
+import { FrameRate as FrameRate_2 } from '@norskvideo/norsk-api/lib/media_pb';
 import { GopStructure } from '@norskvideo/norsk-api/lib/media_pb';
 import * as grpc from '@grpc/grpc-js';
 import { HlsOutputEvent } from '@norskvideo/norsk-api/lib/media_pb';
@@ -412,7 +412,7 @@ export declare interface AutoProcessorMediaNode<Pins extends string> extends Sou
 }
 
 export declare class AutoProcessorMediaNode<Pins extends string> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, getGrpcStream: () => (Readable | Writable), subscribeFn: (subscription: Subscription) => void, subscribeErrorFn?: (error: SubscriptionError) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, getGrpcStream: () => (Readable | Writable), subscribeFn: (subscription: Subscription) => Promise<boolean>, subscribeErrorFn?: (error: SubscriptionError) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
 }
 
 /** @public */
@@ -774,12 +774,12 @@ export declare interface CmafMultiVariantOutputSettings extends SinkNodeSettings
 }
 
 declare class CmafNodeBase<ClientMessage, Pins extends string, T extends MediaNodeState> extends AutoProcessorMediaNode<Pins> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => void, playlistPath: PlaylistPath, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, _playlistPath: PlaylistPath, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
     close(): void;
 }
 
 declare class CmafNodeWithPlaylist<ClientMessage, Pins extends string, T extends MediaNodeState> extends CmafNodeBase<ClientMessage, Pins, T> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => void, playlistPath: PlaylistPath, sessionId: string);
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, playlistPath: PlaylistPath, sessionId: string);
     /**
      * @public
      * Returns the URL to the HLS playlist entry.  Note this can only be evaluated once the stream is active as it
@@ -984,6 +984,11 @@ export declare interface ComposePart<Pins> {
     referenceResolution?: Resolution;
 }
 
+/** @public */
+export declare interface Context {
+    streams: StreamMetadata[];
+}
+
 /** @public */
 export declare type ContextType = "full" | "singleSource" | "singleProgram" | "singleStream" | "singleRendition";
 
@@ -1065,6 +1070,9 @@ export declare type DeckLinkVideoConnection = "sdi" | "hdmi" | "optical_sdi" | "
 /**  @public */
 export declare type DeckLinkVideoIOSupport = "capture" | "playback";
 
+/** @public */
+export declare type DeferredVideoComposeSettings<Pins extends string> = (streams: StreamMetadata[]) => VideoComposeSettings<Pins> | undefined;
+
 /**
  * @public
  * Drop every N frames from an incoming video stream
@@ -1939,6 +1947,11 @@ export declare interface NorskInput {
      * @param settings - Configuration for the RTP input
      */
     rtp(settings: RtpInputSettings): Promise<RtpInputNode>;
+    /**
+     * Generate a test video card with a configurable pattern.
+     * @param settings - Configuration for the video test card
+     */
+    videoTestCard(settings: VideoTestcardGeneratorSettings): Promise<VideoTestcardGeneratorNode>;
     /**
      * Generate a test audio signal with a configurable waveform.
      * @param settings - Configuration for the audio signal
@@ -2183,7 +2196,7 @@ export declare interface NorskTransform {
      * Compose multiple video streams together into a single output
      * @param settings - Composition settings
      */
-    videoCompose<Pins extends string>(settings: VideoComposeSettings<Pins>): Promise<VideoComposeNode<Pins>>;
+    videoCompose<Pins extends string>(settings: VideoComposeSettings<Pins> | DeferredVideoComposeSettings<Pins>): Promise<VideoComposeNode<Pins>>;
     /**
      * Create a Media Node performing transcription into subtitles using the
      * Amazon Transcribe AWS service.
@@ -2283,7 +2296,7 @@ export declare interface NorskTransform {
      * of the time taken to set up connections and subscriptions across various protocols, are off by a few
      * hundred milliseconds
      */
-    streamProgramJoin(settings: StreamProgramJoinSettings): Promise<StreamProgramJoinNode>;
+    streamAlign(settings: StreamAlignSettings): Promise<StreamAlignNode>;
     ancillary(settings: AncillarySettings): Promise<AncillaryNode>;
 }
 
@@ -2504,6 +2517,8 @@ export declare interface PartTransition {
     easing?: SimpleEasing;
 }
 
+declare type Pattern = "black" | "smpte75" | "smpte100";
+
 /** @public */
 export declare type PinToKey<Pins extends string> = Nullable<Partial<Record<Pins, StreamKey[]>>>;
 
@@ -2545,7 +2560,7 @@ export declare interface ProcessorMediaNode<Pins extends string> extends SourceM
 }
 
 export declare class ProcessorMediaNode<Pins extends string> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, getGrpcStream: () => (Readable | Writable), subscribeFn: (subscription: Subscription) => void, subscribeErrorFn?: (error: SubscriptionError) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, getGrpcStream: () => (Readable | Writable), subscribeFn: (subscription: Subscription) => Promise<boolean>, subscribeErrorFn?: (error: SubscriptionError) => void, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
 }
 
 /** @public */
@@ -2963,6 +2978,9 @@ export declare function selectAudio(streams: readonly StreamMetadata[]): StreamK
  */
 export declare function selectAV(streams: readonly StreamMetadata[]): StreamKey[];
 
+/** @public */
+export declare function selectExactKey(key: StreamKey): (streams: readonly StreamMetadata[]) => StreamKey[];
+
 /** @public */
 export declare function selectPlaylist(streams: readonly StreamMetadata[]): StreamKey[];
 
@@ -2988,7 +3006,7 @@ export declare interface SingleStreamStatistics extends StreamStatistics {
 }
 
 /** @public */
-export declare class SinkMediaNode<Pins extends string> extends MediaNodeState {
+export declare class SinkMediaNode<Pins extends string> extends MediaNodeState implements SubscribeDestination {
     permissiveSubscriptionValidation(_context: Context): SubscriptionValidationResponse;
     restrictiveSubscriptionValidation(context: Context): SubscriptionValidationResponse;
     /** Subscribe to the given sources.
@@ -3028,8 +3046,8 @@ export declare interface Smpte2038Message {
 /** @public */
 export declare class SourceMediaNode extends MediaNodeState {
     outputStreams: StreamMetadata[];
-    registerForContextChange(subscriber: SinkMediaNode<string>): void;
-    unregisterForContextChange(subscriber: SinkMediaNode<string>): void;
+    registerForContextChange(subscriber: SubscribeDestination): void;
+    unregisterForContextChange(subscriber: SubscribeDestination): void;
 }
 
 /** @public */
@@ -3075,6 +3093,9 @@ export declare type SourceSubscriptionError = {
     reason: "unsupportedConversion";
 };
 
+/** @public */
+export declare function sourceToPin<Pins extends string>(source: string, pin: Pins): (streams: StreamMetadata[]) => PinToKey<Pins>;
+
 /**
  * @public
  * The return value for the {@link SrtInputSettings.onConnection} callback
@@ -3212,6 +3233,26 @@ export declare interface SrtOutputSettings extends SinkNodeSettings<SrtOutputNod
 /** @public */
 export declare type StabilizationMode = "low" | "medium" | "high";
 
+/**
+ * @public
+ * see: {@link NorskTransform.streamSync}
+ */
+export declare class StreamAlignNode extends AutoProcessorMediaNode<"audio" | "video"> {
+    close(): void;
+}
+
+/**
+ * @public
+ * Settings for a StreamAlign node
+ * This will reset all streams to the same framerates/sample rates
+ * and align their timestamps so that they completely line up for downstream operations
+ * see {@link NorskTransform.streamAlign}
+ * */
+export declare interface StreamAlignSettings extends ProcessorNodeSettings<StreamAlignNode> {
+    sampleRate: SampleRate;
+    frameRate: FrameRate;
+}
+
 /**
  * @public
  * see: {@link NorskTransform.streamChaosMonkey}
@@ -3262,6 +3303,11 @@ export declare interface StreamKeyOverrideSettings extends ProcessorNodeSettings
     streamKey: StreamKey;
 }
 
+/**
+ * Compares two stream keys by value, returning true if the stream keys refer to the same stream
+ */
+export declare function streamKeysAreEqual(l: StreamKey, r: StreamKey): unknown;
+
 /** @public */
 export declare interface StreamKeySettings {
     /**  Source name. Default: the rtmp app */
@@ -3341,22 +3387,6 @@ export declare interface StreamMetadataOverrideSettingsUpdate {
     };
 }
 
-/**
- * @public
- * see: {@link NorskTransform.streamSync}
- */
-export declare class StreamProgramJoinNode extends AutoProcessorMediaNode<"audio" | "video"> {
-    close(): void;
-}
-
-/**
- * @public
- * Settings for a StreamProgramJoin node
- * see {@link NorskTransform.streamSync}
- * */
-export declare interface StreamProgramJoinSettings extends ProcessorNodeSettings<StreamProgramJoinNode> {
-}
-
 /** @public */
 export declare interface StreamStatistics {
     /** The size of the sample window in seconds */
@@ -3463,8 +3493,20 @@ export declare interface StreamSwitchSmoothSettings<Pins extends string> extends
     transitionDurationMs?: number;
     /** The constant resolution that all output video will be scaled to */
     outputResolution: Resolution;
+    /** The constant framerate that all output video will be sampled to */
+    frameRate: FrameRate;
     /** The constant samplerate that all output audio will be resampled to */
     sampleRate: SampleRate;
+    /** The constant channel layout that all output audio will be resampled to */
+    channelLayout: ChannelLayout;
+    /** Alignment behaviour of the component
+     * whether to rebase all incoming streams to a common timeline
+     * Note: This will modify the timestamps, meaning that merging streams not involved in this may result in
+     * operation may result in sync issues. To avoid this, you can use {@link NorskProcessor.streamAlign} instead of relying
+     * on this component for this behaviour
+     * Note: This behaviour may be removed in a future release and replaced with something similar
+     * */
+    alignment?: "aligned" | "not_aligned";
     /** Callback which will be called if a switch request cannot be fulfilled */
     onSwitchError?: (message: string, inputPin?: Pins) => void;
     /** Callback which will be called a transition has succesfully completed for a requested switch, i.e. the new source
@@ -3521,6 +3563,11 @@ export declare interface StreamTimestampNudgeSettings extends ProcessorNodeSetti
     nudge?: number;
 }
 
+export declare interface SubscribeDestination {
+    id?: string;
+    sourceContextChange(responseCallback: (error?: SubscriptionError) => void): Promise<boolean>;
+}
+
 /**
  * @public
  * Errors found while setting up subscriptions, separated out by reason:
@@ -3825,6 +3872,7 @@ export declare interface VideoStreamMetadata {
     codec: string;
     width: number;
     height: number;
+    frameRate?: FrameRate_2;
 }
 
 /**
@@ -3835,6 +3883,37 @@ export declare interface VideoStreamMetadata {
  */
 export declare function videoStreams(streams: readonly StreamMetadata[]): StreamMetadata[];
 
+/**
+ * @public
+ * see: {@link NorskInput.audioSignal}
+ */
+export declare class VideoTestcardGeneratorNode extends SourceMediaNode {
+    close(): void;
+}
+
+/**
+ * @public
+ * Settings for an Video Testcard Generator
+ * see: {@link NorskInput.videoTestcard}
+ * */
+export declare interface VideoTestcardGeneratorSettings extends SourceNodeSettings<VideoTestcardGeneratorNode> {
+    /** The source name to set in the stream key of the outgoing stream */
+    sourceName: string;
+    /** The number of frames to send before shutting down */
+    numberOfFrames?: number;
+    /** Resolution of the test card stream **/
+    resolution: {
+        width: number;
+        height: number;
+    };
+    /** Framerate of the produced video stream **/
+    frameRate: {
+        frames: number;
+        seconds: number;
+    };
+    pattern: Pattern;
+}
+
 /** @public */
 export declare function videoToPin<Pins extends string>(pin: Pins): (streams: StreamMetadata[]) => PinToKey<Pins>;
 

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

@@ -1,7 +1,7 @@
 import { MediaClient } from "@norskvideo/norsk-api/lib/media_grpc_pb";
-import { Context, StreamStatisticsSampling, GopStructure } from "@norskvideo/norsk-api/lib/media_pb";
+import { StreamStatisticsSampling, GopStructure } from "@norskvideo/norsk-api/lib/media_pb";
 import { Nullable } from "typescript-nullable";
-import { StreamKey, MediaNodeId, StreamMetadata, MultiStreamStatistics, SubscriptionError } from "./types";
+import { StreamKey, MediaNodeId, StreamMetadata, Context, MultiStreamStatistics, SubscriptionError } from "./types";
 export * from "../shared/utils";
 import { PlainMessage } from "@bufbuild/protobuf";
 /**
@@ -74,11 +74,15 @@ export declare type ReceiveFromAddressAuto = {
 };
 /** @public */
 export declare type PinToKey<Pins extends string> = Nullable<Partial<Record<Pins, StreamKey[]>>>;
+export interface SubscribeDestination {
+    id?: string;
+    sourceContextChange(responseCallback: (error?: SubscriptionError) => void): Promise<boolean>;
+}
 /** @public */
 export declare class SourceMediaNode extends MediaNodeState {
     outputStreams: StreamMetadata[];
-    registerForContextChange(subscriber: SinkMediaNode<string>): void;
-    unregisterForContextChange(subscriber: SinkMediaNode<string>): void;
+    registerForContextChange(subscriber: SubscribeDestination): void;
+    unregisterForContextChange(subscriber: SubscribeDestination): void;
 }
 /**
  * @public
@@ -91,7 +95,7 @@ export declare class SourceMediaNode extends MediaNodeState {
  * */
 export declare type SubscriptionValidationResponse = true | false | "accept" | "deny" | "accept_and_terminate";
 /** @public */
-export declare class SinkMediaNode<Pins extends string> extends MediaNodeState {
+export declare class SinkMediaNode<Pins extends string> extends MediaNodeState implements SubscribeDestination {
     permissiveSubscriptionValidation(_context: Context): SubscriptionValidationResponse;
     restrictiveSubscriptionValidation(context: Context): SubscriptionValidationResponse;
     /** Subscribe to the given sources.

package/lib/src/media_nodes/common.js

@@ -44,6 +44,7 @@ const types_1 = require("./types");
 __exportStar(require("../shared/utils"), exports);
 const utils_1 = require("../shared/utils");
 const crypto_1 = require("crypto");
+const sdk_1 = require("../sdk");
 /** @internal */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function applyMixins(derivedCtor, baseCtors) {
@@ -182,24 +183,24 @@ class SinkMediaNode extends MediaNodeState {
         const numStreams = context.streams.length;
         const expected = this.currentSubscription.sources.length;
         if (numStreams == 0 && this.subscriptionValidated) {
-            (0, utils_1.debuglog)("Node '%s' accepting inbound context because it is empty and we have previously accepted a full context %O", this.id, debugFormatContext(context));
+            (0, utils_1.debuglog)("Node '%s' accepting inbound context because it is empty and we have previously accepted a full context %O", this.id, debugFormatSdkContext(context));
             this.subscriptionValidated = false;
             return "accept";
         }
         if (this.currentSourcesActive < this.currentSources.size && !this.subscriptionValidated) {
-            (0, utils_1.debuglog)("Node '%s' ignoring inbound context because not all sources are active yet %O", this.id, debugFormatContext(context));
+            (0, utils_1.debuglog)("Node '%s' ignoring inbound context because not all sources are active yet %O", this.id, debugFormatSdkContext(context));
             return "deny";
         }
         if (this.currentSourcesActive < this.currentSources.size) {
-            (0, utils_1.debuglog)("Node '%s' ignoring inbound context because it is smaller than the already-accepted one %O", this.id, debugFormatContext(context));
+            (0, utils_1.debuglog)("Node '%s' ignoring inbound context because it is smaller than the already-accepted one %O", this.id, debugFormatSdkContext(context));
             return "deny";
         }
         if (numStreams == expected) {
-            (0, utils_1.debuglog)("Node '%s' accepting inbound context because all keys and streams are accounted for %O", this.id, debugFormatContext(context));
+            (0, utils_1.debuglog)("Node '%s' accepting inbound context because all keys and streams are accounted for %O", this.id, debugFormatSdkContext(context));
             this.subscriptionValidated = true;
             return "accept";
         }
-        (0, utils_1.debuglog)("Node '%s' ignoring inbound context because not all keys are accounted for yet %O", this.id, debugFormatContext(context));
+        (0, utils_1.debuglog)("Node '%s' ignoring inbound context because not all keys are accounted for yet %O", this.id, debugFormatSdkContext(context));
         return "deny";
     }
     /** Subscribe to the given sources.
@@ -267,7 +268,7 @@ class SinkMediaNode extends MediaNodeState {
                         this.currentSourcesActive += 1;
                         for (const pin in pinSubscriptions) {
                             (_a = pinSubscriptions[pin]) === null || _a === void 0 ? void 0 : _a.forEach((key) => {
-                                this.subscribedStreams.push(source.outputStreams.filter((streamMetadata) => streamMetadata.streamKey == key)[0]);
+                                this.subscribedStreams.push(source.outputStreams.filter((streamMetadata) => streamMetadata.streamKey && (0, sdk_1.streamKeysAreEqual)(streamMetadata.streamKey, key))[0]);
                                 subscriberSources.push((0, utils_1.provideFull)(media_pb_1.SubscribeSource, {
                                     stream: (0, types_1.mkStreamKey)(key),
                                     nodeId: (0, types_1.toMediaNodeId)(source.id),
@@ -284,39 +285,48 @@ class SinkMediaNode extends MediaNodeState {
             const id = (0, crypto_1.randomUUID)();
             this.currentSubscription = (0, utils_1.provideFull)(media_pb_1.Subscription, { sources, id });
             (0, utils_1.debuglog)("Node '%s' sending subscriptions %O", this.id, debugFormatSubscription(this.currentSubscription));
-            this.subscribeFn(this.currentSubscription);
-            this.subscriptionResponseCallbacks.set(id, responseCallback);
-            return true;
+            let subscribed = yield this.subscribeFn(this.currentSubscription);
+            if (subscribed)
+                this.subscriptionResponseCallbacks.set(id, responseCallback);
+            return subscribed;
         });
     }
     /** @internal */
     subscriptionResponse(response) {
-        const callback = this.subscriptionResponseCallbacks.get(response.id);
-        this.subscriptionResponseCallbacks.delete(response.id);
-        if (callback) {
-            if (response.error === undefined) {
-                callback();
-                if (this.subscribedStreamsChangedFn) {
-                    this.subscribedStreamsChangedFn(this.subscribedStreams);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.finaliseSubscription(response.id, response.error);
+        });
+    }
+    /** @internal */
+    finaliseSubscription(id, err) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const callback = this.subscriptionResponseCallbacks.get(id);
+            this.subscriptionResponseCallbacks.delete(id);
+            if (callback) {
+                if (err === undefined) {
+                    callback();
+                    if (this.subscribedStreamsChangedFn) {
+                        this.subscribedStreamsChangedFn(this.subscribedStreams);
+                    }
+                }
+                else {
+                    const error = (0, types_1.fromSubscriptionError)(err);
+                    (0, utils_1.debuglog)("Node '%s' has a failed subscription response for '%s': %O", this.id, id, error);
+                    callback(error);
+                    if (this.subscribeErrorFn) {
+                        this.subscribeErrorFn(error);
+                    }
                 }
             }
             else {
-                const error = (0, types_1.fromSubscriptionError)(response.error);
-                (0, utils_1.debuglog)("Node '%s' has a failed subscription response for '%s': %O", this.id, response.id, error);
-                callback(error);
-                if (this.subscribeErrorFn) {
-                    this.subscribeErrorFn(error);
-                }
+                (0, utils_1.debuglog)("Missing subscription response callback for '%s'", id);
             }
-        }
-        else {
-            (0, utils_1.debuglog)("Missing subscription response callback for '%s'", response.id);
-        }
+        });
     }
     /** @internal */
     handleInboundContext(context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const validationResponse = this.subscriptionValidation(context);
+            const validationResponse = this.subscriptionValidation((0, types_1.fromContext)(context));
             const responseFn = util
                 .promisify(this.client.sendValidationResponse)
                 .bind(this.client);
@@ -428,6 +438,36 @@ function registerStreamHandlers(grpcStream, unregisterNode, tag, reject, setting
 exports.registerStreamHandlers = registerStreamHandlers;
 ////////////////////////////////////////////////////////////////////////////////
 // debug
+function debugFormatSdkContext(context) {
+    return {
+        keys: context.streams.map((stream) => debugFormatSdkStreamMetadata(stream))
+    };
+}
+function debugFormatSdkStreamMetadata(stream) {
+    switch (stream.message.case) {
+        case "audio": {
+            return {
+                streamKey: (stream.streamKey),
+                audio: (stream.message.value),
+            };
+        }
+        case "video": {
+            return {
+                streamKey: (stream.streamKey),
+                video: (stream.message.value),
+            };
+        }
+        case "playlist": {
+            return {
+                streamKey: (stream.streamKey),
+                playlist: stream.message
+            };
+        }
+        default: {
+            return undefined;
+        }
+    }
+}
 function debugFormatContext(context) {
     return {
         keys: context.streams.map((stream) => debugFormatStreamMetadata(stream)),

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

@@ -511,6 +511,36 @@ export interface AudioSignalGeneratorSettings extends SourceNodeSettings<AudioSi
 export declare class AudioSignalGeneratorNode extends SourceMediaNode {
     close(): void;
 }
+/**
+ * @public
+ * Settings for an Video Testcard Generator
+ * see: {@link NorskInput.videoTestcard}
+ * */
+export interface VideoTestcardGeneratorSettings extends SourceNodeSettings<VideoTestcardGeneratorNode> {
+    /** The source name to set in the stream key of the outgoing stream */
+    sourceName: string;
+    /** The number of frames to send before shutting down */
+    numberOfFrames?: number;
+    /** Resolution of the test card stream **/
+    resolution: {
+        width: number;
+        height: number;
+    };
+    /** Framerate of the produced video stream **/
+    frameRate: {
+        frames: number;
+        seconds: number;
+    };
+    pattern: Pattern;
+}
+declare type Pattern = "black" | "smpte75" | "smpte100";
+/**
+ * @public
+ * see: {@link NorskInput.audioSignal}
+ */
+export declare class VideoTestcardGeneratorNode extends SourceMediaNode {
+    close(): void;
+}
 /**
  * @public
  * Settings for an image file source
@@ -632,6 +662,11 @@ export interface NorskInput {
      * @param settings - Configuration for the RTP input
      */
     rtp(settings: RtpInputSettings): Promise<RtpInputNode>;
+    /**
+     * Generate a test video card with a configurable pattern.
+     * @param settings - Configuration for the video test card
+     */
+    videoTestCard(settings: VideoTestcardGeneratorSettings): Promise<VideoTestcardGeneratorNode>;
     /**
      * Generate a test audio signal with a configurable waveform.
      * @param settings - Configuration for the audio signal

package/lib/src/media_nodes/input.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileMp4InputNode = exports.FileImageInputNode = exports.AudioSignalGeneratorNode = exports.BrowserInputNode = exports.M3u8InputNode = exports.UdpTsInputNode = exports.SrtInputNode = exports.FileTsInputNode = exports.FileWebVttInputNode = exports.WhipInputNode = exports.DeckLinkInputNode = exports.RtmpServerInputNode = exports.RtpInputNode = void 0;
+exports.FileMp4InputNode = exports.FileImageInputNode = exports.VideoTestcardGeneratorNode = exports.AudioSignalGeneratorNode = exports.BrowserInputNode = exports.M3u8InputNode = exports.UdpTsInputNode = exports.SrtInputNode = exports.FileTsInputNode = exports.FileWebVttInputNode = exports.WhipInputNode = exports.DeckLinkInputNode = exports.RtmpServerInputNode = exports.RtpInputNode = void 0;
 const media_pb_1 = require("@norskvideo/norsk-api/lib/media_pb");
 const types_1 = require("./types");
 const types_2 = require("../types");
@@ -1014,6 +1014,78 @@ class AudioSignalGeneratorNode extends common_1.SourceMediaNode {
     }
 }
 exports.AudioSignalGeneratorNode = AudioSignalGeneratorNode;
+function toPattern(p) {
+    switch (p) {
+        case "black":
+            return media_pb_1.TestCardPattern.Black;
+        case "smpte75":
+            return media_pb_1.TestCardPattern.Smpte75;
+        case "smpte100":
+            return media_pb_1.TestCardPattern.Smpte100;
+        default:
+            (0, utils_1.exhaustiveCheck)(p);
+    }
+}
+/**
+ * @public
+ * see: {@link NorskInput.audioSignal}
+ */
+class VideoTestcardGeneratorNode extends common_1.SourceMediaNode {
+    /** @internal */
+    constructor(settings, client, unregisterNode) {
+        var _a;
+        super(client, settings.onOutboundContextChange);
+        let id = settings.id
+            ? (0, utils_1.provideFull)(media_pb_1.MediaNodeId, { id: settings.id })
+            : undefined;
+        const config = (0, utils_1.provideFull)(media_pb_1.TestCardVideoConfiguration, {
+            numberOfFrames: (_a = settings.numberOfFrames) !== null && _a !== void 0 ? _a : 0,
+            realtime: true,
+            sourceName: settings.sourceName,
+            frameRate: (0, utils_1.provideFull)(media_pb_1.FrameRate, settings.frameRate),
+            resolution: (0, utils_1.provideFull)(media_pb_1.Resolution, settings.resolution),
+            pattern: toPattern(settings.pattern)
+        });
+        this.grpcStream = this.client.createInputVideoTestCardGenerator();
+        this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.VideoTestCardGeneratorMessage, (0, utils_1.mkMessageCase)({ setup: (0, utils_1.provideFull)(media_pb_1.TestCardVideoSetup, { id }) })));
+        this.grpcStream.write((0, utils_1.provideFull)(media_pb_1.VideoTestCardGeneratorMessage, (0, utils_1.mkMessageCase)({ configure: config })));
+        this.initialised = new Promise((resolve, reject) => {
+            this.grpcStream.on("data", (data) => {
+                const messageCase = data.message.case;
+                switch (messageCase) {
+                    case undefined:
+                        break;
+                    case "nodeId": {
+                        this.id = data.message.value.id;
+                        settings.onCreate && settings.onCreate(this);
+                        resolve();
+                        break;
+                    }
+                    case "outboundContext": {
+                        const context = data.message.value;
+                        this.outboundContextChange(context);
+                        break;
+                    }
+                    default:
+                        (0, utils_1.exhaustiveCheck)(messageCase);
+                }
+            });
+            (0, common_1.registerStreamHandlers)(this.grpcStream, () => unregisterNode(this), "videotestcard", reject, settings);
+        });
+    }
+    /** @internal */
+    static create(settings, client, unregisterNode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const node = new VideoTestcardGeneratorNode(settings, client, unregisterNode);
+            yield node.initialised;
+            return node;
+        });
+    }
+    close() {
+        this.grpcStream.cancel();
+    }
+}
+exports.VideoTestcardGeneratorNode = VideoTestcardGeneratorNode;
 /**
  * @public
  * see: {@link NorskInput.fileImage}

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

@@ -376,11 +376,11 @@ declare enum PlaylistPath {
     Ts = 1
 }
 declare class CmafNodeBase<ClientMessage, Pins extends string, T extends MediaNodeState> extends AutoProcessorMediaNode<Pins> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => void, playlistPath: PlaylistPath, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, _playlistPath: PlaylistPath, subscribedStreamsChangedFn?: (streams: StreamMetadata[]) => void);
     close(): void;
 }
 declare class CmafNodeWithPlaylist<ClientMessage, Pins extends string, T extends MediaNodeState> extends CmafNodeBase<ClientMessage, Pins, T> {
-    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => void, playlistPath: PlaylistPath, sessionId: string);
+    constructor(client: MediaClient, unregisterNode: (node: MediaNodeState) => void, settings: ProcessorNodeSettings<T> & StreamStatisticsMixin, grpcInit: () => grpc.ClientDuplexStream<ClientMessage, HlsOutputEvent>, subscribeFn: (subscription: Subscription) => Promise<boolean>, playlistPath: PlaylistPath, sessionId: string);
     /**
      * @public
      * Returns the URL to the HLS playlist entry.  Note this can only be evaluated once the stream is active as it