@joergmittaglawo/dmvconfig/node_modules/vapi/Audio.d.ts

DMV Configuration scripts for Lawo V__matrix Distributed Multiviewers.

import * as VScript from "vscript";
import * as _Time from "./Time";
import * as _Primitives from "./Primitives";
export declare const lift: {
    readonly Essence: (kwl: string | null, socket: VScript.VSocket) => Essence | null;
    readonly EssenceSignals: (kwl: string | null, socket: VScript.VSocket) => EssenceSignals | null;
    readonly SignalSourceSlice: (kwl: string | null, socket: VScript.VSocket) => SignalSourceSlice | null;
    readonly GainLevel: (x: any | null, _: VScript.VSocket) => GainLevel | null;
    readonly FadeRequest: (x: any | null, _: VScript.VSocket) => FadeRequest | null;
};
export declare const lower: {
    readonly Essence: (ref: Essence | null) => string | null;
    readonly EssenceSignals: (ref: EssenceSignals | null) => string | null;
    readonly SignalSourceSlice: (ref: SignalSourceSlice | null) => string | null;
    readonly GainLevel: (x: GainLevel | null) => (number | boolean)[] | null;
    readonly FadeRequest: (x: FadeRequest | null) => number[] | null;
};
export declare type SignalStatus = "NO_SIGNAL" | "SILENCE" | "SIGNAL";
export declare type Format = "AM824" | "L24" | "L16";
export declare type Frequency = "F48000" | "F96000";
export declare type Timing = "synchronous_or_syntonous" | "asynchronous";
export declare type Level = "set_6dbfs" | "set_18dbfs" | "set_20dbfs";
/**
  if `start` < `downto` ≤ `upfrom` < `end`, this corresponds to a V-fade
  request fading down from `start` to `downto` and back up from `upfrom` to
  `end`. If `start` = `downto` = `upfrom` < `end`, the essence should be
  initially set up with zero amplitude and fade to full amplitude between
  `upfrom` and `end`; likewise, `start` < `downto` = `upfrom` = `end` should
  be initialized with full amplitude, fade down to zero amplitude between
  `start` and `downto` and remain there indefinitely.
  
  All free-running counter values are measured with respect to micro epoch
  #`micro_epoch_index`.
*/
export interface FadeRequest {
    start: number;
    downto: number;
    upfrom: number;
    end: number;
    micro_epoch_index: number;
}
export interface GainLevel {
    gain: number;
    phase_invert: boolean;
}
export declare class SignalSourceSlice {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get alert_level(): VScript.rKeyword<_Primitives.AlertLevel, _Primitives.AlertLevel, SignalSourceSlice>;
    get frequency(): VScript.rKeyword<Frequency, Frequency, SignalSourceSlice>;
    get peak_meter(): VScript.rKeyword<number[], number[], SignalSourceSlice>;
    get silence_status(): VScript.rKeyword<boolean[], boolean[], SignalSourceSlice>;
    get not_present_status(): VScript.rKeyword<boolean[], boolean[], SignalSourceSlice>;
    get dt_node(): VScript.rKeyword<any, any, SignalSourceSlice>;
}
export declare class SignalSourceSliceAsArrayRow<ParentType extends VScript.StronglyTypedSubtree> extends SignalSourceSlice {
    readonly index: number;
    readonly parent: ParentType;
    constructor(st: VScript.Subtree, index: number, parent: ParentType);
}
declare class EssenceSignals {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get enclosing_slice(): VScript.rKeyword<string | null, SignalSourceSlice | null, EssenceSignals>;
    get index_within_slice(): VScript.rKeyword<number, number, EssenceSignals>;
    get level(): VScript.rKeyword<any, GainLevel | null, this>;
    /**
      if `start` < `downto` ≤ `upfrom` < `end`, this corresponds to a V-fade
      request fading down from `start` to `downto` and back up from `upfrom` to
      `end`. If `start` = `downto` = `upfrom` < `end`, the essence should be
      initially set up with zero amplitude and fade to full amplitude between
      `upfrom` and `end`; likewise, `start` < `downto` = `upfrom` = `end`
      should be initialized with full amplitude, fade down to zero amplitude
      between `start` and `downto` and remain there indefinitely.
      
      All free-running counter values are measured with respect to micro epoch
      #`micro_epoch_index`.
    */
    get fade_request(): VScript.rKeyword<any, FadeRequest | null, this>;
}
export declare class Essence {
    readonly raw: VScript.Subtree;
    constructor(raw: VScript.Subtree);
    get brief(): VScript.rKeyword<string, string, Essence>;
    get sop_dt_node(): VScript.rKeyword<any, any, Essence>;
    get signals(): VScript.StronglyTypedTable<EssenceSignals, VScript.TableRowView<EssenceSignals>>;
    /**
      some signal sources, such as RTP audio/video streams, include a
      well-defined offset to the PTP epoch (as seen by the sender). During
      processing, these 'media clocks' may shift (e.g., as signals pass through
      delay elements) or broaden into finite intervals (e.g., as audio channels
      at different offsets to the PTP epoch are combined into a single audio
      essence). Using the `media_clock` keyword, such changes are tracked
      explicitly and forwarded to audio/video transmitters.
    */
    get media_clock(): _Time.Source;
}
export declare class EssenceAsArrayRow<ParentType extends VScript.StronglyTypedSubtree> extends Essence {
    readonly index: number;
    readonly parent: ParentType;
    constructor(st: VScript.Subtree, index: number, parent: ParentType);
}
export declare class EssenceAsTableRow extends Essence {
    readonly enclosing_table: VScript.StronglyTypedTable<Essence>;
    readonly index: number;
    constructor(raw_row: VScript.TableRow, enclosing_table: VScript.StronglyTypedTable<Essence>);
}
export declare const Enums: {
    readonly Level: Level[];
    readonly Timing: Timing[];
    readonly Frequency: Frequency[];
    readonly Format: Format[];
    readonly SignalStatus: SignalStatus[];
};
export {};