Abstract classes

For an introduction, see the Datatypes overview.

AbstractAudioMetering

Base class for audio level metering — provides the peak-level and RMS readouts used by every input and audio operator. Tracks both instantaneous peaks (used by VU meters) and time-averaged RMS values (used for sustained-loudness measurement and side-chain detection). All readouts are read-only from a script — they update per audio frame and are useful for triggering on level events (e.g. silence detection, clip warnings, ducking, automated cuts).

Property	Type	Access	Description
`LeftPeakLevel`	`float`	`get`	Instantaneous peak level of the left channel, in decibels (read-only). Updates per audio frame. Rounded to the configured display precision (see `SetMonitoringPrecision`). `float.MinValue` represents silence. Useful from a script for clip detection, silence-watch alerts, or driving custom level overlays.
`LeftPeakLevelFullPrecision`	`float`	`get`	Same as `LeftPeakLevel` but at full precision — not rounded for display (read-only). Use this when you need the raw value for arithmetic or comparisons; use `LeftPeakLevel` when you need the same value the UI shows.
`LeftPeakLevelRms`	`float`	`get`	RMS (root-mean-square) level of the left channel for the most recent audio frame, in decibels (read-only). RMS values reflect perceived loudness rather than instantaneous peaks — slower to react than `LeftPeakLevel` but more stable. Useful from a script for sustained- level detection (e.g. is the talker actually speaking, or just a transient pop?).
`LeftPeakLevelRmsAverage`	`float`	`get`	Time-averaged RMS level of the left channel, in decibels (read-only). Smoothed over the last several frames (window length controlled by the global `RmsAverageWindowSizeFrames` setting). Use this — not `LeftPeakLevelRms` — for stable side-chain ducking or any logic that should ignore brief peaks.
`RightPeakLevelRmsAverage`	`float`	`get`	Time-averaged RMS level of the right channel, in decibels (read-only). Right-channel counterpart of `LeftPeakLevelRmsAverage` — smoothed over the configured RMS window. Use for stable side-chain or sustained-level logic.
`RightPeakLevel`	`float`	`get`	Instantaneous peak level of the right channel, in decibels (read-only). Right-channel counterpart of `LeftPeakLevel` — same behaviour, same conventions (`float.MinValue` represents silence, rounded to the configured display precision).
`RightPeakLevelFullPrecision`	`float`	`get`	Same as `RightPeakLevel` but at full precision — not rounded for display (read-only). Right-channel counterpart of `LeftPeakLevelFullPrecision`.
`RightPeakLevelRms`	`float`	`get`	RMS level of the right channel for the most recent audio frame, in decibels (read-only). Right-channel counterpart of `LeftPeakLevelRms` — RMS reflects perceived loudness rather than instantaneous peaks.
`StereoPeakLevel`	`float`	`get`	Highest peak seen across both channels in the recent past, in decibels (read-only). "Sticky" running maximum — useful for showing recent peak hold on a meter, or for detecting clipping after the fact (`StereoLevelWarning` flips true when this hits or exceeds 0 dB / 1.0 linear).
`PeakLevel`	`float`	`get`	Highest of the two channels' current instantaneous peak levels, clamped to 1.0 (read-only). Quick "is anything coming through" reading — combines `LeftPeakLevel` and `RightPeakLevel` into a single value useful for compact meter widgets or presence-detection scripts.
`StereoLevelWarning`	`bool`	`get`	True when the audio level has reached or exceeded 0 dB full scale on either channel (read-only). Use this from a script to flag clipping in real time — e.g. log a warning, light an on-screen indicator, or trigger a notification when a source goes hot. Stays true until the meter naturally falls back below clip threshold.

AbstractAudioOperator

Base class for audio operators — every operator in the Audio Processing category (Compressor, Limiter, Gate, EQ, Delay, Low Cut, Gain, EBU R128, Frequency Analyzer, Crystal Speech, etc.) inherits from this. Audio operators take an input audio frame, optionally process it, and return the result. Input/output VU meters are wired automatically — concrete operators only need to implement the per-frame processing in PerformApplyAudioOperator.

