@norskvideo/norsk-api 1.0.343 → 1.0.344

package/lib/media_pb.ts

@@ -621,6 +621,32 @@ proto3.util.setEnumType(SrtMode, "norsk.api.media.SrtMode", [
   { no: 1, name: "Caller" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.TestCardPattern
+ */
+export enum TestCardPattern {
+  /**
+   * @generated from enum value: Black = 0;
+   */
+  Black = 0,
+
+  /**
+   * @generated from enum value: Smpte75 = 1;
+   */
+  Smpte75 = 1,
+
+  /**
+   * @generated from enum value: Smpte100 = 2;
+   */
+  Smpte100 = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(TestCardPattern)
+proto3.util.setEnumType(TestCardPattern, "norsk.api.media.TestCardPattern", [
+  { no: 0, name: "Black" },
+  { no: 1, name: "Smpte75" },
+  { no: 2, name: "Smpte100" },
+]);
+
 /**
  * ///////////////////////////////
  * DeckLink Input
@@ -2647,6 +2673,13 @@ export class StreamMetadata_VideoMetadata extends Message<StreamMetadata_VideoMe
    */
   bitrate = 0;
 
+  /**
+   * The framerate of this video
+   *
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 6;
+   */
+  frameRate?: FrameRate;
+
   constructor(data?: PartialMessage<StreamMetadata_VideoMetadata>) {
     super();
     proto3.util.initPartial(data, this);
@@ -2659,6 +2692,7 @@ export class StreamMetadata_VideoMetadata extends Message<StreamMetadata_VideoMe
     { no: 3, name: "width", kind: "scalar", T: 17 /* ScalarType.SINT32 */ },
     { no: 4, name: "height", kind: "scalar", T: 17 /* ScalarType.SINT32 */ },
     { no: 5, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 6, name: "frame_rate", kind: "message", T: FrameRate },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_VideoMetadata {
@@ -6068,15 +6102,30 @@ export class TestCardVideoConfiguration extends Message<TestCardVideoConfigurati
   resolution?: Resolution;
 
   /**
-   * @generated from field: string source_name = 2;
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 2;
+   */
+  frameRate?: FrameRate;
+
+  /**
+   * @generated from field: string source_name = 3;
    */
   sourceName = "";
 
   /**
-   * @generated from field: int32 number_of_frames = 3;
+   * @generated from field: int32 number_of_frames = 4;
    */
   numberOfFrames = 0;
 
+  /**
+   * @generated from field: bool realtime = 5;
+   */
+  realtime = false;
+
+  /**
+   * @generated from field: norsk.api.media.TestCardPattern pattern = 6;
+   */
+  pattern = TestCardPattern.Black;
+
   constructor(data?: PartialMessage<TestCardVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -6086,8 +6135,11 @@ export class TestCardVideoConfiguration extends Message<TestCardVideoConfigurati
   static readonly typeName = "norsk.api.media.TestCardVideoConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "resolution", kind: "message", T: Resolution },
-    { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "number_of_frames", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "frame_rate", kind: "message", T: FrameRate },
+    { no: 3, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "number_of_frames", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 5, name: "realtime", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 6, name: "pattern", kind: "enum", T: proto3.getEnumType(TestCardPattern) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TestCardVideoConfiguration {
@@ -6176,12 +6228,6 @@ export class VideoTestCardGeneratorEvent extends Message<VideoTestCardGeneratorE
      */
     value: Context;
     case: "outboundContext";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 3;
-     */
-    value: SubscriptionResponse;
-    case: "subscriptionResponse";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<VideoTestCardGeneratorEvent>) {
@@ -6194,7 +6240,6 @@ export class VideoTestCardGeneratorEvent extends Message<VideoTestCardGeneratorE
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
-    { no: 3, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoTestCardGeneratorEvent {
@@ -16985,54 +17030,70 @@ export class StreamSyncEvent extends Message<StreamSyncEvent> {
 }
 
 /**
- * @generated from message norsk.api.media.StreamProgramJoinConfiguration
+ * @generated from message norsk.api.media.StreamAlignConfiguration
  */
-export class StreamProgramJoinConfiguration extends Message<StreamProgramJoinConfiguration> {
+export class StreamAlignConfiguration extends Message<StreamAlignConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
   id?: MediaNodeId;
 
-  constructor(data?: PartialMessage<StreamProgramJoinConfiguration>) {
+  /**
+   * The normalisd sample rate of the audio output
+   *
+   * @generated from field: norsk.api.media.SampleRate sample_rate = 2;
+   */
+  sampleRate = SampleRate.RATE_8000;
+
+  /**
+   * The normalised frame rate of the video output
+   *
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 3;
+   */
+  frameRate?: FrameRate;
+
+  constructor(data?: PartialMessage<StreamAlignConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamProgramJoinConfiguration";
+  static readonly typeName = "norsk.api.media.StreamAlignConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
+    { no: 3, name: "frame_rate", kind: "message", T: FrameRate },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinConfiguration {
-    return new StreamProgramJoinConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignConfiguration {
+    return new StreamAlignConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinConfiguration {
-    return new StreamProgramJoinConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignConfiguration {
+    return new StreamAlignConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinConfiguration {
-    return new StreamProgramJoinConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignConfiguration {
+    return new StreamAlignConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamProgramJoinConfiguration | PlainMessage<StreamProgramJoinConfiguration> | undefined, b: StreamProgramJoinConfiguration | PlainMessage<StreamProgramJoinConfiguration> | undefined): boolean {
-    return proto3.util.equals(StreamProgramJoinConfiguration, a, b);
+  static equals(a: StreamAlignConfiguration | PlainMessage<StreamAlignConfiguration> | undefined, b: StreamAlignConfiguration | PlainMessage<StreamAlignConfiguration> | undefined): boolean {
+    return proto3.util.equals(StreamAlignConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamProgramJoinMessage
+ * @generated from message norsk.api.media.StreamAlignMessage
  */
-export class StreamProgramJoinMessage extends Message<StreamProgramJoinMessage> {
+export class StreamAlignMessage extends Message<StreamAlignMessage> {
   /**
-   * @generated from oneof norsk.api.media.StreamProgramJoinMessage.message
+   * @generated from oneof norsk.api.media.StreamAlignMessage.message
    */
   message: {
     /**
-     * @generated from field: norsk.api.media.StreamProgramJoinConfiguration initial_config = 1;
+     * @generated from field: norsk.api.media.StreamAlignConfiguration initial_config = 1;
      */
-    value: StreamProgramJoinConfiguration;
+    value: StreamAlignConfiguration;
     case: "initialConfig";
   } | {
     /**
@@ -17042,41 +17103,41 @@ export class StreamProgramJoinMessage extends Message<StreamProgramJoinMessage>
     case: "subscription";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<StreamProgramJoinMessage>) {
+  constructor(data?: PartialMessage<StreamAlignMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamProgramJoinMessage";
+  static readonly typeName = "norsk.api.media.StreamAlignMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "initial_config", kind: "message", T: StreamProgramJoinConfiguration, oneof: "message" },
+    { no: 1, name: "initial_config", kind: "message", T: StreamAlignConfiguration, oneof: "message" },
     { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinMessage {
-    return new StreamProgramJoinMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignMessage {
+    return new StreamAlignMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinMessage {
-    return new StreamProgramJoinMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignMessage {
+    return new StreamAlignMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinMessage {
-    return new StreamProgramJoinMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignMessage {
+    return new StreamAlignMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamProgramJoinMessage | PlainMessage<StreamProgramJoinMessage> | undefined, b: StreamProgramJoinMessage | PlainMessage<StreamProgramJoinMessage> | undefined): boolean {
-    return proto3.util.equals(StreamProgramJoinMessage, a, b);
+  static equals(a: StreamAlignMessage | PlainMessage<StreamAlignMessage> | undefined, b: StreamAlignMessage | PlainMessage<StreamAlignMessage> | undefined): boolean {
+    return proto3.util.equals(StreamAlignMessage, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamProgramJoinEvent
+ * @generated from message norsk.api.media.StreamAlignEvent
  */
-export class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
+export class StreamAlignEvent extends Message<StreamAlignEvent> {
   /**
-   * @generated from oneof norsk.api.media.StreamProgramJoinEvent.message
+   * @generated from oneof norsk.api.media.StreamAlignEvent.message
    */
   message: {
     /**
@@ -17104,13 +17165,13 @@ export class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
     case: "inboundContext";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<StreamProgramJoinEvent>) {
+  constructor(data?: PartialMessage<StreamAlignEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamProgramJoinEvent";
+  static readonly typeName = "norsk.api.media.StreamAlignEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
@@ -17118,20 +17179,20 @@ export class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
     { no: 4, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinEvent {
-    return new StreamProgramJoinEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignEvent {
+    return new StreamAlignEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinEvent {
-    return new StreamProgramJoinEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignEvent {
+    return new StreamAlignEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinEvent {
-    return new StreamProgramJoinEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignEvent {
+    return new StreamAlignEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamProgramJoinEvent | PlainMessage<StreamProgramJoinEvent> | undefined, b: StreamProgramJoinEvent | PlainMessage<StreamProgramJoinEvent> | undefined): boolean {
-    return proto3.util.equals(StreamProgramJoinEvent, a, b);
+  static equals(a: StreamAlignEvent | PlainMessage<StreamAlignEvent> | undefined, b: StreamAlignEvent | PlainMessage<StreamAlignEvent> | undefined): boolean {
+    return proto3.util.equals(StreamAlignEvent, a, b);
   }
 }
 
@@ -17491,6 +17552,8 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
   transitionDurationMs = 0;
 
   /**
+   * Resolution of the normalised output
+   *
    * @generated from field: norsk.api.media.Resolution output_resolution = 5;
    */
   outputResolution?: Resolution;
@@ -17502,6 +17565,27 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
    */
   sampleRate = SampleRate.RATE_8000;
 
+  /**
+   * The frame rate of the output
+   *
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 7;
+   */
+  frameRate?: FrameRate;
+
+  /**
+   * The channel layout of the output
+   *
+   * @generated from field: norsk.api.media.ChannelLayout channel_layout = 8;
+   */
+  channelLayout?: ChannelLayout;
+
+  /**
+   * Align all timestamps to minimise timestamp jitter on mixed streams
+   *
+   * @generated from field: norsk.api.media.StreamSwitchSmoothConfiguration.Alignment alignment = 9;
+   */
+  alignment = StreamSwitchSmoothConfiguration_Alignment.ALIGNED;
+
   constructor(data?: PartialMessage<StreamSwitchSmoothConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -17516,6 +17600,9 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
     { no: 4, name: "transition_duration_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 5, name: "output_resolution", kind: "message", T: Resolution },
     { no: 6, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
+    { no: 7, name: "frame_rate", kind: "message", T: FrameRate },
+    { no: 8, name: "channel_layout", kind: "message", T: ChannelLayout },
+    { no: 9, name: "alignment", kind: "enum", T: proto3.getEnumType(StreamSwitchSmoothConfiguration_Alignment) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothConfiguration {
@@ -17535,6 +17622,28 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
   }
 }
 
+/**
+ * Whether to align all the incoming timestamps
+ *
+ * @generated from enum norsk.api.media.StreamSwitchSmoothConfiguration.Alignment
+ */
+export enum StreamSwitchSmoothConfiguration_Alignment {
+  /**
+   * @generated from enum value: ALIGNED = 0;
+   */
+  ALIGNED = 0,
+
+  /**
+   * @generated from enum value: NO_ALIGNMENT = 1;
+   */
+  NO_ALIGNMENT = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(StreamSwitchSmoothConfiguration_Alignment)
+proto3.util.setEnumType(StreamSwitchSmoothConfiguration_Alignment, "norsk.api.media.StreamSwitchSmoothConfiguration.Alignment", [
+  { no: 0, name: "ALIGNED" },
+  { no: 1, name: "NO_ALIGNMENT" },
+]);
+
 /**
  * @generated from message norsk.api.media.StreamSwitchSmoothSwitch
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/norsk-api",
-  "version": "1.0.343",
+  "version": "1.0.344",
   "license": "MIT",
   "dependencies": {
     "@bufbuild/protobuf": "^0.3.0",