(No @ScriptEngine-tagged members.)

AbstractAudioProcessing

Base class shared by every input — covers all audio-processing properties common to NDI, RTMP, SRT, MediaFile, Blackmagic Capture, ASIO, and every other input type. Includes input gain/trim, mute/solo/PFL, pan, stereo balance, low-cut filter, gate, 5-band EQ, broadcast-style compressor, peak limiter, 8-channel routing/remap, audio delay, and pre-fader sends. Concrete inputs inherit these properties — adjusting them on a script-side AbstractInput reference works regardless of the underlying source type.

Property	Type	Access	Description
`InputTrimDb`	`float`	`get/set`	Pre-fader input trim in dB. [min=-24, max=+24, default=0] Use this to compensate for hot or quiet sources before they hit the rest of the chain (gate, EQ, compressor, limiter, fader). Set conservatively — leave the main level adjustments to `StereoGainDb` so dynamics processing sees a sensible signal.
`StereoGainDb`	`float`	`get/set`	Master fader for this input, in dB. [min=-80 (mute), max=+36, default=0] This is the post-processing fader applied after EQ/dynamics — the main level control for the input in the mix. Values at or below -80 dB are treated as -inf (silence). Aim peaks around -6 dB for safe broadcast headroom.
`ApplyInputGainOnAllChannels`	`bool`	`get/set`	When true, the input trim/gain is applied to every channel of a multi-channel input (e.g. all 8 channels of an 8-channel feed) rather than just the stereo Left/Right pair. Enable this for broadcast multi-channel routing where you want a single fader to attenuate the entire bundle of channels uniformly. Leave off when only the stereo monitoring pair should be levelled.
`Pan`	`float`	`get/set`	Stereo balance / pan position. [min=-100 (full left), max=+100 (full right), default=0 (centre)] Negative values weight the signal toward the left channel, positive toward the right; 0 keeps the original stereo image. Useful for placing a mono guest mic in a specific spot in the stereo field, or correcting a leaning source.
`InputAudioDelayMs`	`int`	`get/set`	Per-input audio delay in milliseconds, used for lip-sync compensation. [min=0, max=5000, default=0] Increase when the audio leads the picture (e.g. a remote guest whose voice arrives before their mouth moves on screen). Adjust in small increments (10-40 ms) and watch a clap or hard-consonant cue to dial it in.
`Mute`	`bool`	`get/set`	Silences this input's audio output. Default: false. When set true, peak/RMS meters are also cleared so the input visibly reads as silent. Use mute to drop a source from the program mix without losing your fader position; toggle from a script for cue-driven on/off.
`Solo`	`bool`	`get/set`	Isolates this input by muting every other audio source in the monitoring path. Default: false. Only audible when Audio Preview is active in Composer — does not affect the program/streaming output. Combine with `PFL` to monitor pre-fader so you can hear an input before bringing it up on the master.
`PFL`	`bool`	`get/set`	Pre-Fader Listening — routes the monitoring tap before the master fader so you can hear the input independently of its program level. Default: false. Requires `Solo` to be enabled first; otherwise the setter is ignored. Only audible via Audio Preview in Composer and does not affect the program/streaming output.
`VuMeterConfiguration`	`AudioMixerVuMeterPrePost`	`get/set`	Selects whether the VU-meter reads the signal pre-fader or post-fader. Default: PostFader. Pre-fader shows the level entering the strip (handy for setting input trim and dynamics); post-fader shows what is actually leaving the input on its way to the mix.
`Send1Gain`	`float`	`get/set`	Audio level sent to the Send 1 auxiliary bus. [min=0, max=100, default=0] 0 = no signal on the send; 100 = unity. Use to feed a recorder, IFB mix, or a separate language mix without affecting the program level. Combine with `Send1PrePost` to choose whether the send tap is independent of the master fader (pre) or follows it (post).
`Send1PrePost`	`AudioMixerPrePost`	`get/set`	Selects whether Send 1 is tapped before (PreFader) or after (PostFader) the master fader (`StereoGainDb`). Default: PostFader. PreFader gives a clean copy that is unaffected by the program level — ideal for a recorder or independent IFB mix. PostFader follows the program mix, useful when you want the send to track on-air balance.
`StereoRemap`	`AudioStereoRemap`	`get/set`	Quick stereo channel reassignment for the monitoring/program pair (e.g. straight stereo, swap L/R, fold to mono left, fold to mono right). Use to fix a source that arrives with reversed channels or to mono-fold a single-mic feed presented on one side only. For full 8-channel routing, use the `AudioRemapLeft1`..`AudioRemapRight4` properties instead.
`AudioRemapLeft1`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Left 1 (the first stereo pair, left side). Use to pull any source channel into the L1 slot — e.g. route an incoming centre or surround channel to the main stereo monitoring pair.
`AudioRemapRight1`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Right 1 (the first stereo pair, right side). Pair with `AudioRemapLeft1` to define the main monitoring/program stereo pair from any two source channels.
`AudioRemapLeft2`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Left 2 (second stereo pair, left side). Used for multi-channel routing — e.g. carry an alternate-language commentary on the second stereo pair.
`AudioRemapRight2`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Right 2 (second stereo pair, right side). Pair with `AudioRemapLeft2` to define the second stereo pair from any two source channels.
`AudioRemapLeft3`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Left 3 (third stereo pair, left side). Part of the 8-channel routing matrix — pair with `AudioRemapRight3` for an additional stereo pair.
`AudioRemapRight3`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Right 3 (third stereo pair, right side). Pair with `AudioRemapLeft3` to define the third stereo pair from any two source channels.
`AudioRemapLeft4`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Left 4 (fourth stereo pair, left side). Part of the 8-channel routing matrix — pair with `AudioRemapRight4` for the fourth stereo pair (channels 7/8).
`AudioRemapRight4`	`AudioRemap`	`get/set`	Selects which input channel feeds output channel Right 4 (fourth stereo pair, right side). Pair with `AudioRemapLeft4` to define the fourth stereo pair from any two source channels.
`AudioProcessingTimeMs`	`float`	`get`	(read-only) Time in milliseconds spent on this input's audio processing chain in the last cycle. Useful from a script as a diagnostic to spot inputs whose processing chain is unexpectedly heavy (e.g. a runaway EQ Q or an extreme look-ahead).
`UseGateFilter`	`bool`	`get/set`	Enables or bypasses the gate filter. Default: false (bypassed). Turn on for noisy guest microphones, podium mics, or any source where you need silence between phrases.
`GateThresholdDb`	`float`	`get/set`	Gate threshold in dB — signals below this level are attenuated. [min=-48, max=0, default=-24] Set just above the noise floor: too high cuts off quiet phrases; too low leaves background noise audible. For speech mics, -40 to -30 dB is a typical starting point; for noisy lavs try -30 to -20 dB.
`GateFilterGainReductionDb`	`float`	`get/set`	Maximum attenuation applied when the gate is closed, in dB. [min=-36, max=0, default=-36] -36 dB is effectively silent; smaller (less negative) values leave a quiet bed of the original signal audible — useful when full silence sounds unnatural.
`GateFilterRatio`	`float`	`get/set`	Gate ratio — how aggressively signals below the threshold are pushed down. [min=1, max=20, default=4] 4:1 is a soft expansion (subtle noise reduction); 10:1 or higher acts more like a hard gate. 1:1 disables expansion regardless of `UseGateFilter`.
`GateFilterAttack`	`float`	`get/set`	How quickly the gate opens once the signal crosses the threshold, in milliseconds. [min=1, max=200, default=20] Fast values (1-10 ms) preserve transients in speech and percussion; slower values (50-100 ms) sound more natural on sustained sources but can clip the start of words.
`GateFilterRelease`	`float`	`get/set`	How quickly the gate closes after the signal drops below the threshold, in milliseconds. [min=5, max=5000, default=250] Short releases (50-150 ms) chop tightly around words; longer releases (250-1000 ms) sound smoother and avoid pumping on speech.
`GateFilterKnee`	`float`	`get/set`	Width of the knee around the threshold, in dB. [min=1, max=8, default=2.8] A narrow knee (1-2) gives a sharp, hard gate; a wide knee (4-8) eases signals in and out for a smoother, more natural sound on speech.
`GateFilterMakeupGainDb`	`float`	`get/set`	Output make-up gain after the gate, in dB. [min=0, max=24, default=0] Use to recover perceived loudness if heavy gating left the signal feeling quiet; small amounts (1-6 dB) are usually enough.
`GateFilterCompressorMode`	`CompressorMode`	`get/set`	Direction of expansion: Downward (the standard noise gate, attenuates below the threshold) or Upward (boosts quiet signals). Default: Downward. Stick with Downward for normal noise-gate behaviour on speech; Upward is a niche choice for lifting whispered passages.
`GateFilterCompressorLinkMode`	`CompressorLink`	`get/set`	How the left and right channels are linked when deciding to open or close the gate. Default: Average. Average follows both channels together (preserves stereo image); Maximum opens whenever either channel crosses the threshold; unlinked operates per channel.
`GateFilterCompressorDetectionMode`	`CompressorDetection`	`get/set`	How the level driving the gate is measured: Peak (instantaneous level — fastest reaction) or RMS (average power — smoother, more musical). Default: RMS. Peak is good for percussive material with sharp transients; RMS is the safer choice for speech and sustained sources.
`UseLowCutFilter`	`bool`	`get/set`	Enables or bypasses the low-cut (high-pass) filter. Default: false (bypassed). Turn on for any speech mic to remove sub-100 Hz rumble; usually safe to leave on for broadcast vocals and lavs.
`LowCutFilterOffFrequency`	`int`	`get/set`	Cut-off frequency in Hz — frequencies below this are progressively rolled off. [min=20, max=200, default=80] 80 Hz is the broadcast standard for speech mics; raise to 100-120 Hz for thin male voices with persistent rumble; lower to 30-50 Hz on full-range music to avoid thinning the mix.
`LowCutFilterOrder`	`int`	`get/set`	Filter order — how steep the roll-off is below the cut-off frequency. [min=3, max=20, default=10] Low orders (3-6) sound gentle and musical; high orders (12-20) approach a brickwall cut and are best for surgical rumble removal under speech.
`UseEqFilter`	`bool`	`get/set`	Enables or bypasses the 5-band parametric EQ. Default: false (bypassed). Turn on once you have a problem to solve (boomy mic, harsh sibilance, dull lav) — leave bypassed if the source already sounds correct.
`EqUseSoftClip`	`bool`	`get/set`	Apply gentle soft-clipping at the EQ output to prevent overshoots when bands are boosted heavily. Default: true. Leave on for safety in live broadcast; turn off only when you specifically want raw, un-clipped EQ output (and have a limiter downstream).
`Eq1Frequency`	`int`	`get/set`	Band 1 centre frequency in Hz. [min=20, max=20000, default=200] Band 1 sits in the low-mid region around 100-300 Hz — useful for adding chest/body to vocals or cutting boxiness around 200-400 Hz.
`Eq1Q`	`float`	`get/set`	Band 1 Q (bandwidth). [min=0.1, max=10, default=1] Low Q (0.3-0.7) gives a wide musical bell suitable for tonal shaping; high Q (3-10) is narrow and surgical, good for notching out a single offending frequency.
`Eq1Gain`	`int`	`get/set`	Band 1 boost or cut at the centre frequency, in dB. [min=-36, max=36, default=0] Subtle moves (±3 dB) usually beat dramatic ones — cut narrow problem frequencies and boost wide for character.
`Eq2Frequency`	`int`	`get/set`	Band 2 centre frequency in Hz. [min=20, max=20000, default=500] Band 2 sits in the lower mids around 300-800 Hz — cut here to remove muddiness or boxiness; heavy boosts can sound nasal.
`Eq2Q`	`float`	`get/set`	Band 2 Q (bandwidth). [min=0.1, max=10, default=1] Low Q for broad tone shaping, high Q for surgical notches — the same rules as Band 1.
`Eq2Gain`	`int`	`get/set`	Band 2 boost or cut at the centre frequency, in dB. [min=-36, max=36, default=0] A small cut around 300-500 Hz is a classic move to clean up muddy speech.
`Eq3Frequency`	`int`	`get/set`	Band 3 centre frequency in Hz. [min=20, max=20000, default=1000] Band 3 sits in the mid range around 1-3 kHz — the presence and intelligibility region for voice. A small boost here pushes speech forward in the mix.
`Eq3Q`	`float`	`get/set`	Band 3 Q (bandwidth). [min=0.1, max=10, default=1] Low Q for broad presence shaping, high Q for surgical mid-range work.
`Eq3Gain`	`int`	`get/set`	Band 3 boost or cut at the centre frequency, in dB. [min=-36, max=36, default=0] Boosts of 2-4 dB around 2-3 kHz add clarity; cuts of a few dB tame harsh-sounding presenters.
`Eq4Frequency`	`int`	`get/set`	Band 4 centre frequency in Hz. [min=20, max=20000, default=4000] Band 4 sits in the upper mids around 3-6 kHz — the sibilance and consonant region. A narrow cut here helps with harsh "s" sounds.
`Eq4Q`	`float`	`get/set`	Band 4 Q (bandwidth). [min=0.1, max=10, default=1] High Q (3-8) is useful for de-essing-style narrow cuts; low Q for broad upper-mid shaping.
`Eq4Gain`	`int`	`get/set`	Band 4 boost or cut at the centre frequency, in dB. [min=-36, max=36, default=0] Small cuts (2-4 dB) around 4-6 kHz tame sibilance; small boosts add bite without harshness.
`Eq5Frequency`	`int`	`get/set`	Band 5 centre frequency in Hz. [min=20, max=20000, default=8000] Band 5 sits in the air/brilliance region around 8-12 kHz — gentle wide boosts add openness and "air" to voice and music.
`Eq5Q`	`float`	`get/set`	Band 5 Q (bandwidth). [min=0.1, max=10, default=1] Wide Q (0.3-0.7) is the natural choice for a shimmering high-frequency lift.
`Eq5Gain`	`int`	`get/set`	Band 5 boost or cut at the centre frequency, in dB. [min=-36, max=36, default=0] A 2-3 dB gentle high-shelf-style boost at 8-10 kHz is the typical "air" lift on broadcast voice.
`UseCompressorFilter`	`bool`	`get/set`	Enables or bypasses the compressor. Default: false (bypassed). Disabling also resets the gain-reduction meter (`CompressorGainReductionMeter`) to 0. Turn on to even out a dynamic source (e.g. a presenter who whispers and then shouts) so it sits more consistently in the mix.
`CompressorThreshold`	`float`	`get/set`	Threshold in dB — signals above this level are compressed. [min=-48, max=36, default=-12] For broadcast voice, -18 to -10 dB is typical; lower thresholds catch more of the signal but produce more reduction. Watch the `CompressorGainReductionMeter` while talking — aim for 3-6 dB of reduction on peaks for natural-sounding control.
`CompressorRatio`	`float`	`get/set`	Compression ratio — how much signals above the threshold are reduced. [min=1, max=20, default=4] 2:1-3:1 is light, transparent control; 4:1-6:1 is the broadcast-voice sweet spot; 10:1+ approaches limiting. 1:1 disables compression regardless of `UseCompressorFilter`.
`CompressorDetectorMode`	`AudioCompressorDetectorMode`	`get/set`	How the level driving the compressor is measured: Peak (instantaneous, fast) or RMS (averaged power, smoother). Default: RMS. RMS suits speech and full mixes (sounds musical); Peak catches sharp transients better and is useful for fast control.
`CompressorMakeupGainDb`	`float`	`get/set`	Output make-up gain after compression, in dB. [min=0, max=36, default=3] Use this to restore perceived loudness lost to gain reduction; rule of thumb: add roughly the same number of dB as the average reduction shown on `CompressorGainReductionMeter`.
`CompressorKneeWidthDb`	`float`	`get/set`	Width of the soft knee around the threshold, in dB. [min=1, max=8, default=6] Wider knee (6-8) starts compressing gently below the threshold for an inaudible, transparent feel; narrower knee (1-2) gives a snappier, more obvious sound.
`CompressorAttackTimeMs`	`float`	`get/set`	How quickly the compressor reacts once the signal exceeds the threshold, in milliseconds. [min=1, max=200, default=5] Fast attacks (1-10 ms) catch transients and tame plosives; slower attacks (30-100 ms) let the initial punch through and sound more natural on speech.
`CompressorReleaseTimeMs`	`float`	`get/set`	How quickly the compressor recovers after the signal drops back below threshold, in milliseconds. [min=1, max=500, default=50] Fast releases (20-80 ms) keep average level high but can pump on speech; slower releases (150-300 ms) sound more transparent on voice.
`CompressorRmsTimeMs`	`float`	`get/set`	RMS averaging window length, in milliseconds. [min=1, max=500, default=30] Only relevant when `CompressorDetectorMode` is RMS — short windows (10-30 ms) follow level changes closely; long windows (100-300 ms) smooth more aggressively for very transparent control.
`CompressorLookAheadMs`	`float`	`get/set`	Compressor look-ahead, in milliseconds. [min=1, max=10, default=5] Lets the compressor "see" peaks slightly before they arrive so it can start reducing in time, even with a slow attack. Adds a small fixed latency equal to the look-ahead value — usually inaudible at 1-5 ms.
`CompressorGainReductionMeter`	`float`	`get/set`	(read-only) How hard the compressor is working right now, in dB, smoothed over ~300 ms. 0 means no gain reduction; the more negative, the more the signal is being compressed. Typical broadcast voice peaks 3-6 dB of reduction; consistently more than 10 dB suggests the threshold is too low or the source needs riding manually.
`UseDuckingFilter`	`bool`	`get/set`	Enables or bypasses sidechain ducking. Default: false (bypassed). Disabling also resets the gain-reduction meter (`DuckingGainReductionMeter`) to 0. Turn on and pick a `DuckingSidechainSource` to make this input automatically dip under the trigger input.
`DuckingSidechainSource`	`StringCollectionEnum`	`get/set`	The input whose audio level drives ducking on this input. Lists every audio-capable input in the project except this one. Pick the voice/commentary mic when you want this input's audio to dip under speech. Set to `None` to disable ducking. The selection is remembered with the project.
`DuckingThresholdDb`	`float`	`get/set`	Sidechain level at which ducking starts engaging, in dBFS. [min=-60, max=0, default=-30] When the trigger input rises above this level, this input starts to dip. Lower (more negative) values make ducking trigger more easily, even on quiet speech; higher values only react to clearly loud passages.
`DuckingRatio`	`float`	`get/set`	How aggressively this input is dipped once the threshold is crossed. [min=1, max=20, default=4] 1:1 means no ducking. 4:1 (default) gives a typical music-under-speech feel; 10:1+ produces a very obvious dip. Higher values combined with a low `DuckingMaxGainReductionDb` give "radio-style" hard ducking.
`DuckingAttackMs`	`float`	`get/set`	How quickly this input dips once the trigger crosses threshold, in milliseconds. [min=1, max=500, default=10] Short attacks (1-10 ms) duck instantly — speech jumps to the front cleanly. Longer attacks (50-200 ms) produce a softer "fade-down" feel but let the start of the trigger spill through.
`DuckingReleaseMs`	`float`	`get/set`	How quickly this input comes back up after the trigger goes quiet, in milliseconds. [min=10, max=2000, default=200] Short releases recover quickly between words but can sound "pumpy" on continuous music. Longer releases (500-1500 ms) keep the input down across natural pauses and recover smoothly only when the speaker really stops.
`DuckingMaxGainReductionDb`	`float`	`get/set`	Hardest dip allowed on this input, in decibels. [min=-48, max=0, default=-20] -20 dB is a typical value — the input is clearly under the trigger but still audible. -6 to -12 dB gives a gentle dip; -30 dB or more makes the input almost disappear. 0 dB disables ducking by allowing no reduction at all.
`DuckingGainReductionMeter`	`float`	`get/set`	(read-only) How much this input is being dipped right now by ducking, in dB. 0 means ducking is not currently attenuating the signal; the more negative the value, the harder this input is being dipped under the trigger.
`UseLimiterFilter`	`bool`	`get/set`	Enables or bypasses the look-ahead peak limiter. Default: false (bypassed). Disabling also resets the gain-reduction meter (`LimiterGainReductionMeter`) to 0. Turn on as a safety net before sending the input to the program bus or a streaming target — it guarantees no peak escapes above `LimiterCeilingDb`.
`LimiterCeilingDb`	`float`	`get/set`	Absolute maximum output level in dBFS — the limiter never lets peaks exceed this. [min=-36, max=+6, default=-0.1] -0.1 dBFS is the safe digital broadcast standard; -1.0 dBFS is more conservative for downstream lossy encoders (AAC/MP3) which can introduce inter-sample peaks.
`LimiterReleaseTimeMs`	`float`	`get/set`	How quickly the limiter recovers gain after a peak, in milliseconds. [min=5, max=500, default=100] Short releases (20-60 ms) produce louder output but can introduce distortion and pumping on dense material; longer releases (150-300 ms) sound cleaner but average level is lower.
`LimiterLookAheadMs`	`float`	`get/set`	Limiter look-ahead time, in milliseconds — essential for true brick-wall limiting. [min=1, max=8, default=2] The limiter sees peaks this many milliseconds in advance and starts attenuating before they arrive, so transients never overshoot the ceiling. Adds the same amount of fixed latency to the input's audio path; 2 ms is the broadcast sweet spot.
`LimiterGainReductionMeter`	`float`	`get/set`	(read-only) How much the limiter is attenuating peaks right now, in dB, smoothed over ~300 ms. 0 means the signal is below the ceiling and the limiter is not intervening; the more negative, the more peaks are being clamped. The limiter should rarely intervene — frequent reduction means upstream level/compression is too hot.
`PreFaderSendConfigurations`	`ObservableCollection<PreFaderSendConfiguration>`	`get/set`	Collection of pre-fader send configurations — each entry routes a copy of this input's audio (tapped before the master fader by default) to a separate target audio strip with its own 8-channel mapping. Use pre-fader sends to feed independent mixes (recorder, IFB, alternate-language bus) that stay clean even if the on-air fader is pulled down or muted. Each entry exposes Active, TargetAudioStripId, InputAudioSendType (PreFader/PostFader) and per-target channel routing (TargetCh01..TargetCh08).

AbstractInput

Base class shared by every input — properties documented here are available on all input types (Media File, NDI, RTMP, SRT, Blackmagic Capture, Web Page, Text, etc.). Covers icon labelling, audio-mixer visibility, render gating, tagging for Smart Search, and the source's reported width/height. Concrete inputs add their own properties on top of these.

Property	Type	Access	Description
`IconText`	`string`	`get/set`	Short text shown on the input's icon in the Composer input list. Useful as a quick visual label — for example a channel number, mic name, or camera position — to tell otherwise-similar inputs apart at a glance. Empty by default. Has no effect on rendering or routing.
`HideInAudioMixer`	`bool`	`get/set`	When true, hides the input from the Composer Audio Mixer view without disabling its audio. [default=false]. Useful for declutter: keep the audio routed but remove the strip from the mixer when the input is set up once and never needs hands-on adjustment (e.g. fixed background music, ambient beds, pre-aligned playout). The audio still plays and still feeds downstream processing.
`Invisible`	`bool`	`get/set`	When true, the input is skipped during rendering — it produces no picture on any layer or scene. [default=false]. Use to temporarily take a source off-air without removing it from the project. Audio routing is unaffected. Toggle this from a script for cued-in/cued-out behaviour during a show.
`DoNotRenderController`	`DoNotRenderController`	`get/set`	Decides what controls the `DoNotRenderInput` flag. [default=Let Composer decide]. `Let Composer decide` hands control to the project-level Render Tuning optimiser, which automatically pauses inputs not used by any active scene. `Manual Configuration` ignores Render Tuning and lets the `DoNotRenderInput` toggle control the flag directly — useful for keeping a network source warm when it's currently off-air, or for taking a heavy input down by hand regardless of scene activity.
`DoNotRenderInput`	`bool`	`get/set`	When true, the input's internal render is skipped — no decode or capture work is done. [default=false]. Stronger than `Invisible`: that one renders but doesn't display; this one stops the input from doing any work at all. Useful for reducing CPU/network load on heavy sources (e.g. high-bitrate RTMP/SRT streams, large media files) when the input is temporarily not needed. Audio meters are cleared while disabled.
`Tag`	`string`	`get/set`	One or more tag words used to classify this input. Tags are picked up by Composer's Smart Search to filter or find inputs by category (e.g. "camera", "music", "interview", "sponsor"). Free-form text — typically space- or comma-separated. Has no effect on rendering.
`Width`	`int`	`get`	Width of the source picture in pixels (read-only). Reflects whatever the connected source reports — file resolution, capture device resolution, stream resolution. Useful from a script for layout calculations or for verifying that a source has come up at the expected resolution.
`Height`	`int`	`get`	Height of the source picture in pixels (read-only). Reflects whatever the connected source reports — see `Width`.

AbstractOperator

Base class for Composer operators — components that take an input frame and emit a transformed output frame, typically running their pixel work on the GPU via a CUDA kernel.

Property	Type	Access	Description
`AlwaysRender`	`bool`	`get`	Forces operator to render even if it has a null input

AbstractScene

Base class for scenes — a scene is a top-level composition that contains layers, inputs, operators, and targets. A project holds one or more scenes; each scene renders independently to its own targets. Inherits from AbstractInput so a scene can itself be used as an input on another layer (scene-in-scene / nested compositions). Concrete scene types add scene-specific behaviour on top of these shared properties.

(No @ScriptEngine-tagged members.)

AbstractTarget

Base class shared by every target — properties documented here are available on all target types (NDI, RTMP, RTMPS, RTMP Multi, SRT, MoQ, Decklink output, FFmpeg, File, Snapshot, NvEnc, NvJpeg, PNG, HTTP, Google Storage, ASIO, AAC, UDP, Vindral CDN, etc.). A target receives the rendered scene output and sends it somewhere — to a network protocol, a hardware output, a file on disk, or an HTTP/data endpoint. Concrete targets add their own connection, encoding, and routing properties on top of these shared properties.

Property	Type	Access	Description
`AutoStart`	`bool`	`get/set`	When true, the target connects automatically when the project starts. [default=true]. The recommended setting for most live workflows — output begins as soon as the project loads. Disable for targets that should be triggered manually (e.g. a recording target that only runs during specific segments) or that depend on an external readiness signal before connecting.