true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### ~CameraCoveredDetector()
Finalizes an instance of the true, applies a blur effect to the cached face regions.
- pixelate (bool): if set to true, applies a pixelation effect to the cached face regions.
---
# Class DNNFaceDetector
Link: api/VisioForge.Core.CV.DNNFaceDetector.html
# Class DNNFaceDetector
# Class DNNFaceDetector
**Namespace**: VisioForge.Core.CV
**Assembly**: VisioForge.Core.CV.dll
Implements a Deep Neural Network (DNN) based face detector using OpenCvSharp's DNN module.
```csharp
public class DNNFaceDetector : IDisposable, IFaceDetector, IVideoProcessor
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
This detector uses a pre-trained Caffe model (SSD architecture) to detect faces with high accuracy.
It requires the 'deploy.prototxt' and 'res10_300x300_ssd_iter_140000_fp16.caffemodel' resources.
It supports GPU acceleration if configured and available (VFCUDA).
## Constructors
### DNNFaceDetector(DNNFaceDetectorSettings)
Initializes a new instance of the true to release both managed and unmanaged resources; false to release only unmanaged resources.
### ~FaceDetector()
Finalizes an instance of the This value directly affects performance and detection responsiveness:
This class provides unified access to a wide variety of media devices:
The class supports both synchronous and asynchronous device discovery methods with platform-specific optimizations for Windows, macOS, Linux, iOS, and Android. Real-time device change notifications are provided through events when devices are added or removed from the system.
Use the
This property provides a singleton instance that is automatically created on first access and disposed
when the application exits via the
Using the shared instance is recommended for most scenarios to:
This method discovers Allied Vision cameras using the Vimba X SDK, supporting GigE Vision, USB3 Vision, and Camera Link interfaces. The enumeration is performed on a background thread.
Requires the Allied Vision Vimba X SDK to be installed on the system.
### AudioOutputsAsync(AudioOutputDeviceAPI?) Asynchronously gets an array of available audio output devices (speakers, headphones, etc.). ```csharp public Tasknull, returns devices from all available APIs.
#### Returns
Parameters:
- (Task < AudioOutputDeviceInfo [ ] >): A task that represents the asynchronous operation. The task result contains
an array of null, returns devices from all available APIs. On Linux, defaults to PulseAudio.
#### Returns
Parameters:
- (AudioCaptureDeviceInfo [ ]): An array of
This method automatically performs device enumeration on first call if the internal cache is empty.
Subsequent calls return cached results unless
Supported APIs vary by platform:
null, returns devices from all available APIs.
#### Returns
Parameters:
- (Task < AudioCaptureDeviceInfo [ ] >): A task that represents the asynchronous operation. The task result contains
an array of This method discovers Basler cameras using the Pylon SDK, supporting GigE Vision, USB3 Vision, and Camera Link interfaces. The enumeration provides detailed camera information including device IDs, model names, and connection details.
Requires the Basler Pylon SDK to be installed on the system. The method runs enumeration on a background thread to avoid blocking the calling thread.
### Clear() Clears all cached device lists, forcing a fresh enumeration on the next device query. ```csharp public void Clear() ``` #### RemarksThis method clears all internal device caches including:
Call this method when you need to force a complete re-enumeration of all devices, for example, after system configuration changes or when troubleshooting device detection issues.
### DecklinkAudioSinksAsync() Asynchronously gets an array of available DeckLink audio output sinks. ```csharp public TaskThis method stops all active device monitors, releases GStreamer resources, and unregisters any platform-specific device notification handlers. On Windows, this also stops the WMI event watcher used for USB device change notifications.
After calling this method, the device enumerator cannot be reused. If using the
This method discovers industrial and scientific cameras that comply with the GenICam standard, including GigE Vision and USB3 Vision devices. The enumeration provides detailed camera information including device IDs, model names, and available pixel formats.
The method includes fallback mechanisms to ensure robust camera discovery even when detailed enumeration fails.
### NDISourcesAsync() Asynchronously gets an array of available NDI video/audio sources on the network. ```csharp public TaskThis method discovers NDI sources available on the local network. NDI (Network Device Interface) is a royalty-free protocol for live video streaming over IP networks, commonly used in professional broadcast and video production environments.
The enumeration includes a retry mechanism with delays to ensure all network sources are discovered, as NDI source discovery may take time depending on network conditions.
### ONVIF_ListSourcesAsync(TimeSpan?, CancellationTokenSource?) Asynchronously discovers ONVIF-compliant devices on the local network. ```csharp public Tasknull, defaults to 2 seconds.
Increase this value for larger networks or slow-responding devices.
- cts (CancellationTokenSource ?): Optional cancellation token source to abort the discovery operation.
If null, a new cancellation token source is created internally.
#### Returns
Parameters:
- (Task < Uri [ ] >): A task that represents the asynchronous operation. The task result contains
an array of This method uses WS-Discovery to find ONVIF devices on the network. Each returned URI represents the device service endpoint that can be used to establish a connection for camera control and streaming.
For connecting to discovered devices, use the ONVIFClientX class from VisioForge.Core.ONVIFX
namespace for full device management capabilities including PTZ control, event handling, and profile management.
Once started, the monitor will raise
On Linux, this method performs a one-time enumeration instead of continuous monitoring.
### StartAudioSinkMonitorAsync() Asynchronously starts monitoring for audio output device changes. ```csharp public Task StartAudioSinkMonitorAsync() ``` #### Returns Parameters: - (Task): A task that represents the asynchronous operation. #### Remarks
Once started, the monitor will raise
On Apple platforms (macOS, iOS), this method automatically requests audio access permission.
### StartAudioSourceMonitor() Starts monitoring for audio capture device changes on the current thread. ```csharp public void StartAudioSourceMonitor() ``` #### Remarks
Once started, the monitor will raise
On Linux, this method performs a one-time enumeration instead of continuous monitoring.
### StartAudioSourceMonitorAsync() Asynchronously starts monitoring for audio capture device changes. ```csharp public Task StartAudioSourceMonitorAsync() ``` #### Returns Parameters: - (Task): A task that represents the asynchronous operation. #### Remarks
Once started, the monitor will raise
On Apple platforms (macOS, iOS), this method automatically requests microphone access permission.
### StartVideoSourceMonitor() Starts monitoring for video capture device changes on the current thread. ```csharp public void StartVideoSourceMonitor() ``` #### Remarks
Once started, the monitor will raise
On Linux, this method performs a one-time enumeration instead of continuous monitoring.
### StartVideoSourceMonitorAsync() Asynchronously starts monitoring for video capture device changes. ```csharp public Task StartVideoSourceMonitorAsync() ``` #### Returns Parameters: - (Task): A task that represents the asynchronous operation. #### Remarks
Once started, the monitor will raise
On Apple platforms (macOS), this method automatically requests camera access permission.
### VideoSources() Gets an array of available video capture devices (cameras, webcams, and capture cards). ```csharp public VideoCaptureDeviceInfo[] VideoSources() ``` #### Returns Parameters: - (VideoCaptureDeviceInfo [ ]): An array of
This method automatically performs device enumeration on first call if the internal cache is empty.
Subsequent calls return cached results unless
Supported video sources vary by platform:
true if the specified name is available; otherwise, false.
---
# Class VideoEffectsCS
Link: api/VisioForge.Core.Experimental.VideoEffectsCS.html
# Class VideoEffectsCS
# Class VideoEffectsCS
**Namespace**: VisioForge.Core.Experimental
**Assembly**: VisioForge.Core.dll
Class VideoEffectsCS.
```csharp
public static class VideoEffectsCS
```
#### Inheritance
#### Inherited Members
## Methods
### ColorNoise(nint, int, int, int, Rect)
Applies a color noise effect to the specified pixels.
```csharp
public static void ColorNoise(nint pixels, int width, int height, int amount, Rect rect)
```
#### Parameters
Parameters:
- pixels (nint): The pixels.
- width (int): The width.
- height (int): The height.
- amount (int): The amount of noise.
- rect (Rect): The rectangle area to apply the effect.
### Mosaic(nint, int, int, int, Rect)
Processes the specified pixels.
```csharp
public static void Mosaic(nint pixels, int width, int height, int size, Rect rect)
```
#### Parameters
Parameters:
- pixels (nint): The pixels.
- width (int): The width.
- height (int): The height.
- size (int): The size.
- rect (Rect): The rectangle.
---
# Namespace VisioForge.Core.Experimental
Link: api/VisioForge.Core.Experimental.html
# Namespace VisioForge.Core.Experimental
# Namespace VisioForge.Core.Experimental
### Classes
Parameters:
- (): Experimental KLV remuxer.
- (): Class PluginCheck.
- (): Class VideoEffectsCS.
- (): Experimental iOS test class.
---
# Class FaceInfo
Link: api/VisioForge.Core.FaceAI.FaceInfo.html
# Class FaceInfo
# Class FaceInfo
**Namespace**: VisioForge.Core.FaceAI
**Assembly**: VisioForge.Core.FaceAI.dll
Contains information about a detected face including its location, encoding, and dimensions.
```csharp
[Serializable]
public class FaceInfo
```
#### Inheritance
#### Inherited Members
## Remarks
The true if the person was added successfully; otherwise, false.
### AddKnownPersonAsync(string)
Asynchronously adds a known person from an image file.
```csharp
public Tasktrue if successful; otherwise, false.
### AddKnownPersons(string[])
Adds multiple known persons from image files.
```csharp
public void AddKnownPersons(string[] imageFiles)
```
#### Parameters
Parameters:
- imageFiles (string [ ]): The array of image file paths.
### AddKnownPersonsAsync(string[])
Asynchronously adds multiple known persons from image files.
```csharp
public Task AddKnownPersonsAsync(string[] imageFiles)
```
#### Parameters
Parameters:
- imageFiles (string [ ]): The array of image file paths.
#### Returns
Parameters:
- (Task): A task that represents the asynchronous operation.
### Clear()
Clears the list of known persons.
```csharp
public void Clear()
```
### Detect(Person)
Detects if the specified person matches any known person.
```csharp
public Person Detect(Person person)
```
#### Parameters
Parameters:
- person (Person): The person to detect.
#### Returns
Parameters:
- (Person): The matched null.
### Detect(VideoFrameX)
Detects persons in the specified video frame.
```csharp
public Person[] Detect(VideoFrameX frame)
```
#### Parameters
Parameters:
- frame (VideoFrameX): The video frame.
#### Returns
Parameters:
- (Person [ ]): An array of detected null.
### DetectAsync(VideoFrameX)
Asynchronously detects persons in the specified video frame.
```csharp
public Tasknull if the file doesn't exist or no faces are found.
#### Remarks
The person's name is derived from the image filename (without extension).
If one face is detected, uses the filename as the person's name.
If multiple faces are detected, appends indices like "filename_0", "filename_1", etc.
This method is ideal for batch enrollment from photo directories.
#### Exceptions Parameters: - (Exception): Thrown when the application is not running as an x64 process. ### LoadFromImageFileAsync(FaceRecognitionCore, string) Asynchronously loads person data from an image file. ```csharp public static Tasknull if no faces are found.
#### Remarks
If one face is detected, it creates a person with the given name.
If multiple faces are detected, creates multiple persons with names like "name_0", "name_1", etc.
This method is useful for enrolling persons from live video streams or recorded video files.
#### Exceptions Parameters: - (Exception): Thrown when the application is not running as an x64 process. ### ToString() Returns aThe ColorspaceConverterX class leverages GStreamer's videoconvert element to perform efficient colorspace transformations between different video formats. It supports: - Multiple input and output video formats (RGB, BGR, YUV, etc.) - Hardware-accelerated conversions when available - Thread-safe operation with internal synchronization - Configurable timeout for conversion operations
The converter uses an internal GStreamer pipeline with appsrc and appsink elements to process frames in real-time. Each conversion operation is synchronized using an AutoResetEvent to ensure proper buffer handling.
This class implements
This constructor creates and configures a GStreamer pipeline with the following elements: - appsrc: Receives input frames - capsfilter (input): Enforces input format constraints - videoconvert: Performs the actual colorspace conversion - capsfilter (output): Enforces output format constraints - appsink: Provides converted output frames
The pipeline is automatically started during construction. If initialization fails, all allocated resources are cleaned up and an exception is thrown.
#### Exceptions Parameters: - (InvalidOperationException): Thrown if GStreamer elements cannot be created or linked. ## Methods ### Convert(VideoFrameX, VideoFrameX, int) Converts a video frame from the input colorspace to the output colorspace. ```csharp public void Convert(VideoFrameX inFrame, VideoFrameX outFrame, int timeoutMs = 1000) ``` #### Parameters Parameters: - inFrame (VideoFrameX): The input video frame containing the source data. - outFrame (VideoFrameX): The output video frame that will receive the converted data. - timeoutMs (int): The maximum time to wait for conversion completion, in milliseconds. Default is 1000ms. #### Remarks This is a convenience overload that extracts the data pointers and sizes from theThis method performs a synchronous colorspace conversion operation: 1. Creates a GStreamer buffer from the input data 2. Pushes the buffer through the conversion pipeline 3. Waits for the converted output (with timeout) 4. Copies the result to the output buffer
The operation is thread-safe and uses internal locking to ensure only one conversion happens at a time. If the pipeline is not started, it will be started automatically.
If the conversion times out, no data is written to the output buffer and an error is logged.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the converter has been disposed. ### Dispose() Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. ```csharp public void Dispose() ``` #### RemarksThis method stops the GStreamer pipeline, disconnects event handlers, and releases all native resources including GStreamer elements and allocated memory buffers.
After calling Dispose, the converter instance cannot be reused. Consider using a 'using' statement to ensure proper disposal.
### Dispose(bool) Releases the unmanaged and optionally the managed resources used by thetrue, releases both managed and unmanaged resources; if false, releases only unmanaged resources.
#### Remarks
When called from Dispose (disposing = true), this method: - Disposes the buffer processed event - Frees allocated native memory for output buffers
Regardless of the disposing parameter, it always: - Stops the GStreamer pipeline - Disconnects event handlers to prevent callbacks after disposal - Disposes all GStreamer objects (bin, caps)
### ~ColorspaceConverterX() Finalizes an instance of theThis method stops the GStreamer pipeline, restarts it, and releases all cached output buffers. Use this method if you need to recover from errors or clear the pipeline state.
After reset, the converter is ready to process new frames.
--- # Namespace VisioForge.Core.FastImageProcessingX Link: api/VisioForge.Core.FastImageProcessingX.html # Namespace VisioForge.Core.FastImageProcessingX # Namespace VisioForge.Core.FastImageProcessingX ### Classes Parameters: - (): Provides high-performance colorspace conversion for video frames using GStreamer. --- # Enum VmbAccessModeType Link: api/VisioForge.Core.GenICam.AlliedVision.VmbAccessModeType.html # Enum VmbAccessModeType # Enum VmbAccessModeType **Namespace**: VisioForge.Core.GenICam.AlliedVision **Assembly**: VisioForge.Core.dll Access mode for cameras. ```csharp public enum VmbAccessModeType ``` ## Fields Parameters: - None (): No access. - Full (): Read and write access. - Read (): Read-only access. - Unknown (): Access type unknown. - Exclusive (): Read and write access without permitting access for other consumers. ## Remarks Used in VmbCameraInfo as flags, so multiple modes can be announced. While in VmbCameraOpen(), no combination must be used. --- # Struct VmbCameraInfo Link: api/VisioForge.Core.GenICam.AlliedVision.VmbCameraInfo.html # Struct VmbCameraInfo # Struct VmbCameraInfo **Namespace**: VisioForge.Core.GenICam.AlliedVision **Assembly**: VisioForge.Core.dll Holds read-only information about a camera. ```csharp public struct VmbCameraInfo ``` #### Inherited Members ## Fields ### CameraIdExtended Globally unique identifier for the camera. ```csharp public string CameraIdExtended ``` #### Field Value Parameters: - (string): ### CameraIdString Identifier of the camera. ```csharp public string CameraIdString ``` #### Field Value Parameters: - (string): ### CameraName The display name of the camera. ```csharp public string CameraName ``` #### Field Value Parameters: - (string): ### InterfaceHandle Handle of the related interface for feature access. ```csharp public nint InterfaceHandle ``` #### Field Value Parameters: - (nint): ### LocalDeviceHandle Handle of the related GenTL local device. Null if the camera is not opened. ```csharp public nint LocalDeviceHandle ``` #### Field Value Parameters: - (nint): ### ModelName Model name. ```csharp public string ModelName ``` #### Field Value Parameters: - (string): ### PermittedAccess Permitted access modes, seeTypical Usage Workflow:
Thread Safety: This class is not thread-safe. Access should be synchronized when used from multiple threads, particularly for streaming operations.
Resource Management: The class implements
using var camera = GenICamCameraManager.CreateCamera("MyCamera");
if (camera.Connect())
{
camera.ReadInfo();
camera.SetExposureTime(10000); // 10ms
camera.SetGain(0.0);
camera.FrameReceived += (s, e) => {
Console.WriteLine($"Frame: {e.FrameData.Width}x{e.FrameData.Height}");
};
camera.StartStreaming();
Thread.Sleep(5000); // Stream for 5 seconds
camera.StopStreaming();
}Binning combines adjacent pixels to:
Defines the constraints for ROI height:
Defines the constraints for ROI width:
Defines the constraints for ROI X position:
Defines the constraints for ROI Y position:
Chunk data allows additional metadata to be embedded with each frame, such as:
// Capture a single frame with default timeout
var frameData = camera.CaptureFrame();
if (frameData != null)
{
Console.WriteLine($"Captured frame: {frameData.Width}x{frameData.Height}");
Console.WriteLine($"Pixel format: {frameData.PixelFormat}");
Console.WriteLine($"Data size: {frameData.Size} bytes");
// Process the frame data
ProcessImageData(frameData.Data);
}
else
{
Console.WriteLine("Frame capture failed or timed out");
}
// Capture with longer timeout for slow camera
var slowFrameData = camera.CaptureFrame(15000); // 15 second timeoutThis method performs a synchronous single frame capture:
Timeout Considerations: The timeout should be longer than the exposure time plus any camera processing delays. For very long exposures (>1 second), increase the timeout accordingly.
Performance: This method is suitable for infrequent captures. For continuous imaging,
use
Thread Safety: This method blocks the calling thread until the frame is captured or timeout occurs.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. ### Connect() Establishes connection to the camera hardware and initializes the camera for operation. ```csharp public bool Connect() ``` #### Returns Parameters: - (bool): True if connection was successful, false otherwise. #### Examplesvar camera = new GenICamCamera("192.168.1.100");
if (camera.Connect())
{
camera.ReadInfo();
Console.WriteLine($"Connected to: {camera.ModelName}");
}
else
{
Console.WriteLine("Failed to connect to camera");
}This method performs the following operations:
Note: After successful connection, call
// Execute software trigger command
if (camera.IsFeatureAvailable("TriggerSoftware"))
{
bool success = camera.ExecuteCommand("TriggerSoftware");
Console.WriteLine($"Software trigger: {(success ? "Success" : "Failed")}");
}
// Load user set
if (camera.IsFeatureAvailable("UserSetLoad"))
{
camera.SetStringFeature("UserSetSelector", "UserSet1");
camera.ExecuteCommand("UserSetLoad");
}This method can be used to execute GenICam command features such as:
Use
This method provides direct access to the camera's payload size, which represents the size in bytes of image data that will be transmitted per frame.
This is more reliable than calculating payload size from image dimensions as it accounts for any camera-specific padding or formatting.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if the camera communication fails. ### GetPixelFormat() Gets the current pixel format ```csharp public int GetPixelFormat() ``` #### Returns Parameters: - (int): Current pixel format as integer ### GetPixelFormatString() Gets the current pixel format as a string ```csharp public string GetPixelFormatString() ``` #### Returns Parameters: - (string): Current pixel format name ### GetRegion() Gets the current region of interest (ROI) ```csharp public (int X, int Y, int Width, int Height) GetRegion() ``` #### Returns Parameters: - (( int X , int Y , int Width , int Height )): ROI as x, y, width, height ### GetSensorSize() Gets the sensor size (maximum resolution) ```csharp public (int Width, int Height) GetSensorSize() ``` #### Returns Parameters: - (( int Width , int Height )): Sensor size as width and height ### GetSerialNumber() Gets the serial number from camera ```csharp public string GetSerialNumber() ``` #### Returns Parameters: - (string): ### GetStreamDiagnostics() Gets comprehensive diagnostic information about the current streaming state and performance. ```csharp public AravisStreamDiagnostics GetStreamDiagnostics() ``` #### Returns Parameters: - (AravisStreamDiagnostics): Diagnostic information including buffer counts, statistics, and error states. #### Examples// Monitor streaming performance
var diagnostics = camera.GetStreamDiagnostics();
Console.WriteLine($"Streaming Active: {diagnostics.IsStreaming}");
Console.WriteLine($"Completed Frames: {diagnostics.CompletedBuffers}");
Console.WriteLine($"Failed Frames: {diagnostics.FailedBuffers}");
Console.WriteLine($"Underruns: {diagnostics.UnderrunBuffers}");
Console.WriteLine($"Buffer Counts - Input: {diagnostics.InputBuffers}, Output: {diagnostics.OutputBuffers}");
// Check for problems
if (diagnostics.FailedBuffers > diagnostics.CompletedBuffers * 0.1)
{
Console.WriteLine("Warning: High frame failure rate detected");
}
if (!string.IsNullOrEmpty(diagnostics.ErrorMessage))
{
Console.WriteLine($"Stream Error: {diagnostics.ErrorMessage}");
}This method provides detailed information about the streaming subsystem:
Troubleshooting Guide:
Performance Note: This method queries the stream in real-time, so it reflects current state.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. ### GetStringFeature(string) Gets a string feature value ```csharp public string GetStringFeature(string featureName) ``` #### Parameters Parameters: - featureName (string): Feature name #### Returns Parameters: - (string): Feature value ### GetVendorName() Gets the vendor name from camera ```csharp public string GetVendorName() ``` #### Returns Parameters: - (string): ### GetWidthBounds() Gets the width bounds (min and max values) ```csharp public (int Min, int Max) GetWidthBounds() ``` #### Returns Parameters: - (( int Min , int Max )): Width bounds as min and max ### GetWidthIncrement() Gets the width increment ```csharp public int GetWidthIncrement() ``` #### Returns Parameters: - (int): Width increment value ### GetXBinningBounds() Gets the horizontal binning bounds ```csharp public (int Min, int Max) GetXBinningBounds() ``` #### Returns Parameters: - (( int Min , int Max )): Horizontal binning bounds as min and max ### GetXBinningIncrement() Gets the X binning increment ```csharp public int GetXBinningIncrement() ``` #### Returns Parameters: - (int): X binning increment value ### GetXOffsetBounds() Gets the X offset bounds ```csharp public (int Min, int Max) GetXOffsetBounds() ``` #### Returns Parameters: - (( int Min , int Max )): X offset bounds as min and max ### GetXOffsetIncrement() Gets the X offset increment ```csharp public int GetXOffsetIncrement() ``` #### Returns Parameters: - (int): X offset increment value ### GetYBinningBounds() Gets the vertical binning bounds ```csharp public (int Min, int Max) GetYBinningBounds() ``` #### Returns Parameters: - (( int Min , int Max )): Vertical binning bounds as min and max ### GetYBinningIncrement() Gets the Y binning increment ```csharp public int GetYBinningIncrement() ``` #### Returns Parameters: - (int): Y binning increment value ### GetYOffsetBounds() Gets the Y offset bounds ```csharp public (int Min, int Max) GetYOffsetBounds() ``` #### Returns Parameters: - (( int Min , int Max )): Y offset bounds as min and max ### GetYOffsetIncrement() Gets the Y offset increment ```csharp public int GetYOffsetIncrement() ``` #### Returns Parameters: - (int): Y offset increment value ### IsBinningAvailable() Checks if binning is available ```csharp public bool IsBinningAvailable() ``` #### Returns Parameters: - (bool): True if binning is supported ### IsComponentAvailable() Checks if component control is available ```csharp public bool IsComponentAvailable() ``` #### Returns Parameters: - (bool): True if component control is available #### RemarksComponent control allows selection and configuration of different sensor components or processing pipelines, commonly used in multi-tap or color cameras.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if the camera communication fails. ### IsExposureTimeAvailable() Checks if exposure time control is available ```csharp public bool IsExposureTimeAvailable() ``` #### Returns Parameters: - (bool): True if exposure time control is available #### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if the camera communication fails. ### IsFeatureAvailable(string) Checks if a feature is available ```csharp public bool IsFeatureAvailable(string featureName) ``` #### Parameters Parameters: - featureName (string): Feature name #### Returns Parameters: - (bool): True if feature is available ### IsRegionOffsetAvailableCheck() Checks if region offset is available ```csharp public bool IsRegionOffsetAvailableCheck() ``` #### Returns Parameters: - (bool): True if region offset is available ### IsSoftwareTriggerSupported() Checks if software trigger is supported by the camera ```csharp public bool IsSoftwareTriggerSupported() ``` #### Returns Parameters: - (bool): True if software trigger is supported #### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if the camera communication fails. ### ReadAvailableFeatures() Reads and populates all available GenICam features organized by data type. This method enumerates common GenICam features and categorizes them by type. ```csharp public void ReadAvailableFeatures() ``` #### Examples// Connect and read basic info
camera.Connect();
camera.ReadInfo();
// Optionally read detailed feature information
camera.ReadAvailableFeatures();
// Check capabilities
Console.WriteLine($"Advanced camera: {camera.HasAdvancedFeatures}");
Console.WriteLine($"Available features: {camera.AvailableStringFeatures.Length + camera.AvailableIntegerFeatures.Length + camera.AvailableFloatFeatures.Length + camera.AvailableBooleanFeatures.Length}");
// Check for specific feature types
bool hasCounters = camera.AvailableIntegerFeatures.Contains("CounterValue");
bool hasUserSets = camera.AvailableStringFeatures.Contains("UserSetSelector");This method populates the following properties:
Performance Note: This method can take several seconds to complete as it tests many potential features. It's recommended to call this only when feature discovery is needed.
Feature Categories Tested:
if (camera.Connect())
{
camera.ReadInfo();
Console.WriteLine($"Camera: {camera.VendorName} {camera.ModelName}");
Console.WriteLine($"Sensor Size: {camera.SensorSize.Width}x{camera.SensorSize.Height}");
Console.WriteLine($"Pixel Formats: {string.Join(", ", camera.AvailablePixelFormats)}");
Console.WriteLine($"Frame Rate Range: {camera.FrameRateBounds.Min}-{camera.FrameRateBounds.Max} FPS");
}This method queries the camera for comprehensive information including:
Performance Note: This method involves multiple queries to the camera and may take several hundred milliseconds to complete, especially over network connections.
Usage: Call this method after
// Handle camera disconnection and recovery
try
{
camera.StartStreaming();
}
catch (AravisException ex)
{
Console.WriteLine($"Camera error: {ex.Message}");
// Attempt to reinitialize
if (camera.ReinitializeCamera())
{
Console.WriteLine("Camera reinitialized successfully");
camera.ReadInfo(); // Refresh capabilities
camera.StartStreaming(); // Resume streaming
}
else
{
Console.WriteLine("Failed to reinitialize camera");
}
}This method performs a complete reinitialization:
Usage Scenarios:
Important: After successful reinitialization, you should call
Alternative: For temporary disconnections without disposal, consider using
Black level represents the minimum signal level that corresponds to black in the image. Adjusting black level can help improve image contrast and correct for sensor dark current.
Use
Auto black level modes:
Availability: Check
// Enable continuous auto exposure
if (camera.IsExposureAutoAvailable)
{
camera.SetExposureAuto(GenICamAuto.Continuous);
}
// Disable auto exposure and set manual value
camera.SetExposureAuto(GenICamAuto.Off);
camera.SetExposureTime(10000); // 10msAuto exposure modes:
Availability: Check
// Set exposure to 10 milliseconds
camera.SetExposureTime(10000);
// Set exposure within valid bounds
camera.ReadInfo();
double minExposure = camera.ExposureTimeBounds.Min;
double maxExposure = camera.ExposureTimeBounds.Max;
double targetExposure = Math.Min(maxExposure, Math.Max(minExposure, 5000));
camera.SetExposureTime(targetExposure);The exposure time controls how long the sensor is exposed to light for each frame. Longer exposure times result in brighter images but may cause motion blur.
Valid Range: Use
Units: Microseconds (µs). Common values:
Frame Rate Impact: Longer exposure times may limit the maximum achievable frame rate.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if the exposure time is invalid or the camera rejects the setting. ### SetFloatFeature(string, double) Sets a float feature value ```csharp public void SetFloatFeature(string featureName, double value) ``` #### Parameters Parameters: - featureName (string): Feature name - value (double): Feature value ### SetFrameCount(long) Sets the number of frames to capture in multi-frame acquisition mode ```csharp public void SetFrameCount(long frameCount) ``` #### Parameters Parameters: - frameCount (long): Number of frames to capture #### RemarksThis setting is typically used with
Use
// Enable continuous auto gain
if (camera.IsGainAutoAvailable)
{
camera.SetGainAuto(GenICamAuto.Continuous);
}
// Disable auto gain and set manual value
camera.SetGainAuto(GenICamAuto.Off);
camera.SetGain(0.0); // Minimum gainAuto gain modes:
Availability: Check
// Set ROI to center 640x480 region
camera.ReadInfo();
int centerX = (camera.SensorSize.Width - 640) / 2;
int centerY = (camera.SensorSize.Height - 480) / 2;
camera.SetRegion(centerX, centerY, 640, 480);
// Verify the actual ROI set
var actualROI = camera.GetRegion();
Console.WriteLine($"Actual ROI: {actualROI.X}, {actualROI.Y}, {actualROI.Width}x{actualROI.Height}");The ROI must satisfy the following constraints:
Performance Impact: Smaller ROIs typically allow higher frame rates due to reduced data transfer.
Note: Some cameras may adjust the ROI to the nearest valid values based on their constraints.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if the ROI parameters are invalid or the camera rejects the settings. ### SetStringFeature(string, string) Sets a string feature value ```csharp public void SetStringFeature(string featureName, string value) ``` #### Parameters Parameters: - featureName (string): Feature name - value (string): Feature value ### SoftwareTrigger() Sends a software trigger command to the camera ```csharp public void SoftwareTrigger() ``` #### Examples// Configure for software trigger
if (camera.IsSoftwareTriggerSupported())
{
camera.SetStringFeature("TriggerMode", "On");
camera.SetStringFeature("TriggerSource", "Software");
// Start acquisition
camera.StartAcquisition();
// Trigger a frame
camera.SoftwareTrigger();
}This method sends a software trigger signal to the camera, which can be used to:
Prerequisites: The camera must be configured for software triggering and
// Set up frame handling
camera.FrameReceived += (sender, e) => {
var frame = e.FrameData;
Console.WriteLine($"Received frame: {frame.Width}x{frame.Height}");
// Process frame data...
};
camera.FrameError += (sender, e) => {
Console.WriteLine($"Frame error: {e.ErrorMessage}");
};
// Start streaming
if (camera.StartStreaming())
{
Console.WriteLine("Streaming started successfully");
// Let it stream for a while...
Thread.Sleep(5000);
camera.StopStreaming();
}This method performs the following operations:
Event Handling: Subscribe to
Buffer Management: Buffers are created and managed automatically. The default buffer count is 10, which should be sufficient for most applications.
Thread Safety: This method is not thread-safe with respect to other camera operations.
#### Exceptions Parameters: - (ObjectDisposedException): Thrown if the camera instance has been disposed. - (AravisException): Thrown if streaming cannot be started due to camera or configuration issues. ### StopAcquisition() Stops acquisition ```csharp public void StopAcquisition() ``` ### StopStreaming() Stops streaming frames ```csharp public bool StopStreaming() ``` #### Returns Parameters: - (bool): True if streaming stopped successfully ### ToString() Returns a string representation of the camera ```csharp public override string ToString() ``` #### Returns Parameters: - (string): String representation ### FrameError Event fired when a frame acquisition error occurs during streaming. ```csharp public event EventHandlerCommon causes include:
The streaming will typically continue after an error, but consider reducing frame rate or increasing buffer count.
### FrameReceived Event fired when a new frame is received during streaming operations. ```csharp public event EventHandlercamera.FrameReceived += (sender, e) => {
var frame = e.FrameData;
Console.WriteLine($"Frame: {frame.Width}x{frame.Height}, Format: {frame.PixelFormat}");
// Process frame data...
};This event is raised from a background timer thread, so UI updates should be marshaled to the appropriate thread.
Frame processing should be kept minimal to avoid blocking the acquisition pipeline.
The frame data is copied, so it's safe to access after the event handler returns.
### StreamingStarted Event fired when streaming starts successfully. ```csharp public event EventHandler StreamingStarted ``` #### Event Type Parameters: - (EventHandler): #### Remarks This event indicates that the camera acquisition has started and buffers are available for frame capture. ### StreamingStopped Event fired when streaming stops. ```csharp public event EventHandler StreamingStopped ``` #### Event Type Parameters: - (EventHandler): #### Remarks This event is fired both for normal stop operations and when streaming stops due to errors. --- # Class GenICamCameraManager Link: api/VisioForge.Core.GenICam.GenICamCameraManager.html # Class GenICamCameraManager # Class GenICamCameraManager **Namespace**: VisioForge.Core.GenICam **Assembly**: VisioForge.Core.dll Static class for centralized camera management and enumeration of GenICam-compatible cameras. This class provides centralized management and enumeration of GenICamCamera instances to ensure: - Each camera is created only once and reused across the application - Simple open/closed state tracking with thread-safe operations - Thread-safe access to camera instances using concurrent collections - Automatic cleanup when cameras are no longer needed or available - Comprehensive device enumeration and discovery with real-time updates - Proper resource management and disposal patternsThread Safety: This class is fully thread-safe and can be used from multiple threads simultaneously.
Usage Pattern:
Resource Management:
Cameras are automatically cleaned up when they become unavailable. The manager tracks device availability
and removes cameras that are no longer present in the system during
// Enumerate and populate camera dictionary
GenICamCameraManager.UpdateDeviceList();
// Get camera reference
var camera = GenICamCameraManager.GetCamera("MyCamera");
if (camera == null)
{
Console.WriteLine("Camera not found");
return;
}
// Open camera for use
if (GenICamCameraManager.OpenCamera("MyCamera"))
{
try
{
// Use camera for operations
camera.StartStreaming();
// Perform image capture operations
// ... do work ...
camera.StopStreaming();
}
finally
{
// Always close camera when done
GenICamCameraManager.CloseCamera("MyCamera");
}
}
else
{
Console.WriteLine("Failed to open camera");
}true if the camera was successfully closed or was already closed;
false if an error occurred during the closing process.
#### Examples
string deviceId = "MyCamera_12345";
// Open camera
if (GenICamCameraManager.OpenCamera(deviceId))
{
try
{
// Use camera...
var camera = GenICamCameraManager.GetCamera(deviceId);
camera.StartStreaming();
// ... perform operations ...
}
finally
{
// Always close when done
bool closed = GenICamCameraManager.CloseCamera(deviceId);
if (!closed)
{
Console.WriteLine("Warning: Camera may not have closed properly");
}
}
}This method performs the following operations:
Thread Safety: This method is thread-safe and uses internal locking.
Resource Management: This method properly releases hardware resources while maintaining the camera instance for future use.
Idempotent: It's safe to call this method multiple times on the same camera.
### FindCameraBySerialNumber(string) Finds a camera by its exact serial number using case-insensitive matching. ```csharp public static GenICamCamera FindCameraBySerialNumber(string serialNumber) ``` #### Parameters Parameters: - serialNumber (string): The serial number to search for. #### Returns Parameters: - (GenICamCamera): Anull if no camera with that serial number is found.
#### Examples
// Find camera by serial number
var camera = GenICamCameraManager.FindCameraBySerialNumber("12345678");
if (camera != null)
{
Console.WriteLine($"Found camera: {camera.DeviceId}");
// Open and use the camera
if (GenICamCameraManager.OpenCamera(camera.DeviceId))
{
// Use camera...
GenICamCameraManager.CloseCamera(camera.DeviceId);
}
}
else
{
Console.WriteLine("Camera with serial number 12345678 not found");
}This method performs a case-insensitive exact match search for cameras with the specified serial number.
Performance: This method may take some time as it needs to query device information for each available camera until a match is found.
Cameras that cannot be queried are skipped with a warning logged.
Uniqueness: Serial numbers should be unique, so this method returns the first match found.
### FindCamerasByModel(string) Finds cameras by model name using case-insensitive partial matching. ```csharp public static List// Find all cameras with model names containing "ace"
var aceCameras = GenICamCameraManager.FindCamerasByModel("ace");
Console.WriteLine($"Found {aceCameras.Count} cameras with 'ace' in model name");
foreach (var camera in aceCameras)
{
Console.WriteLine($" - {camera.DeviceId}");
}This method performs a case-insensitive search for cameras whose model name contains the specified string. Partial matches are supported.
Performance: This method may take some time as it needs to query device information for each available camera.
Cameras that cannot be queried are skipped with a warning logged.
### FindCamerasByVendor(string) Finds cameras by vendor name using case-insensitive partial matching. ```csharp public static List// Find all cameras from vendors containing "Basler"
var baslerCameras = GenICamCameraManager.FindCamerasByVendor("Basler");
Console.WriteLine($"Found {baslerCameras.Count} Basler cameras");
foreach (var camera in baslerCameras)
{
Console.WriteLine($" - {camera.DeviceId}");
}This method performs a case-insensitive search for cameras whose vendor name contains the specified string. Partial matches are supported.
Performance: This method may take some time as it needs to query device information for each available camera.
Cameras that cannot be queried are skipped with a warning logged.
### ForceCleanup() Forces removal and disposal of all cameras from the cache, regardless of their current state. ```csharp public static void ForceCleanup() ``` #### Examples// Application shutdown sequence
try
{
// Attempt graceful shutdown first
foreach (var deviceId in GetDeviceIds())
{
CloseCamera(deviceId);
}
}
catch (Exception ex)
{
Console.WriteLine($"Graceful shutdown failed: {ex.Message}");
}
finally
{
// Force cleanup as last resort
GenICamCameraManager.ForceCleanup();
}⚠️ WARNING: This method should be used with extreme caution as it will dispose all camera instances even if they are currently in use. This can cause exceptions in other parts of the application that are actively using cameras.
This method is intended for use in the following scenarios:
Thread Safety: This method is thread-safe but will affect all threads using cameras.
Recovery: After calling this method, you must call
// First, update the device list
GenICamCameraManager.UpdateDeviceList();
// Get a camera instance
var camera = GenICamCameraManager.GetCamera("MyCamera_12345");
if (camera != null)
{
Console.WriteLine($"Camera retrieved: {camera.DeviceId}");
}
else
{
Console.WriteLine("Camera not found or could not be created");
}This method returns a camera instance from the internal cache. If the camera doesn't exist in the cache, it will attempt to create a new instance. The camera is not automatically connected.
Important: You must call
Use
try
{
var firstCamera = GenICamCameraManager.GetCamera(0);
Console.WriteLine($"First camera: {firstCamera.DeviceId}");
}
catch (ArgumentOutOfRangeException)
{
Console.WriteLine("No cameras available");
}
catch (AravisException ex)
{
Console.WriteLine($"Error getting camera: {ex.Message}");
}This method is a convenience wrapper that gets the device ID for the specified index and then retrieves the corresponding camera instance.
Note: Device indices may change between enumerations. For consistent access, consider using device IDs instead of indices.
#### Exceptions Parameters: - (ArgumentOutOfRangeException): Thrown when the specified index is greater than or equal to the number of available devices. - (AravisException): Thrown when the camera cannot be retrieved or created for the specified index. ### GetCameras() Gets all available cameras as// Get all available cameras
var cameras = GenICamCameraManager.GetCameras();
Console.WriteLine($"Found {cameras.Count} cameras:");
foreach (var camera in cameras)
{
Console.WriteLine($" - {camera.DeviceId}");
}This method retrieves camera instances for all devices found in the most recent enumeration. Cameras that cannot be created or retrieved are skipped with a warning logged.
The returned cameras are not automatically connected. Use
Performance: This method may take some time if there are many cameras or if some cameras are slow to respond during instantiation.
### GetCamerasWithInfo() Gets all cameras with their detailed information loaded by temporarily opening each camera. ```csharp public static List// Get all cameras with detailed information
var camerasWithInfo = GenICamCameraManager.GetCamerasWithInfo();
Console.WriteLine($"Found {camerasWithInfo.Count} cameras with detailed info:");
foreach (var camera in camerasWithInfo)
{
var info = camera.CameraInfo;
Console.WriteLine($" - {info.DeviceId}");
Console.WriteLine($" Vendor: {info.Vendor}");
Console.WriteLine($" Model: {info.Model}");
Console.WriteLine($" Serial: {info.SerialNumber}");
Console.WriteLine($" Resolution: {info.Width}x{info.Height}");
}This method temporarily opens each camera to read its detailed information, then closes it immediately. This provides comprehensive camera information but has the following implications:
Use Cases:
Cameras that cannot be opened or provide information are excluded from the results.
### GetDeviceCount() Gets the number of currently available GenICam-compatible devices. ```csharp public static uint GetDeviceCount() ``` #### Returns Parameters: - (uint): The number of available cameras detected by the system. #### ExamplesGenICamCameraManager.UpdateDeviceList();
uint count = GenICamCameraManager.GetDeviceCount();
Console.WriteLine($"Available cameras: {count}");try
{
string firstDeviceId = GenICamCameraManager.GetDeviceId(0);
Console.WriteLine($"First camera ID: {firstDeviceId}");
}
catch (ArgumentOutOfRangeException)
{
Console.WriteLine("No cameras available");
}This method automatically calls
Device indices are assigned in the order devices are discovered and may change between enumerations.
#### Exceptions Parameters: - (ArgumentOutOfRangeException): Thrown when the specified index is greater than or equal to the number of available devices. ### GetDeviceIds() Gets device IDs for all currently available GenICam-compatible cameras. ```csharp public static string[] GetDeviceIds() ``` #### Returns Parameters: - (string [ ]): An array of device ID strings. Each string uniquely identifies a camera device. #### Examplesstring[] deviceIds = GenICamCameraManager.GetDeviceIds();
foreach (string deviceId in deviceIds)
{
Console.WriteLine($"Found camera: {deviceId}");
}This method automatically calls
Device IDs are typically in the format "Vendor_Model_SerialNumber" but the exact format depends on the camera manufacturer.
The returned array will contain "Unknown" for devices where the ID cannot be determined.
### GetFirstAvailableCamera() Gets the first available camera from the centralized cache. ```csharp public static GenICamCamera GetFirstAvailableCamera() ``` #### Returns Parameters: - (GenICamCamera): Atry
{
var camera = GenICamCameraManager.GetFirstAvailableCamera();
Console.WriteLine($"Using camera: {camera.DeviceId}");
// Open and use the camera
if (GenICamCameraManager.OpenCamera(camera.DeviceId))
{
// Use camera...
GenICamCameraManager.CloseCamera(camera.DeviceId);
}
}
catch (AravisException ex)
{
Console.WriteLine($"No cameras available: {ex.Message}");
}This is a convenience method for applications that only need to work with a single camera or want to use the first available camera by default.
This method automatically calls
The returned camera is not automatically connected. Use
true if the camera is currently open and connected;
false if the camera is closed, not found, or the device ID is invalid.
#### Examples
string deviceId = "MyCamera_12345";
if (GenICamCameraManager.IsCameraOpen(deviceId))
{
Console.WriteLine("Camera is ready for use");
var camera = GenICamCameraManager.GetCamera(deviceId);
// Use camera...
}
else
{
Console.WriteLine("Camera needs to be opened first");
GenICamCameraManager.OpenCamera(deviceId);
}This method provides a quick way to check camera connection status without attempting to open or modify the camera state.
Thread Safety: This method is thread-safe and can be called from any thread.
Performance: This is a lightweight operation that only checks internal state.
### OpenCamera(string) Opens a camera for use by establishing a connection to the hardware. ```csharp public static bool OpenCamera(string deviceId) ``` #### Parameters Parameters: - deviceId (string): The unique device ID of the camera to open. #### Returns Parameters: - (bool):true if the camera was successfully opened and is ready for use;
false if the camera could not be opened.
#### Examples
string deviceId = "MyCamera_12345";
if (GenICamCameraManager.OpenCamera(deviceId))
{
try
{
var camera = GenICamCameraManager.GetCamera(deviceId);
// Use camera for operations
camera.StartStreaming();
// ... perform operations ...
camera.StopStreaming();
}
finally
{
GenICamCameraManager.CloseCamera(deviceId);
}
}
else
{
Console.WriteLine("Failed to open camera");
}This method performs the following operations:
Thread Safety: This method is thread-safe and uses internal locking.
Resource Management: Always call
Error Handling: Detailed error information is logged. Check logs for specific failure reasons.
### SetContext(BaseContext) Sets the BaseContext for logging operations throughout the camera manager. ```csharp public static void SetContext(BaseContext context) ``` #### Parameters Parameters: - context (BaseContext): BaseContext instance for logging. If null, a new default context will be created. #### Examplesvar context = new BaseContext();
GenICamCameraManager.SetContext(context);// Refresh the list of available cameras
GenICamCameraManager.UpdateDeviceList();
// Get count of available devices
uint deviceCount = GenICamCameraManager.GetDeviceCount();
Console.WriteLine($"Found {deviceCount} cameras");This method performs the following operations:
Thread Safety: This method is thread-safe and can be called from multiple threads.
Performance: This method may take some time to complete as it performs hardware enumeration. Consider calling it on a background thread in UI applications.
--- # Class GenICamFrameData Link: api/VisioForge.Core.GenICam.GenICamFrameData.html # Class GenICamFrameData # Class GenICamFrameData **Namespace**: VisioForge.Core.GenICam **Assembly**: VisioForge.Core.dll Frame data container ```csharp public class GenICamFrameData ``` #### Inheritance #### Inherited Members ## Properties ### Data Raw frame data ```csharp public byte[] Data { get; set; } ``` #### Property Value Parameters: - (byte [ ]): ### Height Frame height in pixels ```csharp public int Height { get; set; } ``` #### Property Value Parameters: - (int): ### PixelFormat Pixel format ```csharp public GenICamPixelFormat PixelFormat { get; set; } ``` #### Property Value Parameters: - (GenICamPixelFormat): ### Size Frame data size in bytes ```csharp public int Size { get; set; } ``` #### Property Value Parameters: - (int): ### Timestamp Frame timestamp in nanoseconds ```csharp public ulong Timestamp { get; set; } ``` #### Property Value Parameters: - (ulong): ### Width Frame width in pixels ```csharp public int Width { get; set; } ``` #### Property Value Parameters: - (int): ## Methods ### ToString() Gets frame information as string ```csharp public override string ToString() ``` #### Returns Parameters: - (string): Frame information --- # Class GenICamFrameErrorEventArgs Link: api/VisioForge.Core.GenICam.GenICamFrameErrorEventArgs.html # Class GenICamFrameErrorEventArgs # Class GenICamFrameErrorEventArgs **Namespace**: VisioForge.Core.GenICam **Assembly**: VisioForge.Core.dll Event arguments for GenICam frame error events. This class provides information about errors that occur during frame processing in GenICam-compatible camera devices. ```csharp public class GenICamFrameErrorEventArgs : EventArgs ``` #### Inheritance #### Inherited Members ## Examples// Subscribe to frame error events
camera.FrameError += (sender, e) =>
{
Console.WriteLine($"Frame error occurred: {e.ErrorMessage}");
// Handle the error appropriately
};var errorArgs = new GenICamFrameErrorEventArgs("Frame transmission failed: timeout occurred");errorMessage is null.
## Properties
### ErrorMessage
Gets the error message describing the frame error that occurred.
```csharp
public string ErrorMessage { get; }
```
#### Property Value
Parameters:
- (string):
---
# Class GenICamFrameReceivedEventArgs
Link: api/VisioForge.Core.GenICam.GenICamFrameReceivedEventArgs.html
# Class GenICamFrameReceivedEventArgs
# Class GenICamFrameReceivedEventArgs
**Namespace**: VisioForge.Core.GenICam
**Assembly**: VisioForge.Core.dll
Provides data for the frame received event in GenICam operations.
This event is raised when a new frame is captured from a GenICam-compatible device.
```csharp
public class GenICamFrameReceivedEventArgs : EventArgs
```
#### Inheritance
#### Inherited Members
## Examples
// Subscribe to frame received event
genICamDevice.FrameReceived += (sender, e) =>
{
var frameData = e.Frame;
Console.WriteLine($"Frame received: {frameData.Width}x{frameData.Height}");
};frame is null.
## Properties
### Frame
Gets the frame data associated with the received frame.
```csharp
public GenICamFrameData Frame { get; }
```
#### Property Value
Parameters:
- (GenICamFrameData):
#### Remarks
This property provides read-only access to the frame data. The frame data
contains all relevant information about the captured image frame.
---
# Class ManagedEvaluator
Link: api/VisioForge.Core.GenICam.ManagedEvaluator.html
# Class ManagedEvaluator
# Class ManagedEvaluator
**Namespace**: VisioForge.Core.GenICam
**Assembly**: VisioForge.Core.dll
Managed wrapper class for ArvEvaluator with automatic resource management
```csharp
public class ManagedEvaluator : IDisposable
```
#### Inheritance
#### Implements
#### Inherited Members
## Constructors
### ManagedEvaluator(string)
Creates a new managed evaluator with the given expression
```csharp
public ManagedEvaluator(string expression)
```
#### Parameters
Parameters:
- expression (string): Mathematical expression to evaluate
## Properties
### Expression
Sets or gets the main expression
```csharp
public string Expression { get; set; }
```
#### Property Value
Parameters:
- (string):
### Handle
Gets the native evaluator pointer
```csharp
public nint Handle { get; }
```
#### Property Value
Parameters:
- (nint):
## Methods
### Dispose()
Disposes the evaluator
```csharp
public void Dispose()
```
### Dispose(bool)
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool):
### EvaluateAsDouble()
Evaluates the expression as a double
```csharp
public double EvaluateAsDouble()
```
#### Returns
Parameters:
- (double): Result as double
#### Exceptions
Parameters:
- (InvalidOperationException): Thrown if evaluation fails
### EvaluateAsInt64()
Evaluates the expression as a long integer
```csharp
public long EvaluateAsInt64()
```
#### Returns
Parameters:
- (long): Result as long
#### Exceptions
Parameters:
- (InvalidOperationException): Thrown if evaluation fails
### ~ManagedEvaluator()
```csharp
protected ~ManagedEvaluator()
```
### GetConstant(string)
Gets a constant value
```csharp
public string GetConstant(string name)
```
#### Parameters
Parameters:
- name (string): Name of the constant
#### Returns
Parameters:
- (string): Constant value as string
### GetSubExpression(string)
Gets a sub-expression
```csharp
public string GetSubExpression(string name)
```
#### Parameters
Parameters:
- name (string): Name of the sub-expression
#### Returns
Parameters:
- (string): Expression string
### SetConstant(string, string)
Sets a constant value
```csharp
public void SetConstant(string name, string value)
```
#### Parameters
Parameters:
- name (string): Name of the constant
- value (string): Constant value as string
### SetSubExpression(string, string)
Sets a sub-expression
```csharp
public void SetSubExpression(string name, string expression)
```
#### Parameters
Parameters:
- name (string): Name of the sub-expression
- expression (string): Expression string
### SetVariable(string, double)
Sets a double variable
```csharp
public void SetVariable(string name, double value)
```
#### Parameters
Parameters:
- name (string): Variable name
- value (double): Variable value
### SetVariable(string, long)
Sets an integer variable
```csharp
public void SetVariable(string name, long value)
```
#### Parameters
Parameters:
- name (string): Variable name
- value (long): Variable value
---
# Class ManagedGenICam
Link: api/VisioForge.Core.GenICam.ManagedGenICam.html
# Class ManagedGenICam
# Class ManagedGenICam
**Namespace**: VisioForge.Core.GenICam
**Assembly**: VisioForge.Core.dll
Managed wrapper class for ArvGc providing safe access to GenICam functionality
```csharp
public class ManagedGenICam : IDisposable
```
#### Inheritance
#### Implements
#### Inherited Members
## Constructors
### ManagedGenICam(nint, byte[])
Creates a new GenICam object from XML data
```csharp
public ManagedGenICam(nint device, byte[] xmlData)
```
#### Parameters
Parameters:
- device (nint): Device handle
- xmlData (byte [ ]): GenICam XML data
### ManagedGenICam(nint, bool)
Creates a managed wrapper around an existing GenICam handle
```csharp
public ManagedGenICam(nint handle, bool ownsHandle = true)
```
#### Parameters
Parameters:
- handle (nint): Existing GenICam handle
- ownsHandle (bool): Whether this wrapper owns the handle and should dispose it
## Properties
### Handle
Gets the native handle
```csharp
public nint Handle { get; }
```
#### Property Value
Parameters:
- (nint):
### IsValid
Gets whether the GenICam object is valid
```csharp
public bool IsValid { get; }
```
#### Property Value
Parameters:
- (bool):
## Methods
### Dispose()
Disposes the GenICam object
```csharp
public void Dispose()
```
### Dispose(bool)
Disposes the GenICam object
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): Whether disposing from Dispose method
### ~ManagedGenICam()
Finalizer
```csharp
protected ~ManagedGenICam()
```
### GetAccessCheckPolicy()
Gets the access check policy
```csharp
public GenICamAccessCheckPolicy GetAccessCheckPolicy()
```
#### Returns
Parameters:
- (GenICamAccessCheckPolicy): Current access check policy
### GetBuffer()
Gets the current buffer
```csharp
public nint GetBuffer()
```
#### Returns
Parameters:
- (nint): Buffer handle
### GetDevice()
Gets the associated device
```csharp
public nint GetDevice()
```
#### Returns
Parameters:
- (nint): Device handle
### GetNode(string)
Gets a GenICam node by name
```csharp
public nint GetNode(string nodeName)
```
#### Parameters
Parameters:
- nodeName (string): Name of the node
#### Returns
Parameters:
- (nint): Node handle or IntPtr.Zero if not found
### GetRangeCheckPolicy()
Gets the range check policy
```csharp
public GenICamRangeCheckPolicy GetRangeCheckPolicy()
```
#### Returns
Parameters:
- (GenICamRangeCheckPolicy): Current range check policy
### GetRegisterCachePolicy()
Gets the register cache policy
```csharp
public GenICamRegisterCachePolicy GetRegisterCachePolicy()
```
#### Returns
Parameters:
- (GenICamRegisterCachePolicy): Current cache policy
### RegisterFeatureNode(nint)
Registers a feature node with the GenICam object
```csharp
public void RegisterFeatureNode(nint node)
```
#### Parameters
Parameters:
- node (nint): Feature node handle
### SetAccessCheckPolicy(GenICamAccessCheckPolicy)
Sets the access check policy
```csharp
public void SetAccessCheckPolicy(GenICamAccessCheckPolicy policy)
```
#### Parameters
Parameters:
- policy (GenICamAccessCheckPolicy): Access check policy
### SetBuffer(nint)
Sets the buffer for chunk data parsing
```csharp
public void SetBuffer(nint buffer)
```
#### Parameters
Parameters:
- buffer (nint): Buffer handle
### SetRangeCheckPolicy(GenICamRangeCheckPolicy)
Sets the range check policy
```csharp
public void SetRangeCheckPolicy(GenICamRangeCheckPolicy policy)
```
#### Parameters
Parameters:
- policy (GenICamRangeCheckPolicy): Range check policy
### SetRegisterCachePolicy(GenICamRegisterCachePolicy)
Sets the register cache policy
```csharp
public void SetRegisterCachePolicy(GenICamRegisterCachePolicy policy)
```
#### Parameters
Parameters:
- policy (GenICamRegisterCachePolicy): Cache policy
---
# Namespace VisioForge.Core.GenICam
Link: api/VisioForge.Core.GenICam.html
# Namespace VisioForge.Core.GenICam
# Namespace VisioForge.Core.GenICam
### Namespaces
Parameters:
- ():
- ():
### Classes
Parameters:
- (): Stream diagnostics information
- (): Represents a GenICam-compliant camera device with high-level access to camera information,
resolutions, pixel formats, and control features. This class provides a comprehensive
wrapper around the Aravis library for industrial camera control.
Typical Usage Workflow:
Thread Safety: This class is not thread-safe. Access should be synchronized when used from multiple threads, particularly for streaming operations.
Resource Management: The class implements
using var camera = GenICamCameraManager.CreateCamera("MyCamera");
if (camera.Connect())
{
camera.ReadInfo();
camera.SetExposureTime(10000); // 10ms
camera.SetGain(0.0);
camera.FrameReceived += (s, e) => {
Console.WriteLine($"Frame: {e.FrameData.Width}x{e.FrameData.Height}");
};
camera.StartStreaming();
Thread.Sleep(5000); // Stream for 5 seconds
camera.StopStreaming();
}Thread Safety: This class is fully thread-safe and can be used from multiple threads simultaneously.
Usage Pattern:
Resource Management:
Cameras are automatically cleaned up when they become unavailable. The manager tracks device availability
and removes cameras that are no longer present in the system during
// Enumerate and populate camera dictionary
GenICamCameraManager.UpdateDeviceList();
// Get camera reference
var camera = GenICamCameraManager.GetCamera("MyCamera");
if (camera == null)
{
Console.WriteLine("Camera not found");
return;
}
// Open camera for use
if (GenICamCameraManager.OpenCamera("MyCamera"))
{
try
{
// Use camera for operations
camera.StartStreaming();
// Perform image capture operations
// ... do work ...
camera.StopStreaming();
}
finally
{
// Always close camera when done
GenICamCameraManager.CloseCamera("MyCamera");
}
}
else
{
Console.WriteLine("Failed to open camera");
}true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### ~GIFDecoder()
Finalizes an instance of the true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### ~GIFFrame()
Finalizes an instance of the When writing to a full buffer:
This implementation is inspired by the Boost circular_buffer library: http://www.boost.org/doc/libs/1_53_0/libs/circular_buffer/doc/circular_buffer.html
## Constructors ### CircularBuffer(int) Initializes a new instance of theThis method provides a zero-copy view of the buffer contents, which is useful for performance-critical scenarios such as network operations (e.g., Send(IList<ArraySegment<byte>>)).
The segments preserve the logical order of elements from front to back. Either or both segments may be empty depending on the buffer state.
--- # Class ColorspaceConverter Link: api/VisioForge.Core.Helpers.ColorspaceConverter.html # Class ColorspaceConverter # Class ColorspaceConverter **Namespace**: VisioForge.Core.Helpers **Assembly**: VisioForge.Core.dll Provides methods for converting between different color space formats such as RGB, RGBA, ARGB, BGRA, YUV, and others. Supports hardware-accelerated conversions using Intel IPP when available on Windows platforms. ```csharp public static class ColorspaceConverter ``` #### Inheritance #### Inherited Members ## Methods ### ARGBToBGRA(nint, int, nint, int, int, int) Converts image data from ARGB format (Alpha, Red, Green, Blue) to BGRA format (Blue, Green, Red, Alpha). ```csharp public static void ARGBToBGRA(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source ARGB image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for BGRA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### ARGBToRGB(nint, int, nint, int, int, int) Converts ARGB image data (4 bytes per pixel) to RGB format (3 bytes per pixel), discarding the alpha channel. ```csharp public static void ARGBToRGB(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source ARGB image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for RGB image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### BGRAToARGB(nint, int, nint, int, int, int) Converts image data from BGRA format (Blue, Green, Red, Alpha) to ARGB format (Alpha, Red, Green, Blue). ```csharp public static void BGRAToARGB(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source BGRA image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for ARGB image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### BGRToBGRA(nint, int, nint, int, int, int) Converts BGR image data (3 bytes per pixel) to BGRA format (4 bytes per pixel) with full opacity (alpha = 255). ```csharp public static void BGRToBGRA(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source BGR image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for BGRA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### BGRToRGBA(nint, int, nint, int, int, int) Converts BGR image data (3 bytes per pixel) to RGBA format (4 bytes per pixel) with full opacity (alpha = 255). Swaps red and blue channels during conversion. ```csharp public static void BGRToRGBA(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source BGR image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for RGBA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### NV12ToRGBSlow(nint, int, int, int, nint, int) Converts NV12 YUV format to RGB format using software conversion (slower than hardware-accelerated methods). NV12 format stores Y plane followed by interleaved UV plane. ```csharp public static void NV12ToRGBSlow(nint nv12Data, int stride, int width, int height, nint rgbData, int rgbStride) ``` #### Parameters Parameters: - nv12Data (nint): Pointer to the source NV12 data containing Y plane and UV plane. - stride (int): The stride of the NV12 data (bytes per row). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. - rgbData (nint): Pointer to the destination buffer for RGB data. - rgbStride (int): The stride of the RGB data (bytes per row). ### RGBAToARGB(nint, int, nint, int, int, int) Converts image data from RGBA format (Red, Green, Blue, Alpha) to ARGB format (Alpha, Red, Green, Blue). ```csharp public static void RGBAToARGB(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source RGBA image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for ARGB image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### RGBAToBGRA(nint, int, nint, int, int, int) Converts image data from RGBA format (Red, Green, Blue, Alpha) to BGRA format (Blue, Green, Red, Alpha). ```csharp public static void RGBAToBGRA(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source RGBA image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for BGRA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### RGBAToCairo32(byte[], double) Converts RGBA image data to Cairo32 format with pre-multiplied alpha. Cairo32 format stores pixels in pre-multiplied BGRA order for efficient rendering. ```csharp public static byte[] RGBAToCairo32(byte[] data, double alpha) ``` #### Parameters Parameters: - data (byte [ ]): The source RGBA image data as a byte array. - alpha (double): Additional alpha multiplier (0.0 to 1.0) to apply to all pixels. #### Returns Parameters: - (byte [ ]): A new byte array containing the converted Cairo32 format data. ### RGBAToCairo32Ptr(byte[], double) Converts RGBA image data to Cairo32 format and returns a pointer to the converted data. The caller is responsible for freeing the allocated memory using Marshal.FreeHGlobal. ```csharp public static nint RGBAToCairo32Ptr(byte[] data, double alpha) ``` #### Parameters Parameters: - data (byte [ ]): The source RGBA image data as a byte array. - alpha (double): Additional alpha multiplier (0.0 to 1.0) to apply to all pixels. #### Returns Parameters: - (nint): A pointer to the newly allocated Cairo32 format data. Must be freed by the caller. ### RGBToARGB(nint, int, nint, int, int, int) Converts RGB image data (3 bytes per pixel) to ARGB format (4 bytes per pixel) with full opacity (alpha = 255). ```csharp public static void RGBToARGB(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source RGB image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for ARGB image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### RGBToBGRA(nint, int, nint, int, int, int) Converts RGB image data (3 bytes per pixel) to BGRA format (4 bytes per pixel) with full opacity (alpha = 255). Swaps red and blue channels during conversion. ```csharp public static void RGBToBGRA(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source RGB image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for BGRA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### RGBToRGBA(byte[], nint, int, int, int) Converts RGB image data (3 bytes per pixel) to RGBA format (4 bytes per pixel) with full opacity. This overload accepts input data as a byte array. ```csharp public static void RGBToRGBA(byte[] inputData, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputData (byte [ ]): The source RGB image data as a byte array. - outputPtr (nint): Pointer to the destination buffer for RGBA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. ### RGBToRGBA(nint, int, nint, int, int, int) Converts RGB image data (3 bytes per pixel) to RGBA format (4 bytes per pixel) with full opacity (alpha = 255). ```csharp public static void RGBToRGBA(nint inputPtr, int inputStride, nint outputPtr, int outputStride, int width, int height) ``` #### Parameters Parameters: - inputPtr (nint): Pointer to the source RGB image data. - inputStride (int): The number of bytes per row in the source image (including padding). - outputPtr (nint): Pointer to the destination buffer for RGBA image data. - outputStride (int): The number of bytes per row in the destination image (including padding). - width (int): The width of the image in pixels. - height (int): The height of the image in pixels. --- # Class DecklinkHelper Link: api/VisioForge.Core.Helpers.DecklinkHelper.html # Class DecklinkHelper # Class DecklinkHelper **Namespace**: VisioForge.Core.Helpers **Assembly**: VisioForge.Core.dll Provides helper methods for working with Blackmagic DeckLink professional video hardware. This class contains extension methods and utilities for converting between DeckLink-specific formats and the framework's internal format representations. ```csharp public static class DecklinkHelper ``` #### Inheritance #### Inherited Members ## Methods ### GetVideoInfoFromMode(DecklinkMode, out int, out int, out VideoFrameRate) Extracts video format information from a DeckLink video mode. This method parses the DeckLink mode enumeration and returns the corresponding video resolution (width and height) and frame rate for the specified mode. ```csharp public static void GetVideoInfoFromMode(this DecklinkMode mode, out int width, out int height, out VideoFrameRate framerate) ``` #### Parameters Parameters: - mode (DecklinkMode): The DeckLink video mode to parse. - width (int): When this method returns, contains the horizontal resolution in pixels for the specified mode. - height (int): When this method returns, contains the vertical resolution in pixels for the specified mode. - framerate (VideoFrameRate): When this method returns, contains the frame rate information for the specified mode. #### Remarks Supports standard definition (NTSC/PAL), HD (720p/1080i/1080p), 2K DCI, and UHD 4K formats. For unrecognized modes, returns width=0, height=0, and framerate=25fps. ### ToFormat(DecklinkAudioFormat) Converts a DeckLink audio format to the framework's internal AudioFormatX representation. ```csharp public static AudioFormatX ToFormat(this DecklinkAudioFormat format) ``` #### Parameters Parameters: - format (DecklinkAudioFormat): The DeckLink audio format to convert. #### Returns Parameters: - (AudioFormatX): The corresponding AudioFormatX format. Returns S16LE as the default if the format is not recognized. --- # Class FilenameHelper Link: api/VisioForge.Core.Helpers.FilenameHelper.html # Class FilenameHelper # Class FilenameHelper **Namespace**: VisioForge.Core.Helpers **Assembly**: VisioForge.Core.dll Provides utility methods for working with file names, extensions, and paths. ```csharp public static class FilenameHelper ``` #### Inheritance #### Inherited Members ## Methods ### ChangeFileExt(string, string) Changes the file extension of the specified file name to a new extension. ```csharp public static string ChangeFileExt(string filename, string ext) ``` #### Parameters Parameters: - filename (string): The original file name whose extension will be changed. - ext (string): The new extension to apply (should include the period, e.g., ".txt"). #### Returns Parameters: - (string): The file name with the new extension, or the original file name if no extension was found. ### GetFileExt(string) Gets the file extension from the specified file name, including the period. ```csharp public static string GetFileExt(string fileName) ``` #### Parameters Parameters: - fileName (string): The file name from which to extract the extension. #### Returns Parameters: - (string): The file extension including the period (e.g., ".txt"), or an empty string if no extension is found or an error occurs. ### IsAudioFile(string) Determines whether the specified file name represents an audio file based on its extension. ```csharp public static bool IsAudioFile(string filename) ``` #### Parameters Parameters: - filename (string): The file name to check. #### Returns Parameters: - (bool):true if the file extension matches common audio formats (WAV, MP3, OGG, M4A, FLAC, OPUS, SPEEX, WMA); otherwise, false.
### IsImageFile(string)
Determines whether the specified file name represents an image file based on its extension.
```csharp
public static bool IsImageFile(string filename)
```
#### Parameters
Parameters:
- filename (string): The file name to check.
#### Returns
Parameters:
- (bool): true if the file extension matches common image formats (BMP, JPG, JPEG, GIF, PNG, TIF, TIFF); otherwise, false.
### SafeCreateFileUri(string)
Creates a true if all coordinates (Left, Top, Right, Bottom) are zero, indicating an empty rectangle;
otherwise, false.
#### Remarks
An empty rectangle is defined as having all coordinate values set to zero.
This method is useful for checking if a rectangle has been initialized or contains valid dimensions.
### ToRect(VFRectIntl)
Converts a VFRectIntl instance to a Rect instance.
```csharp
public static Rect ToRect(this VFRectIntl rect)
```
#### Parameters
Parameters:
- rect (VFRectIntl): The VFRectIntl instance to convert.
#### Returns
Parameters:
- (Rect): A new Rect instance with the same dimensions as the input VFRectIntl.
#### Remarks
This method provides cross-platform rectangle conversion between VisioForge's internal rectangle type
and the standard Rect type used throughout the framework.
### ToRectIntl(Rect)
Converts a Rect instance to a VFRectIntl instance.
```csharp
public static VFRectIntl ToRectIntl(this Rect rect)
```
#### Parameters
Parameters:
- rect (Rect): The Rect instance to convert.
#### Returns
Parameters:
- (VFRectIntl): A new VFRectIntl instance with the same dimensions as the input Rect.
#### Remarks
This method provides cross-platform rectangle conversion from the standard Rect type
to VisioForge's internal rectangle representation.
---
# Namespace VisioForge.Core.Helpers
Link: api/VisioForge.Core.Helpers.html
# Namespace VisioForge.Core.Helpers
# Namespace VisioForge.Core.Helpers
### Classes
Parameters:
- (): A generic circular buffer implementation that allows efficient insertion and removal
of elements at both ends of the buffer. When the buffer reaches full capacity,
adding new elements will automatically remove elements from the opposite end.
- (): Provides methods for converting between different color space formats such as RGB, RGBA, ARGB, BGRA, YUV, and others.
Supports hardware-accelerated conversions using Intel IPP when available on Windows platforms.
- (): Provides helper methods for working with Blackmagic DeckLink professional video hardware.
This class contains extension methods and utilities for converting between DeckLink-specific
formats and the framework's internal format representations.
- (): Provides utility methods for working with file names, extensions, and paths.
- (): Extension methods for converting between different image formats.
- (): Provides comprehensive image processing utilities for RGB/RGBA image manipulation, stride calculations,
and pixel format conversions. This static helper class handles low-level image operations including
memory copying, color format conversions, image flipping, and stride calculations for various pixel
formats (RGB24, RGB32, ARGB). Essential for video frame processing and image manipulation operations
across the VisioForge media framework.
- (): Provides mathematical utility methods and extension methods for common mathematical operations.
- (): Provides extension methods for string str = Encoding.ASCII.GetString(decodeResults[0].Data).TrimEnd('\0');true if the build was successful or was already built; false otherwise.
#### Remarks
This method connects all video and audio bridge sources to their respective switch inputs.
It is called automatically by true to release both managed and unmanaged resources; false to release only unmanaged resources.
### DurationAsync()
Gets the current playback duration/position of the switch block.
```csharp
public Tasknull as this is a composite block without a single underlying element.
### GetPipeline()
Gets the parent pipeline that hosts this switch block.
```csharp
public MediaBlocksPipeline GetPipeline()
```
#### Returns
Parameters:
- (MediaBlocksPipeline): The true if the input was added successfully; otherwise, false.
#### Remarks
The input is assigned a unique bridge name and automatically started if the main pipeline is already running.
Returns false if the maximum video input count has been reached.
### Input_AddAsync(LVCAudioInput)
Adds an audio-only input source to the switch.
```csharp
public Tasktrue if the input was added successfully; otherwise, false.
#### Remarks
The audio format is automatically configured to match the switch settings.
The input is started automatically if AutoStart is true and the main pipeline is running.
### Input_AddAsync(LVCVideoAudioInput, bool)
Adds a combined video and audio input source to the switch.
```csharp
public Tasktrue, starts the input immediately after adding; otherwise, waits for AutoStart or manual start.
#### Returns
Parameters:
- (Task < bool >): A true if the input was added successfully; otherwise, false.
### Input_AddAsync(LVCFileVideoAudioInput, bool)
Adds a file-based video and audio input source to the switch.
```csharp
public Tasktrue, starts the input immediately after adding; otherwise, waits for AutoStart or manual start.
#### Returns
Parameters:
- (Task < bool >): A true if the input was added successfully; otherwise, false.
#### Remarks
This method uses buffered bridge sources for file inputs to ensure smooth playback.
### Input_FileVideoAudio_Get(int)
Gets a file-based video/audio input by its index position.
```csharp
public LVCFileVideoAudioInput Input_FileVideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input to retrieve.
#### Returns
Parameters:
- (LVCFileVideoAudioInput): The null if the index is invalid or the input is not a file video/audio type.
### Input_Get(int)
Gets any input by its index position.
```csharp
public LVCInput Input_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input to retrieve.
#### Returns
Parameters:
- (LVCInput): The null if the index is out of range.
### Input_RemoveAtAsync(int)
Removes an input at the specified index position.
```csharp
public Tasktrue if the input was removed successfully; otherwise, false.
#### Remarks
The input pipeline is stopped and disposed before removal. Returns false if the index is out of range.
### Input_VideoAudio_Get(int)
Gets a video/audio input by its index position.
```csharp
public LVCVideoAudioInput Input_VideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input to retrieve.
#### Returns
Parameters:
- (LVCVideoAudioInput): The null if the index is invalid or the input is not a video/audio type.
### StartAsync()
Starts the switch block and all configured input sources asynchronously.
```csharp
public Tasktrue if startup was successful; otherwise, false.
#### Remarks
This method builds the pipeline if not already built, preloads all inputs,
then starts all input pipelines and the main pipeline in synchronized fashion.
### StopAsync()
Stops the switch block and all active input sources asynchronously.
```csharp
public Task StopAsync()
```
#### Returns
Parameters:
- (Task): A true if the build was successful or was already built; false otherwise.
#### Remarks
This method connects all video and audio bridge sources to their respective switch inputs.
Bridge sources remain connected even when slots are empty, outputting silence/black until an input is added.
### CleanUp()
Cleans up resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Disposes resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool):
### DurationAsync()
Gets the current playback duration/position of the main pipeline.
```csharp
public Tasktrue if the input was added successfully; otherwise, false.
#### Remarks
Each slot has a fixed bridge name. When an input is added to a slot, it connects to that bridge.
The slot must be empty before adding a new input - use true if the input was added successfully; otherwise, false.
#### Remarks
Both video and audio streams are connected to their respective bridges for the same slot index.
The slot must be empty before adding a new input.
### Input_GetFromSlot(int)
Gets the input at a specific slot.
```csharp
public LVCInput Input_GetFromSlot(int slotIndex)
```
#### Parameters
Parameters:
- slotIndex (int): The zero-based slot index.
#### Returns
Parameters:
- (LVCInput): The null if the slot is empty or the index is invalid.
### Input_RemoveFromSlotAsync(int)
Removes an input from a specific slot.
```csharp
public Tasktrue if the slot was cleared successfully; otherwise, false.
#### Remarks
The bridge source remains active after removal, outputting silence/black until a new input is added.
The new input must use the same bridge name for this slot, which is handled automatically by true if the slot is already empty.
### StartAsync()
Starts the switch block and all configured input sources asynchronously.
```csharp
public Tasktrue if startup was successful; otherwise, false.
#### Remarks
This method builds the pipeline if not already built, preloads all inputs in occupied slots,
then starts all input pipelines and the main pipeline in synchronized fashion.
### StopAsync()
Stops the switch block and all active input sources asynchronously.
```csharp
public Task StopAsync()
```
#### Returns
Parameters:
- (Task): A // Create compositor with specific settings
var settings = new LiveVideoCompositorSettings
{
VideoWidth = 1920,
VideoHeight = 1080,
VideoFrameRate = new VideoFrameRate(30, 1),
MixerType = LVCMixerType.OpenGL,
MaxVideoInputsCount = 4,
MaxVideoOutputsCount = 2
};
using var compositor = new LiveVideoCompositor(settings);
// Add video inputs
var input1 = new LVCVideoAudioInput("Camera 1", captureSettings);
await compositor.Input_AddAsync(input1);
// Add output
var output = new LVCVideoAudioOutput("RTMP Stream", rtmpSettings);
await compositor.Output_AddAsync(output);
// Start composition
await compositor.StartAsync();true to release both managed and unmanaged resources; false to release only unmanaged resources.
#### Remarks
This method follows the standard IDisposable pattern.
When disposing is true, both managed and unmanaged resources are released.
When disposing is false (called from finalizer), only unmanaged resources are released.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
#### Remarks
This method should be called when the Live Video Compositor is no longer needed.
It releases all resources including MediaBlocks pipelines, mixers, effects, and overlays.
After disposal, the object cannot be used and should be discarded.
### DisposeAsync()
Asynchronously disposes of the Live Video Compositor and all its resources.
```csharp
public ValueTask DisposeAsync()
```
#### Returns
Parameters:
- (ValueTask): A ValueTask representing the asynchronous disposal operation.
#### Remarks
This method provides asynchronous disposal support for scenarios where pipeline
shutdown may involve asynchronous operations. It ensures proper cleanup of all
MediaBlocks components without blocking the calling thread.
Prefer this method over synchronous Dispose() when possible.
### DurationAsync()
Gets the current playback position of the main pipeline.
```csharp
public Tasktrue if added successfully, false if max inputs reached.
### Input_AddAsync(LVCAudioInput)
Adds an audio-only input source to the compositor.
```csharp
public Tasktrue if added successfully, false if max inputs reached.
### Input_AddAsync(LVCVideoAudioInput, bool)
Adds a combined video and audio input source to the compositor.
```csharp
public Tasktrue, starts the input immediately after adding (overrides AutoStart property).
#### Returns
Parameters:
- (Task < bool >): A task that represents the asynchronous operation. The task result contains true if added successfully, false if max inputs reached.
### Input_AddAsync(LVCFileVideoAudioInput, bool)
Adds a file-based video and audio input source to the compositor.
```csharp
public Tasktrue, starts the input immediately after adding (overrides AutoStart property).
#### Returns
Parameters:
- (Task < bool >): A task that represents the asynchronous operation. The task result contains true if added successfully, false if max inputs reached.
### Input_FileVideoAudio_Get(int)
Gets a file video/audio input by its index.
```csharp
public LVCFileVideoAudioInput Input_FileVideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input.
#### Returns
Parameters:
- (LVCFileVideoAudioInput): The file video/audio input at the specified index, or null if index is invalid or input is not a file video/audio type.
### Input_Get(int)
Gets an input source by its index, regardless of type.
```csharp
public LVCInput Input_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input.
#### Returns
Parameters:
- (LVCInput): The input at the specified index, or null if index is invalid.
### Input_RemoveAsync(string)
Removes an input source from the compositor by its name.
```csharp
public Tasktrue if removed successfully, false if not found.
### Input_RemoveAtAsync(int)
Removes an input source from the compositor by its index.
```csharp
public Tasktrue if removed successfully, false if index is invalid.
### Input_VideoAudio_Get(int)
Gets a video/audio input by its index.
```csharp
public LVCVideoAudioInput Input_VideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input.
#### Returns
Parameters:
- (LVCVideoAudioInput): The video/audio input at the specified index, or null if index is invalid or input is not a video/audio type.
### Input_VideoStream_Get(int)
Gets the video mixer stream configuration for a specific input by index.
```csharp
public VideoMixerStream Input_VideoStream_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the video input.
#### Returns
Parameters:
- (VideoMixerStream): The video mixer stream configuration, or null if index is invalid or mixer is not available.
### Input_VideoStream_Update(int, VideoMixerStream)
Updates the video mixer stream configuration for a specific input.
```csharp
public void Input_VideoStream_Update(int index, VideoMixerStream stream)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the video input (not used as stream contains its own ID).
- stream (VideoMixerStream): The updated stream configuration including position, size, and other properties.
### Output_AddAsync(LVCVideoOutput, bool)
Adds a video-only output destination to the compositor.
```csharp
public Tasktrue, starts the output immediately when the pipeline is running.
#### Returns
Parameters:
- (Task < bool >): A task that represents the asynchronous operation. The task result contains true if added successfully, false if max outputs reached.
### Output_AddAsync(LVCAudioOutput, bool)
Adds an audio-only output destination to the compositor.
```csharp
public Tasktrue, starts the output immediately when the pipeline is running.
#### Returns
Parameters:
- (Task < bool >): A task that represents the asynchronous operation. The task result contains true if added successfully, false if max outputs reached.
### Output_AddAsync(LVCVideoAudioOutput, bool)
Adds a combined video and audio output destination to the compositor.
```csharp
public Tasktrue, starts the output immediately when the pipeline is running.
#### Returns
Parameters:
- (Task < bool >): A task that represents the asynchronous operation. The task result contains true if added successfully, false if max outputs reached.
### Output_Audio_Get(int)
Gets an audio output by its index.
```csharp
public LVCAudioOutput Output_Audio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCAudioOutput): The audio output at the specified index, or null if index is invalid or output is not an audio type.
### Output_Get(int)
Gets an output destination by its index, regardless of type.
```csharp
public LVCOutput Output_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCOutput): The output at the specified index, or null if index is invalid.
### Output_Get(string)
Gets an output destination by its unique name.
```csharp
public LVCOutput Output_Get(string name)
```
#### Parameters
Parameters:
- name (string): The unique name of the output.
#### Returns
Parameters:
- (LVCOutput): The output with the specified name, or null if not found.
### Output_RemoveAsync(string)
Removes an output destination from the compositor by its name.
```csharp
public Tasktrue if removed successfully, false if not found.
### Output_RemoveAtAsync(int)
Removes an output destination from the compositor by its index.
```csharp
public Tasktrue if removed successfully, false if index is invalid.
### Output_VideoAudio_Get(int)
Gets a video/audio output by its index.
```csharp
public LVCVideoAudioOutput Output_VideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCVideoAudioOutput): The video/audio output at the specified index, or null if index is invalid or output is not a video/audio type.
### Output_Video_Get(int)
Gets a video output by its index.
```csharp
public LVCVideoOutput Output_Video_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCVideoOutput): The video output at the specified index, or null if index is invalid or output is not a video type.
### SetLicenseKey(string, string, string)
Sets the license key and user information for Live Video Compositor activation.
```csharp
public void SetLicenseKey(string licenseKey, string userName, string email)
```
#### Parameters
Parameters:
- licenseKey (string): The VisioForge license key for this component.
- userName (string): The registered user name associated with the license.
- email (string): The email address associated with the license.
#### Remarks
This method must be called before starting composition operations to enable full functionality.
The license key is validated against the provided user credentials.
Invalid or missing license may result in limited functionality or watermarked output.
### StartAsync()
Starts the compositor, including all input pipelines, the main pipeline, and auto-start outputs.
```csharp
public Tasktrue if started successfully, false otherwise.
### StopAsync()
Stops the compositor, including all input pipelines, the main pipeline, and all outputs.
```csharp
public Task StopAsync()
```
#### Returns
Parameters:
- (Task): A task that represents the asynchronous stop operation.
### Switch(int)
Switches to a specific input when using switcher mode (applies to both video and audio).
```csharp
public void Switch(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input to switch to.
### Video_Effects_AddOrUpdateAsync(IBaseVideoEffect, int)
Adds a new video effect or updates an existing effect on the specified channel.
```csharp
public Task Video_Effects_AddOrUpdateAsync(IBaseVideoEffect effect, int channel = 0)
```
#### Parameters
Parameters:
- effect (IBaseVideoEffect): The video effect to add or update. Must implement IBaseVideoEffect interface.
- channel (int): The video channel index to apply the effect to. Default is 0.
#### Returns
Parameters:
- (Task): A Task representing the asynchronous operation.
#### Remarks
If an effect with the same name already exists, it will be updated with the new parameters.
Effects are applied in the order they are added to the channel.
### Video_Effects_Clear(int)
Removes all video effects from the specified channel.
```csharp
public void Video_Effects_Clear(int channel = 0)
```
#### Parameters
Parameters:
- channel (int): The video channel index to clear effects from. Default is 0.
#### Remarks
This operation immediately removes all effects without pausing the pipeline.
Use with caution during active composition as it may cause visual discontinuity.
### Video_Effects_Get(string, int)
Retrieves a video effect by name from the specified channel.
```csharp
public IBaseVideoEffect Video_Effects_Get(string effectName, int channel = 0)
```
#### Parameters
Parameters:
- effectName (string): The unique name identifier of the effect to retrieve.
- channel (int): The video channel index to search for the effect. Default is 0.
#### Returns
Parameters:
- (IBaseVideoEffect): The video effect instance if found; otherwise, null.
#### Remarks
Effect names are case-sensitive and must match exactly.
### Video_Effects_RemoveAsync(IBaseVideoEffect, int)
Removes a video effect instance from the specified channel.
```csharp
public Task Video_Effects_RemoveAsync(IBaseVideoEffect effect, int channel = 0)
```
#### Parameters
Parameters:
- effect (IBaseVideoEffect): The video effect instance to remove.
- channel (int): The video channel index to remove the effect from. Default is 0.
#### Returns
Parameters:
- (Task): A Task representing the asynchronous operation.
#### Remarks
The pipeline is temporarily paused during effect removal to ensure thread safety.
If the effect is not found on the channel, the method returns without error.
### Video_Effects_RemoveAsync(string, int)
Removes a video effect by name from the specified channel.
```csharp
public Task Video_Effects_RemoveAsync(string name, int channel = 0)
```
#### Parameters
Parameters:
- name (string): The unique name identifier of the effect to remove.
- channel (int): The video channel index to remove the effect from. Default is 0.
#### Returns
Parameters:
- (Task): A Task representing the asynchronous operation.
#### Remarks
The pipeline is temporarily paused during effect removal to ensure thread safety.
If no effect with the given name exists, the method returns without error.
### Video_Overlay_Add(IOverlayManagerElement, int)
Adds a new overlay element to the specified video channel.
```csharp
public void Video_Overlay_Add(IOverlayManagerElement overlay, int channel = 0)
```
#### Parameters
Parameters:
- overlay (IOverlayManagerElement): The overlay element to add. Must implement IOverlayManagerElement interface.
- channel (int): The video channel index to add the overlay to. Default is 0.
#### Remarks
Overlays are rendered in the order they are added, with later overlays appearing on top.
Supported overlay types include text, images, graphics, and custom visual elements.
### Video_Overlay_Clear(int)
Removes all overlay elements from the specified video channel.
```csharp
public void Video_Overlay_Clear(int channel = 0)
```
#### Parameters
Parameters:
- channel (int): The video channel index to clear overlays from. Default is 0.
#### Remarks
This operation immediately removes all overlays from the channel.
Use with caution during active composition as it may cause visual discontinuity.
### Video_Overlay_Count(int)
Gets the total number of overlays in the specified video channel.
```csharp
public int Video_Overlay_Count(int channel = 0)
```
#### Parameters
Parameters:
- channel (int): The video channel index to count overlays from. Default is 0.
#### Returns
Parameters:
- (int): The number of overlay elements in the channel.
### Video_Overlay_Get(int, int)
Gets the overlay element at the specified index from the video channel.
```csharp
public IOverlayManagerElement Video_Overlay_Get(int index, int channel = 0)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the overlay to retrieve.
- channel (int): The video channel index to get the overlay from. Default is 0.
#### Returns
Parameters:
- (IOverlayManagerElement): The overlay element at the specified index.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when index is out of range.
### Video_Overlay_Remove(IOverlayManagerElement, int)
Removes an overlay element from the specified video channel.
```csharp
public void Video_Overlay_Remove(IOverlayManagerElement overlay, int channel = 0)
```
#### Parameters
Parameters:
- overlay (IOverlayManagerElement): The overlay element instance to remove.
- channel (int): The video channel index to remove the overlay from. Default is 0.
#### Remarks
If the overlay is not found on the channel, the method returns without error.
### Video_Overlay_RemoveAt(int, int)
Removes an overlay element at the specified index from the video channel.
```csharp
public void Video_Overlay_RemoveAt(int index, int channel = 0)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the overlay to remove.
- channel (int): The video channel index to remove the overlay from. Default is 0.
#### Remarks
Throws an exception if the index is out of range for the channel's overlay collection.
### Video_Overlay_Update(IOverlayManagerElement, int)
Updates an existing overlay element by removing and re-adding it to the specified channel.
```csharp
public void Video_Overlay_Update(IOverlayManagerElement overlay, int channel = 0)
```
#### Parameters
Parameters:
- overlay (IOverlayManagerElement): The overlay element with updated properties.
- channel (int): The video channel index containing the overlay. Default is 0.
#### Remarks
This method removes the existing overlay and adds it back with updated properties.
The overlay's position in the rendering order is preserved.
### OnError
Occurs when an error happens in any of the pipelines or during operations.
```csharp
public event EventHandler// Create settings for 1080p live composition
var settings = new LiveVideoCompositorSettings(1920, 1080, new VideoFrameRate(30, 1))
{
MixerType = LVCMixerType.OpenGL,
VideoChannelCount = 2, // Two independent video processing channels
MaxVideoInputsCount = 6,
MaxVideoOutputsCount = 3,
AudioSampleRate = 48000,
AudioChannels = 2
};// Creating an audio input with custom format
var audioInfo = new AudioInfoX(AudioFormatX.S16LE, 48000, 2);
var audioInput = new LVCAudioInput("Microphone", compositor, sourceBlock, audioInfo, autostart: true);
await compositor.Input_AddAsync(audioInput);true, automatically starts the input when added to compositor.
- processingBlock (MediaBlock): The optional processing block for audio effects or transformations.
## Methods
### Build(int, string, int, string)
Builds the audio input pipeline by creating bridge connections and linking media blocks.
```csharp
public override void Build(int id, string uniqueName, int id2 = -1, string uniqueName2 = null)
```
#### Parameters
Parameters:
- id (int): The primary identifier for this input.
- uniqueName (string): The unique name for the bridge connection.
- id2 (int): The secondary identifier (optional, default is -1).
- uniqueName2 (string): The secondary unique name (optional).
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when media type is invalid.
### UpdateInfo(AudioInfoX)
Updates the audio format information for this input.
```csharp
public void UpdateInfo(AudioInfoX info)
```
#### Parameters
Parameters:
- info (AudioInfoX): The new audio format information including sample rate, channels, and bit depth.
## See Also
---
# Class LVCAudioOutput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCAudioOutput.html
# Class LVCAudioOutput
# Class LVCAudioOutput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Live Video Compositor audio output that receives composed audio content from the main composition pipeline.
Handles audio-only destinations including file encoders, streaming outputs, audio monitoring, and hardware outputs.
Each audio output maintains its own processing pipeline with format conversion to match the target destination requirements.
Implements the // Creating an audio output for file recording
var audioOutput = new LVCAudioOutput("Audio Recording", compositor, audioEncoderBlock, autostart: true);
await compositor.Output_AddAsync(audioOutput);true, automatically starts with the main pipeline.
## See Also
---
# Class LVCFileVideoAudioInput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCFileVideoAudioInput.html
# Class LVCFileVideoAudioInput
# Class LVCFileVideoAudioInput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Live Video Compositor file-based video and audio input specifically optimized for media file playback within compositions.
Handles video and audio content from file sources with specialized buffering and synchronization for non-live content.
Uses BridgeBufferSinkBlock for video to provide optimal file-based media integration with the live composition pipeline.
Implements the // Creating a file input for background video
var fileInput = new LVCFileVideoAudioInput("Background", compositor, fileSourceBlock,
videoInfo, audioInfo, new Rect(0, 0, 1920, 1080), autostart: true);
await compositor.Input_AddAsync(fileInput);true, the input automatically starts with the main compositor pipeline.
- processingVideoBlock (MediaBlock): Optional processing block for video effects or transformations before bridging.
- processingAudioBlock (MediaBlock): Optional processing block for audio effects or transformations before bridging.
- live (bool): If set to true, treats the file source with live source timing (typically false for files).
- customSyncFlag (bool ?): Optional synchronization flag for controlling file-to-live timing alignment.
### LVCFileVideoAudioInput(string, MediaBlock, VideoFrameInfoX, AudioInfoX, Rect, bool, MediaBlock, MediaBlock, bool, bool?)
Initializes a new instance of the true, the input automatically starts with the main compositor pipeline.
- processingVideoBlock (MediaBlock): Optional processing block for video effects or transformations before bridging.
- processingAudioBlock (MediaBlock): Optional processing block for audio effects or transformations before bridging.
- live (bool): If set to true, treats the file source with live source timing (typically false for files).
- customSyncFlag (bool ?): Optional synchronization flag for controlling file-to-live timing alignment.
## Properties
### AudioID
Gets the audio identifier.
```csharp
public int AudioID { get; }
```
#### Property Value
Parameters:
- (int):
### Rectangle
Gets or sets the rectangle.
This property is ignored if the playback is started.
Use the Input_VideoStream_Update method to update the rectangle during the playback.
```csharp
public Rect Rectangle { get; set; }
```
#### Property Value
Parameters:
- (Rect):
### VideoID
Gets the video identifier.
```csharp
public int VideoID { get; }
```
#### Property Value
Parameters:
- (int):
## Methods
### Build(int, string, int, string)
Builds the file input pipeline using BridgeBufferSinkBlock for video and BridgeAudioSinkBlock for audio.
```csharp
public override void Build(int id, string uniqueName, int id2 = -1, string uniqueName2 = null)
```
#### Parameters
Parameters:
- id (int): The video stream identifier.
- uniqueName (string): The unique name for the video bridge connection.
- id2 (int): The audio stream identifier.
- uniqueName2 (string): The unique name for the audio bridge connection.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetVideoInfo()
Gets the video information.
```csharp
public VideoFrameInfoX GetVideoInfo()
```
#### Returns
Parameters:
- (VideoFrameInfoX): VideoFrameInfoX.
## See Also
---
# Class LVCInput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCInput.html
# Class LVCInput
# Class LVCInput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Base class for Live Video Compositor input sources that feed media content into the composition pipeline.
Each input runs in its own isolated MediaBlocks pipeline and connects to the main compositor via bridge blocks.
This architecture allows for independent control of each input source (start, stop, pause) while maintaining
synchronized output from the main composition pipeline. Supports video-only, audio-only, or combined video/audio inputs.
Implements the // Creating a video input from a camera
var cameraInput = new LVCVideoAudioInput("Camera 1", compositor, cameraSettings);
cameraInput.Rectangle = new Rect(0, 0, 640, 480); // Position in composition
await compositor.Input_AddAsync(cameraInput);
// The input will automatically start with the compositor
await compositor.StartAsync();true, automatically start with the main compositor pipeline.
- processingBlock (MediaBlock): Optional processing block for effects or transformations.
- live (bool): If set to true, indicates this is a live/real-time source.
## Fields
### _bridgeSinkBlock
The bridge sink block that transfers media data from this input pipeline to the main compositor.
```csharp
protected MediaBlock _bridgeSinkBlock
```
#### Field Value
Parameters:
- (MediaBlock):
#### Remarks
Bridge blocks enable cross-pipeline communication, allowing independent pipeline control
while maintaining synchronized media flow.
### _context
The execution context providing logging, error handling, and platform-specific services.
```csharp
protected ContextX _context
```
#### Field Value
Parameters:
- (ContextX):
### _mainBlock
The primary source block that generates or receives the media content for this input.
```csharp
protected MediaBlock _mainBlock
```
#### Field Value
Parameters:
- (MediaBlock):
#### Remarks
This can be a camera source, file source, network stream source, or any other MediaBlock
that implements IMediaBlockSource interface.
### _processingBlock
The optional processing block that can be inserted between the main source block and bridge sink.
```csharp
protected MediaBlock _processingBlock
```
#### Field Value
Parameters:
- (MediaBlock):
#### Remarks
Used for applying effects, filters, or transformations to the input before it reaches the compositor.
Examples include color correction, scaling, deinterlacing, or audio processing.
### disposedValue
Tracks whether the object has been disposed to prevent redundant disposal.
```csharp
protected bool disposedValue
```
#### Field Value
Parameters:
- (bool):
## Properties
### AutoStart
Gets or sets a value indicating whether this input automatically starts when the main compositor starts.
```csharp
public bool AutoStart { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
When false, the input must be started manually using StartAsync() after the compositor starts.
Useful for inputs that should be added dynamically during live production.
### ID
Gets or sets the numeric identifier assigned by the compositor.
```csharp
public int ID { get; }
```
#### Property Value
Parameters:
- (int):
#### Remarks
Assigned internally when the input is added to the compositor.
### MediaType
Gets the type of media this input handles (video, audio, or both).
```csharp
public LVCMediaType MediaType { get; }
```
#### Property Value
Parameters:
- (LVCMediaType):
### Name
Gets the user-friendly name of this input source.
```csharp
public string Name { get; }
```
#### Property Value
Parameters:
- (string):
### Pipeline
Gets the MediaBlocks pipeline that manages this input's processing chain.
```csharp
public MediaBlocksPipeline Pipeline { get; }
```
#### Property Value
Parameters:
- (MediaBlocksPipeline):
#### Remarks
Each input has its own pipeline for isolation and independent control.
### UniqueName
Gets or sets the unique identifier for the primary bridge connection.
```csharp
public string UniqueName { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
This name must be unique across all inputs to ensure proper data routing.
### UniqueName2
Gets or sets the unique identifier for the secondary bridge connection (used for dual-stream inputs).
```csharp
public string UniqueName2 { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
Only used when an input provides both video and audio through separate bridge connections.
## Methods
### Build(int, string, int, string)
Builds the input pipeline by creating and connecting the necessary bridge blocks.
```csharp
public virtual void Build(int id, string uniqueName, int id2 = -1, string uniqueName2 = null)
```
#### Parameters
Parameters:
- id (int): The primary identifier for this input.
- uniqueName (string): The unique name for the primary bridge connection.
- id2 (int): The secondary identifier for dual-stream inputs (default: -1).
- uniqueName2 (string): The unique name for the secondary bridge connection (optional).
#### Remarks
Derived classes must implement this method to set up their specific pipeline configuration,
including bridge connections and any processing blocks.
#### Exceptions
Parameters:
- (NotImplementedException): This base implementation must be overridden in derived classes.
### Dispose(bool)
Releases the unmanaged resources used by the input and optionally releases the managed resources.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
#### Remarks
This method properly disposes of the pipeline, main block, and bridge connections.
Derived classes should override this method to dispose of their specific resources.
### Dispose()
Releases all resources used by the current instance of the true if the input started successfully; otherwise, false.
#### Remarks
For certain source types (UniversalSource, Decklink), this method waits for the pipeline
to fully initialize before returning. This ensures the source is ready before proceeding.
### StopAsync()
Stops the input pipeline and disconnects from the compositor.
```csharp
public Tasktrue if the input stopped successfully; otherwise, false.
#### Remarks
Stopping an input releases its resources and removes it from the composition.
The input can be restarted later if needed.
## See Also
---
# Enum LVCMediaType
Link: api/VisioForge.Core.LiveVideoCompositor.LVCMediaType.html
# Enum LVCMediaType
# Enum LVCMediaType
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Defines the media type for Live Video Compositor inputs and outputs.
This enumeration specifies whether a compositor component handles video only, audio only, or both video and audio streams.
Used to categorize and manage different types of media sources and destinations within the composition pipeline.
```csharp
public enum LVCMediaType
```
## Fields
Parameters:
- Video (): Video-only media type. The input or output handles only video streams and will be connected to video processing components.
- Audio (): Audio-only media type. The input or output handles only audio streams and will be connected to audio processing components.
- VideoAudio (): Combined video and audio media type. The input or output handles both video and audio streams simultaneously,
requiring connections to both video and audio processing pipelines.
## Remarks
The media type determines how the compositor will process and route the associated streams.
For example, VideoAudio inputs will be connected to both video and audio mixers,
while Video-only inputs will only participate in video mixing operations.
---
# Enum LVCMixerType
Link: api/VisioForge.Core.LiveVideoCompositor.LVCMixerType.html
# Enum LVCMixerType
# Enum LVCMixerType
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Defines the mixing technology used by the Live Video Compositor for combining multiple video inputs.
Each mixer type offers different performance characteristics, platform compatibility, and feature sets.
The choice of mixer type affects both processing efficiency and visual quality of the final composition.
```csharp
public enum LVCMixerType
```
## Fields
Parameters:
- CPU (): CPU-based software video mixing. Provides maximum compatibility across all platforms but may have
higher CPU usage and lower performance compared to GPU-accelerated options.
Best for scenarios where GPU acceleration is not available or when maximum compatibility is required.
- OpenGL (): OpenGL-based GPU-accelerated video mixing. Provides good performance and cross-platform compatibility
on systems with OpenGL support. Recommended for most live composition scenarios requiring real-time mixing.
- Switcher (): Input switcher mode that selects one input at a time rather than mixing multiple inputs.
Provides the lowest resource usage and is suitable for simple input switching scenarios
where only one source needs to be active at any given time.
## Remarks
- CPU: Software-based mixing, most compatible but potentially slower
- OpenGL: GPU-accelerated mixing using OpenGL, good performance and cross-platform
- D3D11: Windows-specific GPU acceleration using Direct3D 11, optimal for Windows platforms
- Switcher: Simple input selection without actual mixing, lowest resource usage
---
# Class LVCOutput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCOutput.html
# Class LVCOutput
# Class LVCOutput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Base class for Live Video Compositor output destinations that receive composed media content from the main composition pipeline.
Each output runs in its own isolated MediaBlocks pipeline and connects to the main compositor via bridge blocks.
This architecture allows for independent control of each output destination (start, stop, pause) while receiving
synchronized content from the main composition pipeline. Supports video-only, audio-only, or combined video/audio outputs.
Implements the // Creating a file output for recording
var fileOutput = new LVCVideoAudioOutput("Recording", compositor, fileEncoderBlock);
fileOutput.SetFilenameOrURL("output.mp4");
await compositor.Output_AddAsync(fileOutput);
// The output will automatically start with the compositor
await compositor.StartAsync();true, automatically start with the main compositor pipeline.
## Fields
### _bridgeSourceBlock
The bridge source block that receives media data from the main compositor pipeline.
```csharp
protected MediaBlock _bridgeSourceBlock
```
#### Field Value
Parameters:
- (MediaBlock):
#### Remarks
Bridge blocks enable cross-pipeline communication, allowing independent pipeline control
while maintaining synchronized media flow from the compositor.
### _compositor
Reference to the parent Live Video Compositor that manages this output.
```csharp
protected LiveVideoCompositor _compositor
```
#### Field Value
Parameters:
- (LiveVideoCompositor):
### _context
The execution context providing logging, error handling, and platform-specific services.
```csharp
protected ContextX _context
```
#### Field Value
Parameters:
- (ContextX):
### _mainBlock
The primary sink block that consumes the composed media content.
```csharp
protected MediaBlock _mainBlock
```
#### Field Value
Parameters:
- (MediaBlock):
#### Remarks
This can be a file writer, streaming encoder, display renderer, or any other MediaBlock
that implements IMediaBlockSink interface.
### _mediaType
The type of media this output handles (video, audio, or both).
```csharp
protected LVCMediaType _mediaType
```
#### Field Value
Parameters:
- (LVCMediaType):
### disposedValue
Tracks whether the object has been disposed to prevent redundant disposal.
```csharp
protected bool disposedValue
```
#### Field Value
Parameters:
- (bool):
## Properties
### AutoStart
Gets or sets a value indicating whether this output automatically starts when the main compositor starts.
```csharp
public bool AutoStart { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
When false, the output must be started manually using StartAsync() after the compositor starts.
Useful for outputs that should be activated on-demand during live production.
### Channel
Gets or sets the video channel index from which this output receives content.
```csharp
public int Channel { get; set; }
```
#### Property Value
Parameters:
- (int):
#### Remarks
When the compositor has multiple video channels, this property determines
which channel's output is sent to this destination.
### Name
Gets the user-friendly name of this output destination.
```csharp
public string Name { get; }
```
#### Property Value
Parameters:
- (string):
### Pipeline
Gets the MediaBlocks pipeline that manages this output's processing chain.
```csharp
public MediaBlocksPipeline Pipeline { get; }
```
#### Property Value
Parameters:
- (MediaBlocksPipeline):
#### Remarks
Each output has its own pipeline for isolation and independent control.
## Methods
### Build(string, string)
Builds the output pipeline by creating bridge source blocks and connecting to the main sink.
```csharp
public virtual void Build(string uniqueName, string uniqueName2 = null)
```
#### Parameters
Parameters:
- uniqueName (string): The unique name for the primary bridge connection.
- uniqueName2 (string): The unique name for the secondary bridge connection (optional, for dual-stream outputs).
#### Remarks
This method creates the appropriate bridge source block based on the media type and connects it
to the main sink block. For blocks supporting dynamic inputs, new input pads are created as needed.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when _mediaType is not a valid LVCMediaType value.
### Dispose(bool)
Releases the unmanaged resources used by the output and optionally releases the managed resources.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
#### Remarks
This method properly disposes of the pipeline, main block, and bridge connections.
Derived classes should override this method to dispose of their specific resources.
### Dispose()
Releases all resources used by the current instance of the null if not applicable.
#### Remarks
This method is only valid for outputs that write to files or stream to network destinations.
Display outputs or hardware outputs will return null.
### SetAndConnectMainBlock(MediaBlock)
Sets a new main sink block and connects it to the existing bridge source.
```csharp
protected bool SetAndConnectMainBlock(MediaBlock mainBlock)
```
#### Parameters
Parameters:
- mainBlock (MediaBlock): The new main sink block to connect.
#### Returns
Parameters:
- (bool): true if the block was successfully set and connected; false if the operation failed.
#### Remarks
This method allows changing the output destination dynamically after the pipeline is built.
The bridge source must already exist before calling this method.
### SetFilenameOrURL(string)
Sets the output filename or URL for the main sink block.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The filename for file outputs or URL for streaming outputs.
#### Remarks
For file outputs, provide a local file path. For streaming outputs, provide the destination URL
(e.g., rtmp://server/app/stream). This method only affects blocks that implement IMediaBlockSink.
### StartAsync()
Starts the output pipeline and begins receiving composed media from the compositor.
```csharp
public Tasktrue if the output started successfully; otherwise, false.
#### Remarks
The output will begin processing media as soon as the compositor provides it through the bridge connection.
Ensure the compositor is running before starting outputs to receive media.
### StopAsync(bool)
Stops the output pipeline and finalizes any pending operations.
```csharp
public Tasktrue, the pipeline will be stopped immediately without waiting for proper finalization.
If false (default), the pipeline performs a graceful shutdown using end-of-stream messages.
#### Returns
Parameters:
- (Task < bool >): A task that returns true if the output stopped successfully; otherwise, false.
#### Remarks
For file outputs, using force=true may result in corrupted files or missing frames.
Always use force=false when recording to ensure proper file finalization.
## See Also
---
# Class LVCVideoAudioInput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCVideoAudioInput.html
# Class LVCVideoAudioInput
# Class LVCVideoAudioInput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Live Video Compositor combined video and audio input that feeds synchronized video/audio content into the composition pipeline.
Handles sources with both video and audio streams, maintaining synchronization between streams while providing
independent processing capabilities for video positioning/effects and audio mixing/effects.
This is the most common input type for camera sources, media files, and streaming inputs.
Implements the // Creating a combined video/audio input from a camera
var input = new LVCVideoAudioInput("Camera", compositor, cameraBlock, videoInfo, audioInfo,
new Rect(0, 0, 640, 480), autostart: true);
await compositor.Input_AddAsync(input);true, the input automatically starts with the main compositor pipeline.
- processingVideoBlock (MediaBlock): Optional processing block for video effects or transformations before bridging.
- processingAudioBlock (MediaBlock): Optional processing block for audio effects or transformations before bridging.
- live (bool): If set to true, indicates this is a live/real-time source (affects timing behavior).
- customSyncFlag (bool ?): Optional synchronization flag for controlling video/audio sync behavior in the bridge system.
### LVCVideoAudioInput(string, MediaBlock, VideoFrameInfoX, AudioInfoX, Rect, bool, MediaBlock, MediaBlock, bool, bool?)
Initializes a new instance of the true, the input automatically starts with the main compositor pipeline.
- processingVideoBlock (MediaBlock): Optional processing block for video effects or transformations before bridging.
- processingAudioBlock (MediaBlock): Optional processing block for audio effects or transformations before bridging.
- live (bool): If set to true, indicates this is a live/real-time source (affects timing behavior).
- customSyncFlag (bool ?): Optional synchronization flag for controlling video/audio sync behavior in the bridge system.
## Properties
### AudioID
Gets the audio identifier.
```csharp
public int AudioID { get; }
```
#### Property Value
Parameters:
- (int):
### Rectangle
Gets or sets the rectangle.
This property is ignored if the playback is started.
Use the Input_VideoStream_Update method to update the rectangle during the playback.
```csharp
public Rect Rectangle { get; set; }
```
#### Property Value
Parameters:
- (Rect):
### VideoID
Gets the video identifier.
```csharp
public int VideoID { get; }
```
#### Property Value
Parameters:
- (int):
## Methods
### Build(int, string, int, string)
Builds the input pipeline by connecting source blocks to bridge sinks with optional processing blocks.
```csharp
public override void Build(int id, string uniqueName, int id2 = -1, string uniqueName2 = null)
```
#### Parameters
Parameters:
- id (int): The video stream identifier.
- uniqueName (string): The unique name for the video bridge connection.
- id2 (int): The audio stream identifier.
- uniqueName2 (string): The unique name for the audio bridge connection.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetVideoInfo()
Gets the video information.
```csharp
public VideoFrameInfoX GetVideoInfo()
```
#### Returns
Parameters:
- (VideoFrameInfoX): VideoFrameInfoX.
## See Also
---
# Class LVCVideoAudioOutput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCVideoAudioOutput.html
# Class LVCVideoAudioOutput
# Class LVCVideoAudioOutput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Live Video Compositor combined video and audio output that receives synchronized video/audio content from the main composition pipeline.
Handles destinations requiring both video and audio streams with independent processing capabilities for encoding,
format conversion, and output-specific transformations. This is the most common output type for recording and streaming applications.
Implements the // Creating a combined video/audio output for MP4 recording
var output = new LVCVideoAudioOutput("Recording", compositor, encoderBlock, autostart: true,
videoProcessingBlock, audioProcessingBlock);
await compositor.Output_AddAsync(output);true, the output automatically starts with the main compositor pipeline.
- processingVideoBlock (MediaBlock): Optional processing block for video encoding or format conversion before output.
- processingAudioBlock (MediaBlock): Optional processing block for audio encoding or format conversion before output.
## Methods
### Build(string, string)
Builds the output pipeline by connecting bridge sources to output blocks with optional processing.
```csharp
public override void Build(string uniqueName, string uniqueName2 = null)
```
#### Parameters
Parameters:
- uniqueName (string): The unique name for the video bridge connection.
- uniqueName2 (string): The unique name for the audio bridge connection.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
## See Also
---
# Class LVCVideoInput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCVideoInput.html
# Class LVCVideoInput
# Class LVCVideoInput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Live Video Compositor video input that feeds video content into the composition pipeline.
Handles video-only sources with positioning, scaling, and transformation capabilities within the composition canvas.
Each video input maintains its own rectangle position, resize policy, and optional processing chain for effects or transformations.
Implements the // Creating a video input with custom positioning
var videoInput = new LVCVideoInput("Camera 1", compositor, sourceBlock, videoInfo,
new Rect(100, 100, 640, 480), autostart: true);
videoInput.ResizePolicy = LVCResizePolicy.LetterBox;
await compositor.Input_AddAsync(videoInput);true, automatically starts the input when added to compositor.
- processingBlock (MediaBlock): The optional processing block for video effects or transformations.
### LVCVideoInput(string, MediaBlock, VideoFrameInfoX, Rect, bool, MediaBlock)
Initializes a new instance of the true, automatically starts the input when added to compositor.
- processingBlock (MediaBlock): The optional processing block for video effects or transformations.
## Properties
### Rectangle
Gets or sets the rectangle position and size for this video input within the composition canvas.
This property is ignored if the playback is started.
Use the Input_VideoStream_Update method to update the rectangle during the playback.
```csharp
public Rect Rectangle { get; set; }
```
#### Property Value
Parameters:
- (Rect):
### ResizePolicy
Gets or sets the resize policy that determines how the video input is scaled to fit its rectangle.
```csharp
public LVCResizePolicy ResizePolicy { get; set; }
```
#### Property Value
Parameters:
- (LVCResizePolicy):
## Methods
### Build(int, string, int, string)
Builds the video input pipeline by creating bridge connections and linking media blocks.
```csharp
public override void Build(int id, string uniqueName, int id2 = -1, string uniqueName2 = null)
```
#### Parameters
Parameters:
- id (int): The primary identifier for this input.
- uniqueName (string): The unique name for the bridge connection.
- id2 (int): The secondary identifier (optional, default is -1).
- uniqueName2 (string): The secondary unique name (optional).
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when media type is invalid.
### GetVideoInfo()
Gets the video frame information.
```csharp
public VideoFrameInfoX GetVideoInfo()
```
#### Returns
Parameters:
- (VideoFrameInfoX): The video frame info.
## See Also
---
# Class LVCVideoOutput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCVideoOutput.html
# Class LVCVideoOutput
# Class LVCVideoOutput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Live Video Compositor video output that receives composed video content from the main composition pipeline.
Handles video-only destinations including file encoders, streaming outputs, preview displays, and hardware outputs.
Each video output maintains its own processing pipeline with optional video processing blocks for encoding or transformation.
Implements the // Creating a video output for file recording
var videoOutput = new LVCVideoOutput("Recording", compositor, fileEncoderBlock, autostart: true);
await compositor.Output_AddAsync(videoOutput);true, automatically starts with the main pipeline.
- processingVideoBlock (MediaBlock): The optional processing video block for encoding or format conversion.
## Methods
### Build(string, string)
Builds the video output pipeline by creating bridge source and connecting media blocks.
```csharp
public override void Build(string uniqueName, string uniqueName2 = null)
```
#### Parameters
Parameters:
- uniqueName (string): The unique name for the primary bridge connection.
- uniqueName2 (string): The unique name for the secondary bridge connection (optional).
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when media type is invalid.
## See Also
---
# Class LVCVideoViewOutput
Link: api/VisioForge.Core.LiveVideoCompositor.LVCVideoViewOutput.html
# Class LVCVideoViewOutput
# Class LVCVideoViewOutput
**Namespace**: VisioForge.Core.LiveVideoCompositor
**Assembly**: VisioForge.Core.dll
Represents a video output destination for the Live Video Compositor that renders to a video view control.
This class provides functionality to display composited video content directly in UI controls
through the IVideoView interface, enabling real-time preview and monitoring capabilities.
Implements the true, the output will automatically start with the main pipeline. If false, manual start is required.
- processingVideoBlock (MediaBlock): Optional media block for additional video processing before rendering (e.g., filters, effects). Pass null for direct rendering.
## See Also
---
# Namespace VisioForge.Core.LiveVideoCompositor
Link: api/VisioForge.Core.LiveVideoCompositor.html
# Namespace VisioForge.Core.LiveVideoCompositor
# Namespace VisioForge.Core.LiveVideoCompositor
### Classes
Parameters:
- (): Live Video Compositor audio input that feeds audio content into the composition pipeline.
Handles audio-only sources with format conversion, mixing, and processing capabilities within the audio composition.
Each audio input maintains its own audio format specification and optional processing chain for effects or transformations.
Implements the // Example of setting the license key for the Live Video Compositor.
// This should typically be done once at application startup.
var compositor = new LiveVideoCompositor();
compositor.SetLicenseKey("YOUR_LICENSE_KEY", "Your Name", "your.email@example.com");
// After setting the license key, the SDK's features will be enabled according to the license level.// Creating a high-performance 4K live compositor
var settings = new LiveVideoCompositorSettings(3840, 2160, new VideoFrameRate(60, 1))
{
MixerType = LVCMixerType.OpenGL,
VideoChannelCount = 4,
MaxVideoInputsCount = 8,
MaxVideoOutputsCount = 4
};
var compositor = new LiveVideoCompositor(context, settings);
await compositor.StartAsync();var settings = new LiveVideoCompositorSettings(1920, 1080, new VideoFrameRate(30, 1))
{
MixerType = LVCMixerType.OpenGL,
AudioEnabled = true
};
var compositor = new LiveVideoCompositor(settings);true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
This is the public synchronous Dispose method, implementing the null if audio is disabled.
#### Remarks
The audio mixer combines all audio inputs into a single output stream.
It is only created if AudioEnabled is true in the settings.
### GetContext()
Gets the context object for this compositor.
```csharp
public ContextX GetContext()
```
#### Returns
Parameters:
- (ContextX): The true if the input was added successfully; otherwise, false.
#### Remarks
This method can be called before or after the compositor is started. If called after startup,
the input is dynamically added to the running pipeline. The input's AutoStart property determines
whether it begins processing immediately. Each input is assigned a unique ID for bridge connections.
#### Exceptions
Parameters:
- (InvalidOperationException): May occur if the maximum number of inputs is exceeded.
### Input_AddAsync(LVCAudioInput)
Adds an audio-only input to the compositor.
```csharp
public Tasktrue if the input was added successfully; otherwise, false.
#### Remarks
This method requires audio to be enabled in the compositor settings. Like video inputs,
audio inputs can be added dynamically during playback. Each input is assigned a unique ID
for bridge connections and mixed into the main audio output.
#### Exceptions
Parameters:
- (InvalidOperationException): Thrown when audio is disabled in compositor settings.
### Input_AddAsync(LVCVideoAudioInput, bool)
Adds a combined video and audio input to the compositor.
```csharp
public Tasktrue, starts the input after adding; otherwise uses the input's AutoStart property. Default is false.
#### Returns
Parameters:
- (Task < bool >): A true if the input was added successfully; otherwise, false.
#### Remarks
This method handles inputs that provide both video and audio streams. The video and audio
components are processed separately but remain synchronized. Special handling is provided
for file sources to ensure proper preloading when added to a running compositor.
Both video and audio IDs are assigned from their respective pools.
### Input_Count()
Gets the total number of inputs currently added to the compositor.
```csharp
public int Input_Count()
```
#### Returns
Parameters:
- (int): The number of inputs of all types (video, audio, and combined).
#### Remarks
This count includes all input types regardless of their current state (playing, paused, or stopped).
### Input_Get(int)
Gets an input by its index in the input list.
```csharp
public LVCInput Input_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input.
#### Returns
Parameters:
- (LVCInput): The null if the index is out of range.
#### Remarks
This method returns the base input type. Cast the result to the specific input type
(LVCVideoInput, LVCAudioInput, or LVCVideoAudioInput) as needed.
### Input_Get(Guid)
Gets an input by its unique identifier.
```csharp
public LVCInput Input_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the input.
#### Returns
Parameters:
- (LVCInput): The null if not found.
#### Remarks
This is the preferred method for retrieving inputs as IDs are guaranteed to be unique
and stable throughout the input's lifetime. The returned base type can be cast to the
specific input type as needed.
### Input_GetID(string)
Gets the unique identifier of an input by its name.
```csharp
public Guid? Input_GetID(string name)
```
#### Parameters
Parameters:
- name (string): The name of the input to find.
#### Returns
Parameters:
- (Guid ?): The null if no input with the specified name exists.
#### Remarks
Input names are not required to be unique, so this method returns the first match found.
For reliable identification, use the input's ID directly.
### Input_GetName(Guid)
Gets the name of an input by its unique identifier.
```csharp
public string Input_GetName(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the input.
#### Returns
Parameters:
- (string): The name of the input if found; null if no input with the specified ID exists.
#### Remarks
This method is useful for displaying input information in user interfaces or logs.
### Input_RemoveAsync(Guid)
Removes an input from the compositor by its unique ID.
```csharp
public Tasktrue if the input was removed successfully; otherwise, false.
#### Remarks
This method can be called during playback to dynamically remove inputs. It properly:
- Stops the input pipeline
- Blocks and removes mixer pads
- Cleans up bridge connections
- Releases IDs back to the pool for reuse
- Disposes of all resources
The removal is performed safely without interrupting other inputs or the main pipeline.
### Input_VideoAudio_Get(int)
Gets a video/audio input by its index in the input list.
```csharp
public LVCVideoAudioInput Input_VideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the input.
#### Returns
Parameters:
- (LVCVideoAudioInput): The null if the index is out of range or the input is not a video/audio type.
#### Remarks
This method performs type checking and will return null if the input at the specified
index is not a combined video/audio input.
### Input_VideoAudio_Get(Guid)
Gets a video/audio input by its unique identifier.
```csharp
public LVCVideoAudioInput Input_VideoAudio_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the input.
#### Returns
Parameters:
- (LVCVideoAudioInput): The null if not found or the input is not a video/audio type.
#### Remarks
This is the preferred method for retrieving inputs as IDs are guaranteed to be unique
and stable throughout the input's lifetime.
### Input_VideoStream_Get(LVCInput)
Gets the video mixer stream configuration for a specific input.
```csharp
public VideoMixerStream Input_VideoStream_Get(LVCInput input)
```
#### Parameters
Parameters:
- input (LVCInput): The input to get the stream for.
#### Returns
Parameters:
- (VideoMixerStream): The null if the input is not found or the video mixer is not initialized.
#### Remarks
Use this method to retrieve the current configuration of a video input stream,
which can then be modified and updated using Input_VideoStream_Update().
### Input_VideoStream_Update(VideoMixerStream)
Updates the configuration of a video input stream in the mixer.
```csharp
public void Input_VideoStream_Update(VideoMixerStream stream)
```
#### Parameters
Parameters:
- stream (VideoMixerStream): The stream configuration to update.
#### Examples
var stream = compositor.Input_VideoStream_Get(input);
if (stream != null)
{
stream.Alpha = 0.5; // Set 50% transparency
stream.Rectangle = new Rect(100, 100, 640, 480); // Reposition
compositor.Input_VideoStream_Update(stream);
}true, starts the output immediately; otherwise, it must be started manually. Default is false.
#### Returns
Parameters:
- (Task < bool >): A true if the output was added successfully; otherwise, false.
#### Remarks
This method can be called before or after the compositor is started. If called after startup,
the output is dynamically added to the running pipeline using a tee element. The start parameter
overrides the output's AutoStart property for immediate activation.
### Output_AddAsync(LVCAudioOutput, bool)
Adds an audio-only output to the compositor.
```csharp
public Tasktrue, starts the output immediately; otherwise, it must be started manually. Default is false.
#### Returns
Parameters:
- (Task < bool >): A true if the output was added successfully; otherwise, false.
#### Remarks
Audio outputs receive the mixed audio from all audio inputs. Multiple audio outputs can be
active simultaneously, each receiving the same audio mix. This is useful for recording
while streaming or monitoring.
### Output_AddAsync(LVCVideoAudioOutput, bool)
Adds a combined video and audio output to the compositor.
```csharp
public Tasktrue, starts the output immediately; otherwise, it must be started manually. Default is false.
#### Returns
Parameters:
- (Task < bool >): A true if the output was added successfully; otherwise, false.
#### Remarks
This method creates separate bridge connections for video and audio streams to the output.
Both streams remain synchronized through the output pipeline. Common uses include recording
files with both video and audio or streaming to services that require both components.
### Output_Audio_Get(int)
Gets an audio output by its index in the output list.
```csharp
public LVCAudioOutput Output_Audio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCAudioOutput): The null if the index is out of range or the output is not an audio-only type.
#### Remarks
This method performs type checking and will return null if the output at the specified
index is not an audio-only output.
### Output_Audio_Get(Guid)
Gets an audio output by its unique identifier.
```csharp
public LVCAudioOutput Output_Audio_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the output.
#### Returns
Parameters:
- (LVCAudioOutput): The null if not found or the output is not an audio-only type.
#### Remarks
This is the preferred method for retrieving outputs as IDs are guaranteed to be unique
and stable throughout the output's lifetime.
### Output_Count()
Gets the total number of outputs currently added to the compositor.
```csharp
public int Output_Count()
```
#### Returns
Parameters:
- (int): The number of outputs of all types (video, audio, and combined).
#### Remarks
This count includes all output types regardless of their current state (active or inactive).
### Output_Get(int)
Gets an output by its index in the output list.
```csharp
public LVCOutput Output_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCOutput): The null if the index is out of range.
#### Remarks
This method returns the base output type. Cast the result to the specific output type
(LVCVideoOutput, LVCAudioOutput, or LVCVideoAudioOutput) as needed.
### Output_Get(Guid)
Gets an output by its unique identifier.
```csharp
public LVCOutput Output_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the output.
#### Returns
Parameters:
- (LVCOutput): The null if not found.
#### Remarks
This is the preferred method for retrieving outputs as IDs are guaranteed to be unique
and stable throughout the output's lifetime. The returned base type can be cast to the
specific output type as needed.
### Output_Get(string)
Gets an output by its name.
```csharp
[Obsolete("Use Output_Get(Guid id) instead for better performance and unique identification.")]
public LVCOutput Output_Get(string name)
```
#### Parameters
Parameters:
- name (string): The name of the output to find.
#### Returns
Parameters:
- (LVCOutput): The first null if no output with the specified name exists.
#### Remarks
Output names are not required to be unique, so this method returns the first match found.
This method is obsolete and may be removed in future versions.
### Output_GetID(string)
Gets the unique identifier of an output by its name.
```csharp
public Guid? Output_GetID(string name)
```
#### Parameters
Parameters:
- name (string): The name of the output to find.
#### Returns
Parameters:
- (Guid ?): The null if no output with the specified name exists.
#### Remarks
Output names are not required to be unique, so this method returns the first match found.
For reliable identification, use the output's ID directly.
### Output_GetName(Guid)
Gets the name of an output by its unique identifier.
```csharp
public string Output_GetName(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the output.
#### Returns
Parameters:
- (string): The name of the output if found; null if no output with the specified ID exists.
#### Remarks
This method is useful for displaying output information in user interfaces or logs.
### Output_RemoveAsync(Guid)
Removes an output from the compositor by its unique ID.
```csharp
public Tasktrue if the output was removed successfully; otherwise, false.
#### Remarks
This method stops the output pipeline gracefully and removes it from the compositor.
For file outputs, this ensures proper file finalization. The output is disposed after removal.
### Output_VideoAudio_Get(int)
Gets a video/audio output by its index in the output list.
```csharp
public LVCVideoAudioOutput Output_VideoAudio_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCVideoAudioOutput): The null if the index is out of range or the output is not a video/audio type.
#### Remarks
This method performs type checking and will return null if the output at the specified
index is not a combined video/audio output.
### Output_VideoAudio_Get(Guid)
Gets a video/audio output by its unique identifier.
```csharp
public LVCVideoAudioOutput Output_VideoAudio_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the output.
#### Returns
Parameters:
- (LVCVideoAudioOutput): The null if not found or the output is not a video/audio type.
#### Remarks
This is the preferred method for retrieving outputs as IDs are guaranteed to be unique
and stable throughout the output's lifetime.
### Output_Video_Get(int)
Gets a video output by its index in the output list.
```csharp
public LVCVideoOutput Output_Video_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the output.
#### Returns
Parameters:
- (LVCVideoOutput): The null if the index is out of range or the output is not a video-only type.
#### Remarks
This method performs type checking and will return null if the output at the specified
index is not a video-only output.
### Output_Video_Get(Guid)
Gets a video output by its unique identifier.
```csharp
public LVCVideoOutput Output_Video_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique identifier of the output.
#### Returns
Parameters:
- (LVCVideoOutput): The null if not found or the output is not a video-only type.
#### Remarks
This is the preferred method for retrieving outputs as IDs are guaranteed to be unique
and stable throughout the output's lifetime.
### SetLicenseKey(string, string, string)
Sets the license key for the Live Video Compositor SDK.
```csharp
public void SetLicenseKey(string licenseKey, string userName, string email)
```
#### Parameters
Parameters:
- licenseKey (string): The unique license key provided by VisioForge.
- userName (string): The name of the user or organization associated with the license.
- email (string): The email address associated with the license.
### StartAsync()
Starts the compositor and all configured inputs and outputs.
```csharp
public Tasktrue if startup was successful; otherwise, false.
#### Examples
var compositor = new LiveVideoCompositor(settings);
// Add inputs and outputs...
if (await compositor.StartAsync())
{
Console.WriteLine("Compositor started successfully");
}null.
#### Remarks
Use this method to retrieve an effect instance for modification or inspection.
If the video effect manager is not initialized, this method will return null.
### Video_Effects_RemoveAsync(BaseVideoEffect, int)
Removes a video effect from the compositor output.
```csharp
public Task Video_Effects_RemoveAsync(BaseVideoEffect effect, int channel = 0)
```
#### Parameters
Parameters:
- effect (BaseVideoEffect): The video effect instance to remove.
- channel (int): The channel to remove the effect from. This parameter is reserved for future use and currently has no effect. Default is 0.
#### Returns
Parameters:
- (Task): A true, the input will start automatically when added to the compositor.
- processingBlock (MediaBlock): Optional processing block for audio effects or transformations.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when info parameter is null.
## Properties
### Info
Gets the audio information containing format details such as sample rate, channels, and audio format.
```csharp
public AudioInfoX Info { get; }
```
#### Property Value
Parameters:
- (AudioInfoX):
## Methods
### UpdateInfo(AudioInfoX)
Updates the audio information for this input with new format specifications.
```csharp
public void UpdateInfo(AudioInfoX info)
```
#### Parameters
Parameters:
- info (AudioInfoX): The new audio information containing updated format, channels, or sample rate.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when info parameter is null.
## See Also
---
# Class LVCAudioOutput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCAudioOutput.html
# Class LVCAudioOutput
# Class LVCAudioOutput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Represents an audio output for the Live Video Compositor that can receive and render audio streams.
This class provides functionality to connect audio sinks and output devices to the compositor pipeline.
Implements the true, the output will start automatically with the main pipeline.
## See Also
---
# Class LVCInput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCInput.html
# Class LVCInput
# Class LVCInput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Base class for all Live Video Compositor input sources.
```csharp
public class LVCInput : IDisposable
```
#### Inheritance
#### Derived
#### Implements
#### Inherited Members
## Remarks
This abstract base class provides the common functionality for all input types in the Live Video Compositor.
It manages the input pipeline, bridge connections, and lifecycle operations. Derived classes implement
specific input types such as video-only, audio-only, or combined video/audio inputs.
Each input maintains its own pipeline for processing before sending data to the main compositor.
## Constructors
### LVCInput(string, LiveVideoCompositor, MediaBlock, LVCMediaType, bool, MediaBlock, bool)
Initializes a new instance of the null if adding later.
- mainBlock (MediaBlock): The source block that provides the media stream.
- mediaType (LVCMediaType): The type of media this input provides (video, audio, or both).
- autostart (bool): If true, starts automatically when the compositor starts.
- processingBlock (MediaBlock): Optional processing block for applying effects. Default is null.
- live (bool): If true, indicates a live source requiring real-time processing. Default is true.
#### Remarks
This protected constructor is called by derived classes to initialize the base input functionality.
It creates a separate pipeline for this input and configures clock synchronization.
## Fields
### _bridgeSinkBlock
The bridge sink block.
```csharp
protected MediaBlock _bridgeSinkBlock
```
#### Field Value
Parameters:
- (MediaBlock):
### _compositor
Reference to the parent Live Video Compositor that manages this input.
```csharp
protected LiveVideoCompositor _compositor
```
#### Field Value
Parameters:
- (LiveVideoCompositor):
### _context
The execution context providing logging, error handling, and platform-specific services.
```csharp
protected ContextX _context
```
#### Field Value
Parameters:
- (ContextX):
### _processingBlock
The processing block (optional).
```csharp
protected MediaBlock _processingBlock
```
#### Field Value
Parameters:
- (MediaBlock):
### disposedValue
The disposed value.
```csharp
protected bool disposedValue
```
#### Field Value
Parameters:
- (bool):
## Properties
### AutoStart
Gets or sets a value indicating whether this input starts automatically with the main compositor.
```csharp
public bool AutoStart { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
When set to true, this input will begin processing as soon as the compositor starts.
When false, the input must be started manually using StartAsync() or ResumeAsync().
### ID
Gets the unique identifier for this input.
```csharp
public Guid ID { get; }
```
#### Property Value
Parameters:
- (Guid):
#### Remarks
This ID is generated automatically when the input is created and remains constant
throughout the input's lifetime. Use this for reliable input identification.
### IsSeekable
Gets a value indicating whether this input supports seeking operations.
```csharp
public bool IsSeekable { get; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
Seekability is determined by the main block type. File-based sources typically support seeking,
while live sources (cameras, network streams) typically do not.
### MainBlock
Gets or sets the main source block that provides media data for this input.
```csharp
public MediaBlock MainBlock { get; }
```
#### Property Value
Parameters:
- (MediaBlock):
#### Remarks
This is typically a source block such as UniversalSourceBlock, DecklinkVideoSourceBlock,
or other media source implementations. The block type determines the input's capabilities
and whether it supports seeking.
### MediaType
Gets the type of media this input provides.
```csharp
public LVCMediaType MediaType { get; }
```
#### Property Value
Parameters:
- (LVCMediaType):
### Name
Gets the descriptive name of this input.
```csharp
public string Name { get; }
```
#### Property Value
Parameters:
- (string):
### Pipeline
Gets the media processing pipeline for this input.
```csharp
public MediaBlocksPipeline Pipeline { get; }
```
#### Property Value
Parameters:
- (MediaBlocksPipeline):
#### Remarks
Each input maintains its own pipeline separate from the main compositor pipeline.
This allows independent control over playback state and processing.
### UniqueName
Gets or sets the unique bridge identifier for the primary media stream.
```csharp
public string UniqueName { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
This internal identifier is used by the bridge system to connect this input's
pipeline to the main compositor pipeline. It is set automatically during the build process.
### UniqueName2
Gets or sets the unique bridge identifier for the secondary media stream.
```csharp
public string UniqueName2 { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
This internal identifier is used when an input provides both video and audio streams,
requiring separate bridge connections. It is set automatically during the build process.
## Methods
### Dispose(bool)
Releases the unmanaged and optionally managed resources used by this input.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources;
false to release only unmanaged resources.
#### Remarks
This method disposes of the main block, pipeline, and bridge sink block if they exist.
Derived classes should override this method to dispose of their specific resources,
ensuring to call the base implementation.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting resources.
```csharp
public void Dispose()
```
#### Remarks
Call this method when you are finished using the input. This method calls Dispose(true)
and suppresses finalization to improve performance.
### ~LVCInput()
Finalizes an instance of the true, only preloads the pipeline without starting playback. Default is false.
#### Returns
Parameters:
- (Task < bool >): A true if the start was successful; otherwise, false.
#### Remarks
For certain source types (UniversalSourceBlock, DecklinkVideoSourceBlock), this method waits for
the pipeline to reach a ready state before returning. This ensures proper initialization of
complex sources. The preloadOnly parameter is useful for preparing inputs without immediately
starting playback.
### StopAsync()
Stops this input's pipeline and releases processing resources.
```csharp
public Tasktrue if the stop was successful; otherwise, false.
#### Remarks
This method performs a forced stop of the pipeline to ensure quick shutdown.
After stopping, the input would need to be restarted using StartAsync() to resume processing.
## See Also
---
# Enum LVCMediaType
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCMediaType.html
# Enum LVCMediaType
# Enum LVCMediaType
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Defines the media types supported by the Live Video Compositor for input and output streams.
```csharp
public enum LVCMediaType
```
## Fields
Parameters:
- Video (): Video-only media stream without audio.
- Audio (): Audio-only media stream without video.
- VideoAudio (): Combined video and audio media stream.
---
# Enum LVCMixerType
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCMixerType.html
# Enum LVCMixerType
# Enum LVCMixerType
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Defines the rendering backend types available for video mixing in the Live Video Compositor.
Different backends offer various performance characteristics and platform compatibility.
```csharp
public enum LVCMixerType
```
## Fields
Parameters:
- CPU (): Software-based CPU rendering for maximum compatibility but lower performance.
- OpenGL (): Hardware-accelerated rendering using OpenGL for cross-platform GPU acceleration.
---
# Class LVCOutput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCOutput.html
# Class LVCOutput
# Class LVCOutput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Base class for all Live Video Compositor output destinations.
```csharp
public class LVCOutput : IDisposable
```
#### Inheritance
#### Derived
#### Implements
#### Inherited Members
## Remarks
This class provides the common functionality for all output types in the Live Video Compositor.
It manages the output pipeline, bridge connections from the main compositor, and lifecycle operations.
Derived classes implement specific output types such as video files, streams, or display outputs.
Each output maintains its own pipeline separate from the main compositor for independent control.
## Constructors
### LVCOutput(string, LiveVideoCompositor, MediaBlock, LVCMediaType, bool)
Initializes a new instance of the true, starts automatically when the compositor starts.
#### Remarks
This constructor initializes the output pipeline and configures clock synchronization
with the main compositor. The main block typically represents a file sink, stream sink,
or display renderer.
## Fields
### _bridgeSourceBlock
The bridge source block.
```csharp
protected MediaBlock _bridgeSourceBlock
```
#### Field Value
Parameters:
- (MediaBlock):
### _compositor
Reference to the parent Live Video Compositor that manages this output.
```csharp
protected LiveVideoCompositor _compositor
```
#### Field Value
Parameters:
- (LiveVideoCompositor):
### _context
The execution context providing logging, error handling, and platform-specific services.
```csharp
protected ContextX _context
```
#### Field Value
Parameters:
- (ContextX):
### _mainBlock
The primary sink block that receives and processes the output media stream.
```csharp
protected MediaBlock _mainBlock
```
#### Field Value
Parameters:
- (MediaBlock):
### _mediaType
The type of media (video, audio, or both) handled by this output.
```csharp
protected LVCMediaType _mediaType
```
#### Field Value
Parameters:
- (LVCMediaType):
### disposedValue
The disposed value.
```csharp
protected bool disposedValue
```
#### Field Value
Parameters:
- (bool):
## Properties
### AutoStart
Gets or sets a value indicating whether this output starts automatically with the main compositor.
```csharp
public bool AutoStart { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
When set to true, this output will begin processing as soon as the compositor starts.
When false, the output must be started manually using StartAsync(). This is useful for
outputs that should be activated on-demand, such as recording outputs.
### ID
Gets the unique identifier for this output.
```csharp
public Guid ID { get; }
```
#### Property Value
Parameters:
- (Guid):
#### Remarks
This ID is generated automatically when the output is created and remains constant
throughout the output's lifetime. Use this for reliable output identification instead of names.
### Name
Gets the descriptive name of this output.
```csharp
public string Name { get; }
```
#### Property Value
Parameters:
- (string):
### Pipeline
Gets the media processing pipeline for this output.
```csharp
public MediaBlocksPipeline Pipeline { get; }
```
#### Property Value
Parameters:
- (MediaBlocksPipeline):
#### Remarks
Each output maintains its own pipeline separate from the main compositor pipeline,
allowing independent control over recording, streaming, or display operations.
## Methods
### Build(string, string)
Builds the internal pipeline structure for this output.
```csharp
public virtual void Build(string uniqueName, string uniqueName2 = null)
```
#### Parameters
Parameters:
- uniqueName (string): The unique bridge identifier for the primary stream (video or audio).
- uniqueName2 (string): The unique bridge identifier for the secondary stream (used for video/audio outputs).
#### Remarks
This virtual method creates the bridge source blocks that receive data from the main compositor
and connects them to the output's main block. It can be overridden by derived classes for
custom pipeline configurations. The method handles dynamic input creation for blocks that support it.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when the media type is not recognized.
### Dispose(bool)
Releases the unmanaged and optionally managed resources used by this output.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources;
false to release only unmanaged resources.
#### Remarks
This method disposes of the main block, pipeline, and bridge source block if they exist.
Derived classes should override this method to dispose of their specific resources,
ensuring to call the base implementation.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting resources.
```csharp
public void Dispose()
```
#### Remarks
Call this method when you are finished using the output. This method ensures proper
cleanup of all resources and should be called before removing the output from the compositor.
### ~LVCOutput()
Finalizes an instance of the null.
#### Remarks
This method delegates to the main block's implementation of IMediaBlockSink.
It's typically used for file or stream outputs to retrieve the destination path or URL.
### SetAndConnectMainBlock(MediaBlock)
Sets a new main block and connects it to the existing bridge source.
```csharp
protected bool SetAndConnectMainBlock(MediaBlock mainBlock)
```
#### Parameters
Parameters:
- mainBlock (MediaBlock): The new sink block to use as the main output destination.
#### Returns
Parameters:
- (bool): true if the connection was successful; false if the block is null or connection failed.
#### Remarks
This protected method allows derived classes to change the output destination dynamically.
The bridge source must already be created before calling this method.
### SetFilenameOrURL(string)
Sets the filename or URL for this output.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The filename or URL to set as the output destination.
#### Remarks
This method delegates to the main block's implementation of IMediaBlockSink.
It's typically used for file or stream outputs to set the destination path or URL.
The actual behavior depends on the specific sink implementation in the main block.
### StartAsync()
Starts this output's pipeline and begins processing media from the compositor.
```csharp
public Tasktrue if the start was successful; otherwise, false.
#### Remarks
This method should be called after the output has been added to the compositor.
If AutoStart is true, this method is called automatically when the compositor starts.
### StopAsync(bool)
Stops this output's pipeline and finalizes any pending operations.
```csharp
public Tasktrue, forces immediate pipeline shutdown without waiting for pending data.
If false, performs a graceful shutdown using end-of-stream messages.
Default is false.
#### Returns
Parameters:
- (Task < bool >): A true if the stop was successful; otherwise, false.
#### Remarks
For file outputs, using force=true may result in incomplete files or corrupted endings.
Always use force=false (default) for file outputs to ensure proper finalization.
For display or streaming outputs, force=true can be used for immediate shutdown.
## See Also
---
# Enum LVCResizePolicy
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCResizePolicy.html
# Enum LVCResizePolicy
# Enum LVCResizePolicy
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Defines the resize policy options for video inputs in the Live Video Compositor.
```csharp
public enum LVCResizePolicy
```
## Fields
Parameters:
- Letterbox (): Scales the video to fit within the target rectangle while maintaining the original aspect ratio.
Black bars (letterboxing or pillarboxing) are added as needed to fill the remaining space.
This mode ensures the entire source video is visible without any cropping. If the aspect ratios
of source and target don't match, black bars will appear either on the sides (pillarboxing)
or top/bottom (letterboxing) of the video.
- Stretch (): Stretches the video to completely fill the target rectangle, ignoring the original aspect ratio.
This mode may cause visual distortion if the source and target aspect ratios differ significantly.
Use this mode when you need to fill the exact rectangle dimensions and aspect ratio preservation
is not important.
- LetterboxToFill (): Scales the video to fill the entire target rectangle while maintaining the original aspect ratio.
Parts of the video may be cropped to achieve this.
This mode ensures no black bars appear, but may crop portions of the source video to maintain
the aspect ratio. The video is centered in the target rectangle, with equal amounts cropped
from opposite sides when necessary. Also known as "zoom to fill" or "crop to fit".
## Remarks
This enumeration controls how video inputs are scaled and positioned within their designated
rectangle in the compositor. Each policy offers different trade-offs between preserving
aspect ratio and filling the available space.
---
# Class LVCVideoAudioInput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCVideoAudioInput.html
# Class LVCVideoAudioInput
# Class LVCVideoAudioInput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Represents a combined video and audio input source for the Live Video Compositor.
```csharp
public class LVCVideoAudioInput : LVCInput, IDisposable
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
This class handles input streams that contain both video and audio components.
It provides separate processing pipelines for video and audio, allowing independent
effects and transformations on each stream while maintaining synchronization.
Like video-only inputs, it supports positioning, resize policies, and preview rendering.
## Constructors
### LVCVideoAudioInput(string, LiveVideoCompositor, MediaBlock, VideoFrameInfoX, AudioInfoX, Rect, bool, MediaBlock, MediaBlock, bool, bool?)
Initializes a new instance of the null if video is disabled.
- audioInfo (AudioInfoX): The audio information. Format, channels, and sample rate are required. Can be null if audio is disabled.
- rect (Rect): The position and size of the video component within the compositor output.
- autostart (bool): If true, the input will start automatically when the compositor starts.
- processingVideoBlock (MediaBlock): An optional processing block for the video stream. Default is null.
- processingAudioBlock (MediaBlock): An optional processing block for the audio stream. Default is null.
- live (bool): If true, indicates this is a live source requiring real-time processing. Default is true.
- customSyncFlag (bool ?): Optional custom synchronization flag for advanced timing control. Default is null.
### LVCVideoAudioInput(string, MediaBlock, VideoFrameInfoX, AudioInfoX, Rect, bool, MediaBlock, MediaBlock, bool, bool?)
Initializes a new instance of the null if video is disabled.
- audioInfo (AudioInfoX): The audio information. Format, channels, and sample rate are required. Can be null if audio is disabled.
- rect (Rect): The position and size of the video component within the compositor output.
- autostart (bool): If true, the input will start automatically when added to a compositor.
- processingVideoBlock (MediaBlock): An optional processing block for the video stream. Default is null.
- processingAudioBlock (MediaBlock): An optional processing block for the audio stream. Default is null.
- live (bool): If true, indicates this is a live source requiring real-time processing. Default is true.
- customSyncFlag (bool ?): Optional custom synchronization flag for advanced timing control. Default is null.
#### Remarks
This constructor is typically used when creating inputs that will be added to a compositor later.
## Properties
### AudioInfo
Gets the audio stream information for this input.
```csharp
public AudioInfoX AudioInfo { get; }
```
#### Property Value
Parameters:
- (AudioInfoX):
### ProcessingVideoBlocks
Gets the list of video processing blocks applied to the video stream.
```csharp
public Listtrue to release both managed and unmanaged resources;
false to release only unmanaged resources.
#### Remarks
This method properly disposes of both video and audio bridge sinks, as well as any
preview components that were created. It ensures all resources are cleaned up in the
correct order before calling the base class disposal logic.
### ResumeAsync()
Resumes playback of this input after it has been paused.
```csharp
public override Task ResumeAsync()
```
#### Returns
Parameters:
- (Task): A true, the output will automatically start with the main pipeline; otherwise, manual start is required.
- processingVideoBlock (MediaBlock): An optional video processing block to apply effects or transformations to the video stream before output. Default is null.
- processingAudioBlock (MediaBlock): An optional audio processing block to apply effects or transformations to the audio stream before output. Default is null.
## Methods
### Build(string, string)
Builds the output pipeline by creating bridge sources for video and audio
and connecting them to the main output block through optional processing blocks.
```csharp
public override void Build(string uniqueName, string uniqueName2 = null)
```
#### Parameters
Parameters:
- uniqueName (string): The unique identifier for the video bridge source.
- uniqueName2 (string): The unique identifier for the audio bridge source. If not provided, defaults to null.
#### Remarks
This method creates the necessary bridge sources based on the compositor's settings,
connects optional processing blocks if provided, and establishes the complete
pipeline from bridge sources to the main output block. The method handles
dynamic input creation for blocks that support it.
### Dispose(bool)
Releases unmanaged and optionally managed resources used by this output.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
#### Remarks
This method properly disposes of the bridge source blocks for both video and audio
to prevent memory leaks and ensure proper cleanup of resources.
## See Also
---
# Class LVCVideoInput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCVideoInput.html
# Class LVCVideoInput
# Class LVCVideoInput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Represents a video-only input source for the Live Video Compositor.
```csharp
public class LVCVideoInput : LVCInput, IDisposable
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
This class handles video input streams that will be composited into the final output.
It supports various features including custom positioning, resize policies, optional preview rendering,
and processing blocks for applying effects or transformations to the input video stream.
Video inputs can be dynamically added, removed, and repositioned during playback.
## Constructors
### LVCVideoInput(string, LiveVideoCompositor, MediaBlock, VideoFrameInfoX, Rect, bool, MediaBlock)
Initializes a new instance of the true, the input will start automatically when the compositor starts.
- processingBlock (MediaBlock): An optional processing block to apply effects or transformations. Default is null.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when info is null.
### LVCVideoInput(string, MediaBlock, VideoFrameInfoX, Rect, bool, MediaBlock)
Initializes a new instance of the true, the input will start automatically when added to a compositor.
- processingBlock (MediaBlock): An optional processing block to apply effects or transformations. Default is null.
#### Remarks
This constructor is typically used when creating inputs that will be added to a compositor later.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when info is null.
## Properties
### Info
Gets the video frame information for this input.
```csharp
public VideoFrameInfoX Info { get; }
```
#### Property Value
Parameters:
- (VideoFrameInfoX):
### ProcessingVideoBlocks
Gets the list of video processing blocks applied to this input.
```csharp
public Listtrue to release both managed and unmanaged resources;
false to release only unmanaged resources.
#### Remarks
This method properly disposes of the video tee and renderer components if they were created,
then calls the base class disposal logic. This method is called by the public Dispose method
and the finalizer.
### ToString()
Returns a string representation of this video input.
```csharp
public override string ToString()
```
#### Returns
Parameters:
- (string): A string containing the input name and its rectangle dimensions in the format "Name (Rectangle)".
## See Also
---
# Class LVCVideoOutput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCVideoOutput.html
# Class LVCVideoOutput
# Class LVCVideoOutput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Represents a video-only output component for the Live Video Compositor.
This class handles the creation and management of video bridge sources
that connect to the main processing pipeline, supporting optional video processing blocks.
```csharp
public class LVCVideoOutput : LVCOutput, IDisposable
```
#### Inheritance
#### Derived
#### Implements
#### Inherited Members
## Remarks
This output type is used when only video streams need to be processed and output
from the compositor, without any audio components. It creates a single bridge source
for video and allows for optional video processing before connection to the main output block.
## Constructors
### LVCVideoOutput(string, LiveVideoCompositor, MediaBlock, bool, MediaBlock)
Initializes a new instance of the true, the output will automatically start with the main pipeline; otherwise, manual start is required.
- processingVideoBlock (MediaBlock): An optional video processing block to apply effects or transformations to the video stream before output. Default is null.
## Methods
### Build(string, string)
Builds the output pipeline by creating a video bridge source and connecting it
to the main output block through an optional processing block.
```csharp
public override void Build(string uniqueName, string uniqueName2 = null)
```
#### Parameters
Parameters:
- uniqueName (string): The unique identifier for the video bridge source.
- uniqueName2 (string): Not used in video-only output. This parameter is included for interface compatibility.
#### Remarks
This method creates a video bridge source based on the compositor's video settings,
connects an optional processing block if provided, and establishes the pipeline
from the bridge source to the main output block. The method handles dynamic input
creation for blocks that support it. Note that there appears to be duplicate connection
logic in the current implementation that may need review.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when the media type is null or invalid.
## See Also
---
# Class LVCVideoViewOutput
Link: api/VisioForge.Core.LiveVideoCompositorV2.LVCVideoViewOutput.html
# Class LVCVideoViewOutput
# Class LVCVideoViewOutput
**Namespace**: VisioForge.Core.LiveVideoCompositorV2
**Assembly**: VisioForge.Core.dll
Represents a video output component that renders directly to a video view for the Live Video Compositor.
This specialized output class creates a video renderer block that displays the compositor's
video output directly on a user interface video view control.
```csharp
public class LVCVideoViewOutput : LVCVideoOutput, IDisposable
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
This class extends true, the output will automatically start with the main pipeline; otherwise, manual start is required.
- processingVideoBlock (MediaBlock): An optional video processing block to apply effects or transformations to the video stream before rendering. Default is null.
#### Remarks
This constructor creates a true if successful, false otherwise.
### CleanUp()
Releases all resources and performs cleanup operations for this AAC encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer AAC encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer AAC encoder.
### GetDefaultSettings()
Gets the default AAC encoder settings appropriate for the current platform.
On Windows, it prefers AVENC (libav) if available, otherwise falls back to Media Foundation.
On Android and iOS (non-Catalyst), it uses the VO-AAC encoder.
On all other platforms (Linux, macOS), it uses AVENC.
```csharp
public static IAACEncoderSettings GetDefaultSettings()
```
#### Returns
Parameters:
- (IAACEncoderSettings): Platform-specific AAC encoder settings configured with default values.
### GetElement()
Gets the underlying GStreamer element that performs the AAC encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the AAC encoder.
### IsAvailable(IAACEncoderSettings)
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable(IAACEncoderSettings settings)
```
#### Parameters
Parameters:
- settings (IAACEncoderSettings): The settings.
#### Returns
Parameters:
- (bool): true if the specified settings is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this AAC encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ADPCMEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.ADPCMEncoderBlock.html
# Class ADPCMEncoderBlock
# Class ADPCMEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into ADPCM (Adaptive Differential Pulse Code Modulation) format.
ADPCM is a lossy audio compression technique that reduces file size while maintaining reasonable quality,
commonly used in telecommunications and embedded systems. This block supports configurable block alignment
for optimized encoding performance.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this ADPCM encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer ADPCM encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer ADPCM encoder.
### GetElement()
Gets the underlying GStreamer element that performs the ADPCM encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the ADPCM encoder.
### IsAvailable()
Determines whether the ADPCM encoder is available on the current system.
This checks if the required GStreamer ADPCM encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the ADPCM encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this ADPCM encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ALAWEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.ALAWEncoderBlock.html
# Class ALAWEncoderBlock
# Class ALAWEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into A-law (G.711) format.
A-law is a standard audio compression algorithm widely used in European telecommunications systems,
providing 8-bit logarithmic quantization of 16-bit audio samples. This encoder is commonly used
for telephony applications and VoIP systems where bandwidth efficiency is important.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this A-law encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer A-law encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer A-law encoder.
### GetElement()
Gets the underlying GStreamer element that performs the A-law encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the A-law encoder.
### IsAvailable()
Determines whether the A-law encoder is available on the current system.
This checks if the required GStreamer A-law encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the A-law encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this A-law encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class AptXDecoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.AptXDecoderBlock.html
# Class AptXDecoderBlock
# Class AptXDecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that decodes AptX compressed audio streams into raw PCM audio.
AptX is a psychoacoustic audio codec algorithm that provides CD-like audio quality
with low latency, making it ideal for wireless audio reception over Bluetooth.
This decoder handles AptX bitstreams and outputs high-quality stereo PCM audio.
Implements the true if the decoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this AptX decoder block.
This method disposes of GStreamer elements, releases memory, and ensures proper
shutdown of the block. Called automatically during pipeline teardown.
```csharp
public void CleanUp()
```
### Dispose(bool)
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Properly disposes of the GStreamer AptX decoder element and associated resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer AptX decoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer AptX decoder.
### GetElement()
Gets the underlying GStreamer element that performs the AptX audio decoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the AptX decoder.
### IsAvailable(AptXDecoderSettings)
Determines whether AptX decoding is available with the specified settings.
Checks for the presence of the GStreamer openaptxdec plugin.
```csharp
public static bool IsAvailable(AptXDecoderSettings settings)
```
#### Parameters
Parameters:
- settings (AptXDecoderSettings): The AptX decoder settings to validate.
#### Returns
Parameters:
- (bool): true if AptX decoding is available; otherwise, false.
### SetContext(MediaBlocksPipeline)
Associates this AptX decoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
public void SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class AptXEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.AptXEncoderBlock.html
# Class AptXEncoderBlock
# Class AptXEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into AptX format for Bluetooth audio applications.
AptX is a psychoacoustic audio codec algorithm that provides CD-like audio quality
with low latency, making it ideal for wireless audio transmission over Bluetooth.
The codec uses a 4:1 compression ratio and supports stereo audio only.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this AptX encoder block.
This method disposes of GStreamer elements, releases memory, and ensures proper
shutdown of the block. Called automatically during pipeline teardown.
```csharp
public void CleanUp()
```
### Dispose(bool)
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Properly disposes of the GStreamer AptX encoder element and associated resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer AptX encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer AptX encoder.
### GetElement()
Gets the underlying GStreamer element that performs the AptX audio encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the AptX encoder.
### IsAvailable(AptXEncoderSettings)
Determines whether AptX encoding is available with the specified settings.
Checks for the presence of the GStreamer openaptxenc plugin.
```csharp
public static bool IsAvailable(AptXEncoderSettings settings)
```
#### Parameters
Parameters:
- settings (AptXEncoderSettings): The AptX encoder settings to validate.
#### Returns
Parameters:
- (bool): true if AptX encoding is available; otherwise, false.
### SetContext(MediaBlocksPipeline)
Associates this AptX encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
public void SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class FLACEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.FLACEncoderBlock.html
# Class FLACEncoderBlock
# Class FLACEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into FLAC (Free Lossless Audio Codec) format.
FLAC is a lossless audio compression format that reduces file size without quality loss,
making it ideal for archival storage, high-quality audio production, and applications
where audio fidelity is critical. Supports configurable compression levels and encoding parameters.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this FLAC encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer FLAC encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer FLAC encoder.
### GetElement()
Gets the underlying GStreamer element that performs the FLAC encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the FLAC encoder.
### IsAvailable()
Determines whether the FLAC encoder is available on the current system.
This checks if the required GStreamer FLAC encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the FLAC encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this FLAC encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MP2EncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.MP2EncoderBlock.html
# Class MP2EncoderBlock
# Class MP2EncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into MP2 (MPEG-1 Audio Layer II) format.
MP2 is a standardized lossy audio compression format that provides good quality
at moderate bitrates and is widely used in broadcast applications, DAB radio,
and European digital television systems. The encoder offers excellent compatibility
with legacy systems while maintaining efficient compression ratios suitable for
broadcast transmission and professional audio distribution.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this MP2 encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer MP2 encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer MP2 encoder.
### GetElement()
Gets the underlying GStreamer element that performs the MP2 encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the MP2 encoder.
### IsAvailable()
Determines whether the MP2 encoder is available on the current system.
This checks if the required GStreamer MP2 encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the MP2 encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this MP2 encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MP3EncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.MP3EncoderBlock.html
# Class MP3EncoderBlock
# Class MP3EncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
Audio encoder block that compresses raw audio into MP3 (MPEG-1 Audio Layer III) format.
MP3 is one of the most widely supported audio formats, offering good compression ratios
while maintaining acceptable audio quality. This block uses the LAME encoder for high-quality
MP3 encoding with configurable bitrate settings. It supports constant bitrate (CBR) and
variable bitrate (VBR) encoding modes, with bitrates ranging from 32 to 320 kbps.
The encoder accepts raw PCM audio input and produces compressed MP3 audio output suitable
for streaming, storage, or further processing. Common use cases include creating audio files,
streaming audio content, and reducing audio bandwidth requirements. The block optionally
adds an MP3 parser for streaming scenarios like RTMP to YouTube or Facebook.
Implements the true, adds an MP3 parser after encoding. This is required
for RTMP streaming to services like YouTube and Facebook to ensure proper stream formatting.
## Properties
### Input
Gets the single audio input pad for this encoder block.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets all input pads. This block has a single audio input.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the single audio output pad for this encoder block.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets all output pads. This block has a single audio output.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the MP3 encoder settings including bitrate, quality, and encoding mode.
These settings control the compression quality and output file size.
```csharp
public MP3EncoderSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (MP3EncoderSettings):
### Type
Gets the block type identifier for this MP3 encoder.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds and initializes the MP3 encoder within the pipeline.
Creates the LAME MP3 encoder element with the specified settings and optionally
adds an MP3 parser for streaming compatibility.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the encoder was successfully built and configured; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the MP3 encoder element.
Called during disposal to ensure proper cleanup of native GStreamer resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the MP3 encoder.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The MP3Encoder element that performs the audio compression.
### GetElement()
Gets the underlying GStreamer element for this MP3 encoder.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer lamemp3enc element that performs MP3 encoding.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this MP3 encoder, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this encoder block.
## See Also
---
# Class OPUSEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.OPUSEncoderBlock.html
# Class OPUSEncoderBlock
# Class OPUSEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into Opus format.
Opus is a modern, open-source audio codec designed for low-latency, high-quality audio transmission
over the internet. It excels in both speech and music applications, providing superior quality at
low bitrates compared to older codecs. Opus is widely used in VoIP, video conferencing, streaming,
and real-time communications due to its adaptive bitrate and low encoding delay.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Opus encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Opus encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Opus encoder.
### GetElement()
Gets the underlying GStreamer element that performs the Opus encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Opus encoder.
### IsAvailable()
Determines whether the Opus encoder is available on the current system.
This checks if the required GStreamer Opus encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the Opus encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Opus encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SpeexEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.SpeexEncoderBlock.html
# Class SpeexEncoderBlock
# Class SpeexEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into Speex format.
Speex is an open-source speech codec specifically designed for voice over IP (VoIP) applications
and speech compression. It provides excellent compression for human speech while maintaining
good quality at very low bitrates. The codec features variable bitrate encoding, noise
suppression, echo cancellation, and is particularly well-suited for real-time voice
communication systems, internet telephony, and voice recording applications.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Speex encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Speex encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Speex encoder.
### GetElement()
Gets the underlying GStreamer element that performs the Speex speech encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Speex encoder.
### IsAvailable()
Determines whether the Speex encoder is available on the current system.
This checks if the required GStreamer Speex encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the Speex encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Speex encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VorbisEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.VorbisEncoderBlock.html
# Class VorbisEncoderBlock
# Class VorbisEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into Vorbis format.
Vorbis is an open-source, lossy audio compression format that provides excellent quality
at low bitrates. Designed as a free alternative to MP3, Vorbis offers superior compression
efficiency and is commonly used in gaming, streaming applications, and OGG containers.
The encoder supports variable bitrate (VBR) encoding for optimal quality-to-size ratio.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Vorbis encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Vorbis encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Vorbis encoder.
### GetElement()
Gets the underlying GStreamer element that performs the Vorbis encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Vorbis encoder.
### IsAvailable()
Determines whether the Vorbis encoder is available on the current system.
This checks if the required GStreamer Vorbis encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the Vorbis encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Vorbis encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class WAVEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.WAVEncoderBlock.html
# Class WAVEncoderBlock
# Class WAVEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into WAV (Waveform Audio File Format).
WAV is an uncompressed audio format that preserves original audio quality without
any loss. It's widely supported across all platforms and applications, making it
ideal for professional audio production, archiving, and scenarios where audio
fidelity is paramount. The format supports various bit depths and sample rates.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this WAV encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer WAV encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer WAV encoder.
### GetElement()
Gets the underlying GStreamer element that performs the WAV encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the WAV encoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this WAV encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class WavPackEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.WavPackEncoderBlock.html
# Class WavPackEncoderBlock
# Class WavPackEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into WavPack format.
WavPack is a hybrid lossless/lossy audio compression format that provides both perfect quality
preservation and excellent compression ratios. Unlike traditional lossless formats, WavPack can
create hybrid files with a lossy core and lossless correction data, offering flexible quality
options. The format supports very high compression ratios while maintaining fast encoding/decoding
speeds, making it ideal for archival storage, music distribution, and professional audio applications
where both quality and file size are important considerations.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this WavPack encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer WavPack encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer WavPack encoder.
### GetElement()
Gets the underlying GStreamer element that performs the WavPack encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the WavPack encoder.
### IsAvailable()
Determines whether the WavPack encoder is available on the current system.
This checks if the required GStreamer WavPack encoder plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the WavPack encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this WavPack encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class WMAEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.WMAEncoderBlock.html
# Class WMAEncoderBlock
# Class WMAEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioEncoders
**Assembly**: VisioForge.Core.dll
MediaBlock that encodes raw audio into WMA (Windows Media Audio) format.
WMA is Microsoft's proprietary lossy audio compression format that offers good compression
efficiency and quality. The format supports variable bitrate encoding, lossless compression
modes, and advanced features like digital rights management (DRM). WMA is widely supported
on Windows platforms and provides excellent integration with Microsoft's media ecosystem,
making it suitable for Windows-based applications and Windows Media streaming.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this WMA encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer WMA encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer WMA encoder.
### GetDefaultSettings()
Creates a new instance of WMAEncoderSettings with default values optimized for general-purpose encoding.
These default settings provide a good balance between quality and file size for most Windows Media applications.
```csharp
public static WMAEncoderSettings GetDefaultSettings()
```
#### Returns
Parameters:
- (WMAEncoderSettings): A WMAEncoderSettings instance configured with recommended default values for WMA encoding.
### GetElement()
Gets the underlying GStreamer element that performs the WMA encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the WMA encoder.
### IsAvailable()
Determines whether the WMA encoder is available on the current system.
This checks if the required Windows Media Format SDK and GStreamer WMA encoder plugin are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the WMA encoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this WMA encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.AudioEncoders
Link: api/VisioForge.Core.MediaBlocks.AudioEncoders.html
# Namespace VisioForge.Core.MediaBlocks.AudioEncoders
# Namespace VisioForge.Core.MediaBlocks.AudioEncoders
### Classes
Parameters:
- (): MediaBlock that encodes raw audio into AAC (Advanced Audio Coding) format.
AAC is a widely supported audio format offering better quality than MP3 at similar bitrates,
commonly used in streaming, broadcasting, and mobile applications. This block supports
platform-specific encoders for optimal performance.
Implements the true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the amplify filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The AmplifyFilter element that performs the audio processing.
### GetElement()
Gets the underlying GStreamer element for this amplify block.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that performs the amplification.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this block, providing access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class AudioBalanceBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioBalanceBlock.html
# Class AudioBalanceBlock
# Class AudioBalanceBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio balance processing block for stereo panorama control in the MediaBlocks pipeline.
This block adjusts the stereo balance (left/right channel distribution) of audio content,
allowing positioning of audio from full left (-1.0) through center (0.0) to full right (+1.0).
Essential for stereo audio mixing, surround sound processing, and spatial audio applications.
Implements the // Create balance block for center positioning
var centerBalance = new AudioBalanceBlock();
// Create balance block shifted to the left
var leftBalance = new AudioBalanceBlock(-0.5f);
// Create balance block shifted to the right
var rightBalance = new AudioBalanceBlock(0.7f);true if the audio balance block was successfully built and configured; false if initialization failed.
### CleanUp()
Cleans up the audio balance block by disposing of the GStreamer audio balance filter.
This method safely releases the underlying audio processing resources and resets the block
to an unbuilt state for potential reuse or final disposal.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and optionally managed resources used by the audio balance block.
Properly disposes of the GStreamer audio balance filter and associated resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element for this audio balance block.
Provides access to the underlying audio balance filter for advanced operations.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement representing the audio balance filter component.
### GetElement()
Gets the underlying GStreamer element for direct GStreamer API access.
Provides low-level access to the audio balance filter element for advanced audio processing operations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element representing the audio balance filter.
### IsAvailable()
Determines whether the audio balance block is available in the current environment.
Checks for the presence of required GStreamer audio processing plugins and dependencies.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if audio balance processing is available; otherwise, false.
#### Remarks
This method verifies that the underlying GStreamer audio balance filter is properly installed
and can be instantiated. Always check availability before using the block in production code.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this audio balance block.
This method is called internally by the MediaBlocks pipeline during block initialization
to provide access to pipeline resources and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that owns this block.
## See Also
---
# Class AudioConverterBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioConverterBlock.html
# Class AudioConverterBlock
# Class AudioConverterBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio format converter block that transforms audio data between different formats, sample rates, and channel configurations.
This block provides automatic audio format conversion capabilities within a media processing pipeline,
handling format negotiation and conversion between incompatible audio formats. It supports conversion
between various audio formats including different sample rates (8kHz to 192kHz), bit depths (8/16/24/32-bit),
channel layouts (mono, stereo, surround), and audio codecs. The converter automatically determines
the optimal conversion path and handles format negotiation between connected blocks.
Common use cases include matching audio formats between sources and encoders, resampling for output devices,
and ensuring compatibility between pipeline elements with different audio requirements.
Implements the true if the converter was successfully built and initialized; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the audio converter element.
Called during disposal to ensure proper cleanup of native GStreamer resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the audio converter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The AudioConverter element that performs the format conversion.
### GetElement()
Gets the underlying GStreamer element for this converter block.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer audioconvert element that performs the format transformation.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this converter block, providing access to shared resources and pipeline state.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this converter block.
## See Also
---
# Class AudioEffectsBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioEffectsBlock.html
# Class AudioEffectsBlock
# Class AudioEffectsBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio effects processing block that applies multiple real-time audio effects to audio streams.
This block manages a chain of audio effects including volume control, equalizers, balance adjustment,
echo/reverb, amplification, compression/expansion, and tempo scaling. Effects can be dynamically
added, removed, and updated during playback without interrupting the audio stream. The block supports
both real-time parameter adjustment and effect chaining for complex audio processing workflows.
Essential for audio post-processing, music production, broadcast audio, and interactive audio applications.
Implements the true if the audio effects block was successfully built and configured; false if initialization failed.
### CleanUp()
Cleans up the audio effects block by disposing of all internal processing components.
This method safely releases the audio effects processor, audio converter, and resets
the block to an unbuilt state for potential reuse or final disposal.
```csharp
public void CleanUp()
```
### Clear()
Removes all audio effects from the processing chain.
This method clears both the high-level effects list and the underlying GStreamer
processing elements, returning the block to a pass-through state with no effects applied.
```csharp
public void Clear()
```
### Dispose(bool)
Releases unmanaged and optionally managed resources used by the audio effects block.
Properly disposes of all audio effects, the effects processor, and audio converter components.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Get(string)
Retrieves an audio effect from the processing chain by its name.
This method allows access to individual effects for parameter adjustment or configuration.
The search is case-insensitive for convenience.
```csharp
public BaseAudioEffect Get(string name)
```
#### Parameters
Parameters:
- name (string): The name of the audio effect to retrieve, as specified during creation.
#### Returns
Parameters:
- (BaseAudioEffect): The true if audio effects processing is available; otherwise, false.
### Remove(BaseAudioEffect)
Removes an audio effect from the processing chain.
This method safely removes the effect from both the high-level effect list and the
underlying GStreamer processing chain, cleaning up resources and event handlers.
```csharp
public void Remove(BaseAudioEffect effect)
```
#### Parameters
Parameters:
- effect (BaseAudioEffect): The audio effect to remove from the processing chain.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this audio effects block.
This method is called internally by the MediaBlocks pipeline during block initialization
to provide access to pipeline resources, logging context, and effect processor configuration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that owns this block.
## See Also
---
# Class AudioLoudNormBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioLoudNormBlock.html
# Class AudioLoudNormBlock
# Class AudioLoudNormBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio loudness normalization block using audioloudnorm from rsaudiofx plugin.
Normalizes audio according to EBU R128 loudness standards with configurable target levels,
loudness range, and peak limiting. Essential for broadcast compliance, streaming platforms,
and maintaining consistent audio levels across different content.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this audio loudness normalization block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer audio loudness normalization filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer audio loudness normalization filter.
### GetElement()
Gets the underlying GStreamer element that performs the loudness normalization processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the audio loudness normalization filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this audio loudness normalization block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class AudioMixerBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioMixerBlock.html
# Class AudioMixerBlock
# Class AudioMixerBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio mixer block that combines multiple audio streams into a single output stream.
This block accepts multiple audio inputs and mixes them together with individual volume
and mute controls for each input channel. The mixer automatically handles format conversion
through internal audio resamplers to ensure all inputs are converted to a common format
before mixing. Essential for combining multiple audio sources like microphones, music tracks,
sound effects, and other audio streams in broadcast, conferencing, and multimedia applications.
Supports dynamic input addition/removal during playback and real-time volume/mute control.
Implements the true if the mixer was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this audio mixer block.
This method disposes of the mixer element, all resamplers, and input blocks.
```csharp
public void CleanUp()
```
### CreateNewInput()
Creates a new input pad for the audio mixer.
Each input pad can receive an independent audio stream that will be mixed with other inputs.
The new input is not connected to the mixer until the Build() method is called.
```csharp
public MediaBlockPad CreateNewInput()
```
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for audio input.
### CreateNewInputLive()
Creates a new input pad and immediately connects it to the running audio mixer.
This method allows dynamic input addition while the pipeline is in playing state.
Each input includes an audio resampler to ensure format compatibility.
```csharp
public MediaBlockPad CreateNewInputLive()
```
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured and connected for live audio input.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer audio mixer element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer audio mixer.
### GetElement()
Gets the underlying GStreamer element that performs the audio mixing operations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the audio mixer.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### RemoveInputLive(MediaBlockPad)
Removes an input from the audio mixer while the pipeline is running.
This method safely disconnects and removes an input pad, its associated resampler,
and mixer sink pad without interrupting other audio streams.
```csharp
public bool RemoveInputLive(MediaBlockPad blockPad)
```
#### Parameters
Parameters:
- blockPad (MediaBlockPad): The MediaBlockPad to remove from the mixer.
#### Returns
Parameters:
- (bool): true if the input was successfully removed; false if an error occurred.
### SetMute(int, bool)
Sets the mute state for a specific input stream in the mixer.
Muted streams continue to be processed but their audio is silenced in the mix.
```csharp
public void SetMute(int streamIndex, bool value)
```
#### Parameters
Parameters:
- streamIndex (int): The zero-based index of the input stream to mute/unmute.
- value (bool): True to mute the stream, false to unmute.
### SetVolume(int, double)
Sets the volume level for a specific input stream in the mixer.
Volume is applied independently to each input before mixing.
```csharp
public void SetVolume(int streamIndex, double value)
```
#### Parameters
Parameters:
- streamIndex (int): The zero-based index of the input stream to adjust.
- value (double): The volume multiplier (0.0 = silence, 1.0 = normal, 10.0 = maximum amplification).
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this audio mixer block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class AudioResamplerBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioResamplerBlock.html
# Class AudioResamplerBlock
# Class AudioResamplerBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio resampler block that converts audio between different sample rates, formats, and channel configurations.
This block provides high-quality audio resampling for format compatibility and sample rate conversion
within the MediaBlocks pipeline. It can convert between various audio formats (8-bit to 32-bit),
sample rates (8kHz to 192kHz), and channel layouts (mono to multi-channel). The resampler uses
advanced algorithms to maintain audio quality during conversion and minimize artifacts.
Essential for ensuring audio compatibility between sources, effects, and outputs with different requirements.
Implements the true if the audio resampler was successfully built and configured; false if initialization failed.
### CleanUp()
Cleans up the audio resampler block by disposing of the GStreamer audio resampler element.
This method safely releases the underlying resampling resources and resets the block
to an unbuilt state for potential reuse or final disposal.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and optionally managed resources used by the audio resampler block.
Properly disposes of the GStreamer audio resampler element and associated resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element for this audio resampler block.
Provides access to the underlying audio resampler element for advanced operations.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement representing the audio resampler component.
### GetElement()
Gets the underlying GStreamer element for direct GStreamer API access.
Provides low-level access to the audio resampler element for advanced resampling operations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element representing the audio resampler.
### IsAvailable()
Determines whether the audio resampler block is available in the current environment.
Checks for the presence of required GStreamer audio resampling plugins and dependencies.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if audio resampling is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this audio resampler block.
This method is called internally by the MediaBlocks pipeline during block initialization
to provide access to pipeline resources and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that owns this block.
## See Also
---
# Class AudioRNNoiseBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioRNNoiseBlock.html
# Class AudioRNNoiseBlock
# Class AudioRNNoiseBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
RNN-based audio noise reduction block using audiornnoise from rsaudiofx plugin.
Uses a recurrent neural network to intelligently remove noise from audio streams while
preserving speech and other desired audio content. Features voice activity detection
for optimized noise reduction performance. Essential for cleaning audio recordings,
live streams, and communication applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this audio RNN noise reduction block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer audio RNN noise reduction filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer audio RNN noise reduction filter.
### GetElement()
Gets the underlying GStreamer element that performs the noise reduction processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the audio RNN noise reduction filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this audio RNN noise reduction block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class AudioSampleGrabberBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.AudioSampleGrabberBlock.html
# Class AudioSampleGrabberBlock
# Class AudioSampleGrabberBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio sample grabber block that captures audio samples from the pipeline for analysis or processing.
This block provides real-time access to audio data flowing through the pipeline without affecting
the audio stream. It captures audio samples and delivers them through events for applications that
need to analyze, visualize, or process audio data. The block supports various audio formats and
can optionally include a null renderer for scenarios where audio data capture is needed without playback.
Essential for audio analysis, waveform visualization, level meters, and custom audio processing applications.
Implements the true if the grabber was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this audio sample grabber block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer audio sample grabber element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer sample grabber.
### GetElement()
Gets the underlying GStreamer element that performs the audio sample capture.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the sample grabber.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this audio sample grabber block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### OnAudioFrameBuffer
This event occurs whenever a new audio frame is captured from the stream.
Provides real-time access to audio samples for analysis, visualization, or processing
without affecting the audio pipeline flow.
```csharp
public event EventHandlertrue if the corrector was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this audio timestamp corrector block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer audio timestamp corrector element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer timestamp corrector.
### GetElement()
Gets the underlying GStreamer element that performs the audio timestamp correction processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the timestamp corrector.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this audio timestamp corrector block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ChebyshevBandPassRejectBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.ChebyshevBandPassRejectBlock.html
# Class ChebyshevBandPassRejectBlock
# Class ChebyshevBandPassRejectBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Chebyshev band pass and band reject audio filter block for precise frequency domain processing.
This block implements high-quality Chebyshev filters that can operate in band-pass or band-reject modes
to selectively allow or remove specific frequency ranges from audio signals. Chebyshev filters provide
steeper roll-off characteristics compared to Butterworth filters, making them ideal for applications
requiring precise frequency separation. The block supports configurable ripple, cutoff frequencies,
and filter order for optimal audio filtering performance. Essential for audio cleanup, noise reduction,
frequency isolation, and professional audio processing applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Chebyshev band-pass/reject filter block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Chebyshev band-pass/reject filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Chebyshev filter.
### GetElement()
Gets the underlying GStreamer element that performs the Chebyshev band-pass/reject filtering.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Chebyshev filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Chebyshev band-pass/reject filter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ChebyshevLimitBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.ChebyshevLimitBlock.html
# Class ChebyshevLimitBlock
# Class ChebyshevLimitBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Chebyshev low pass and high pass filter block for frequency range limiting and audio cleanup.
This block implements high-quality Chebyshev filters that can operate in low-pass or high-pass modes
to remove unwanted frequency content from audio signals. Chebyshev filters provide steeper roll-off
characteristics compared to Butterworth filters with configurable ripple and cutoff frequency.
Essential for anti-aliasing, noise reduction, audio cleanup, and frequency band limiting applications
in professional audio processing and broadcast systems.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Chebyshev limit filter block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Chebyshev limit filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Chebyshev filter.
### GetElement()
Gets the underlying GStreamer element that performs the Chebyshev low-pass/high-pass filtering.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Chebyshev filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Chebyshev limit filter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CompressorExpanderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.CompressorExpanderBlock.html
# Class CompressorExpanderBlock
# Class CompressorExpanderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio compressor/expander block for dynamic range control and audio level management.
This block provides professional-grade dynamic range processing including compression to reduce
dynamic range and expansion to increase it. Features configurable ratio, threshold, attack/release
times, and soft/hard knee characteristics. Essential for audio mastering, broadcast normalization,
voice processing, and maintaining consistent audio levels in multimedia applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this compressor/expander filter block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer compressor/expander filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer compressor/expander filter.
### GetElement()
Gets the underlying GStreamer element that performs the dynamic range processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the compressor/expander filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this compressor/expander filter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CsoundFilterBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.CsoundFilterBlock.html
# Class CsoundFilterBlock
# Class CsoundFilterBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Csound audio filter block that provides advanced audio synthesis and processing capabilities.
This block integrates the powerful Csound audio programming language and DSP engine to enable
complex audio transformations, synthesis, and effects processing. Supports both CSD text content
and external CSD files for flexible audio programming. Features include real-time parameter control,
score looping, and offset configuration for sophisticated audio manipulation in multimedia pipelines.
Implements the true [loop].
- scoreOffset (double): The score offset.
## Properties
### CsdText
Gets or sets the CSD text content defining the Csound instruments and score.
This property allows inline specification of Csound code for real-time audio processing.
Changes take effect on the next pipeline start or restart.
```csharp
public string CsdText { get; set; }
```
#### Property Value
Parameters:
- (string):
### Input
Gets the single audio input pad for this block.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets all input pads. This block has a single audio input.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Location
Gets or sets the CSD file location for external Csound score files.
Use either CsdText or Location but not both simultaneously to avoid conflicts.
Changes take effect on the next pipeline start or restart.
```csharp
public string Location { get; set; }
```
#### Property Value
Parameters:
- (string):
### Loop
Gets or sets a value indicating whether the Csound score should loop continuously.
When enabled, the score will restart automatically upon completion.
Can be changed during playback in PLAYING or PAUSED states.
```csharp
public bool Loop { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Output
Gets the single audio output pad for this block.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets all output pads. This block has a single audio output.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### ScoreOffset
Gets or sets the score offset in seconds for starting playback at a specific time.
This allows skipping to any position within the Csound score for flexible playback control.
Changes take effect on the next pipeline start or restart.
```csharp
public double ScoreOffset { get; set; }
```
#### Property Value
Parameters:
- (double):
### Type
Gets the block type identifier for this Csound filter block.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Constructs and initializes the Csound filter and its associated GStreamer elements.
This method creates the filter with the specified Csound parameters, establishes input and output pads,
and prepares the block for advanced audio synthesis and processing using the Csound DSP engine.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Csound filter block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Csound filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Csound filter.
### GetElement()
Gets the underlying GStreamer element that performs the Csound audio processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Csound filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Csound filter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class EbuR128LevelBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.EbuR128LevelBlock.html
# Class EbuR128LevelBlock
# Class EbuR128LevelBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
EBU R128 loudness level measurement block using ebur128level from rsaudiofx plugin.
Measures and reports loudness levels according to EBU R128 standard including momentary,
short-term, and integrated loudness measurements, loudness range, and peak levels.
Essential for broadcast compliance, audio mastering, and loudness monitoring applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this EBU R128 level measurement block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer EBU R128 level measurement filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer EBU R128 level measurement filter.
### GetElement()
Gets the underlying GStreamer element that performs the loudness level measurement.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the EBU R128 level measurement filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this EBU R128 level measurement block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class EchoBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.EchoBlock.html
# Class EchoBlock
# Class EchoBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio echo effect block that adds delayed repetitions of the input audio signal.
This block creates echo effects by mixing delayed versions of the audio with the original signal.
Features configurable delay time, feedback amount, and intensity for creating various echo effects
from subtle ambience to dramatic repeating echoes. Essential for audio enhancement, spatial effects,
music production, and creating acoustic environment simulations in multimedia applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this echo effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer echo filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer echo filter.
### GetElement()
Gets the underlying GStreamer element that performs the echo effect processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the echo filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this echo effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class Equalizer10Block
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.Equalizer10Block.html
# Class Equalizer10Block
# Class Equalizer10Block
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
10-band graphic equalizer block for precise frequency response control and audio tone shaping.
This block provides a traditional 10-band graphic equalizer with fixed frequency bands covering
the full audio spectrum from bass to treble. Each band can be independently adjusted to boost
or cut specific frequency ranges, allowing for detailed audio tone control and frequency correction.
Essential for audio mastering, sound system tuning, music production, and broadcast audio processing.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this 10-band equalizer block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer 10-band equalizer filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer equalizer filter.
### GetElement()
Gets the underlying GStreamer element that performs the 10-band equalization processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the equalizer filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetBand(int, double)
Sets the gain level for a specific frequency band.
```csharp
public void SetBand(int id, double value)
```
#### Parameters
Parameters:
- id (int): The band identifier (0-9) corresponding to specific frequencies.
- value (double): The gain value in decibels (-24dB to +12dB).
#### Remarks
Ranging from -24 dB to +12 dB.
Band 0: 29 Hz.
Band 1: 59 Hz.
Band 2: 119 Hz.
Band 3: 237 Hz.
Band 4: 474 Hz.
Band 5: 947 Hz.
Band 6: 1889 Hz.
Band 7: 3770 Hz.
Band 8: 7523 Hz.
Band 9: 15011 Hz.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this 10-band equalizer block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class EqualizerParametricBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.EqualizerParametricBlock.html
# Class EqualizerParametricBlock
# Class EqualizerParametricBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Parametric equalizer block providing flexible multi-band frequency control with adjustable parameters.
This block offers advanced equalizer functionality with configurable frequency bands where each band
can have its center frequency, gain, and bandwidth (Q factor) independently adjusted. Provides more
precise frequency control than graphic equalizers, making it ideal for professional audio correction,
notch filtering, and surgical frequency adjustments. Essential for audio mastering, broadcast processing,
and high-end audio production applications requiring precise frequency response shaping.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this parametric equalizer block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer parametric equalizer filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer parametric equalizer filter.
### GetElement()
Gets the underlying GStreamer element that performs the parametric equalization processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the parametric equalizer filter.
### GetStates()
Gets the current configuration states for all parametric equalizer bands.
```csharp
public ParametricEqualizerBand[] GetStates()
```
#### Returns
Parameters:
- (ParametricEqualizerBand [ ]): An array of ParametricEqualizerBand objects containing the configuration for each band.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetNumBands(int)
Sets the number of active parametric equalizer bands.
Each band can independently control a specific frequency range with adjustable
center frequency, gain, and bandwidth. Default: 5.
```csharp
public void SetNumBands(int value)
```
#### Parameters
Parameters:
- value (int): The number of bands to activate (1-64).
### SetState(int, ParametricEqualizerBand)
Sets the configuration state for a specific parametric equalizer band.
Each band state includes center frequency, bandwidth (Q factor), and gain settings.
```csharp
public void SetState(int index, ParametricEqualizerBand bandState)
```
#### Parameters
Parameters:
- index (int): The band index (0-based, must be less than NumBands).
- bandState (ParametricEqualizerBand): The parametric band configuration including frequency, bandwidth, and gain.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this parametric equalizer block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class HRTFRenderBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.HRTFRenderBlock.html
# Class HRTFRenderBlock
# Class HRTFRenderBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Head-Related Transfer Function (HRTF) spatial audio rendering block using hrtfrender from rsaudiofx plugin.
Renders spatial audio using HRTF data for 3D positional audio effects. Provides immersive audio
experiences by simulating how sound reaches the ears from different spatial positions.
Essential for VR applications, games, and spatial audio content production.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this HRTF rendering block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer HRTF rendering filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer HRTF rendering filter.
### GetElement()
Gets the underlying GStreamer element that performs the HRTF spatial audio rendering.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the HRTF rendering filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this HRTF rendering block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class KaraokeBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.KaraokeBlock.html
# Class KaraokeBlock
# Class KaraokeBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Karaoke audio effect block that removes or reduces center-panned vocals from stereo audio.
This block uses advanced audio processing techniques to isolate and suppress vocal content
that is typically recorded in the center of the stereo image. Features configurable filtering
levels and frequency ranges to optimize vocal removal for different music types. Essential for
karaoke applications, vocal isolation, instrumental track creation, and audio remixing.
Works best with well-mixed stereo recordings where vocals are center-panned.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this karaoke effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer karaoke filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer karaoke filter.
### GetElement()
Gets the underlying GStreamer element that performs the karaoke vocal removal processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the karaoke filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this karaoke effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class PitchBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.PitchBlock.html
# Class PitchBlock
# Class PitchBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio pitch shifting block that changes the pitch without affecting playback speed.
This block provides high-quality pitch shifting using the soundtouch library.
Supports pitch adjustment in semitones (-12 to +12) for musical applications.
Essential for karaoke, music production, and audio processing applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Cleans up all resources associated with the pitch operations.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the pitch block.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer pitch filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer pitch filter.
### GetElement()
Gets the underlying GStreamer element that performs the pitch processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the pitch filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this pitch block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class RemoveSilenceBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.RemoveSilenceBlock.html
# Class RemoveSilenceBlock
# Class RemoveSilenceBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio silence removal block that automatically detects and removes silent sections from audio streams.
This block analyzes incoming audio to identify sections where the signal level falls below a specified
threshold and either removes these sections entirely or reduces their volume. Essential for cleaning up
recordings, podcasts, voice content, and any audio that contains unwanted silent gaps or quiet segments.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this remove silence block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer removesilence filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer removesilence filter.
### GetElement()
Gets the underlying GStreamer element that performs the silence removal processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the removesilence filter.
### IsAvailable()
Determines whether this media block is available.
Checks if the required GStreamer removesilence plugin is installed and accessible.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the removesilence element is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this remove silence block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ReverberationBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.ReverberationBlock.html
# Class ReverberationBlock
# Class ReverberationBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Reverberation audio effect block that simulates acoustic spaces and room ambience.
This block adds realistic reverb effects to audio by simulating the natural reflections
and decay characteristics of various acoustic environments. Features configurable room size,
decay time, damping, and wet/dry mix controls to create everything from subtle room ambience
to dramatic hall reverbs. Essential for music production, audio post-production, gaming audio,
and creating immersive spatial audio experiences.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this reverberation effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer reverberation filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer reverberation filter.
### GetElement()
Gets the underlying GStreamer element that performs the reverberation effect processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the reverberation filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this reverberation effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class RSAudioEchoBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.RSAudioEchoBlock.html
# Class RSAudioEchoBlock
# Class RSAudioEchoBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
RS Audio Echo effect block using rsaudioecho from rsaudiofx plugin.
Provides echo and reverb effects with configurable delay, intensity, and feedback parameters.
Features precise control over echo characteristics for creating spatial effects, ambience,
and classic echo sounds. Essential for audio enhancement and creative audio processing.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this RS audio echo effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer RS audio echo filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer RS audio echo filter.
### GetElement()
Gets the underlying GStreamer element that performs the echo effect processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the RS audio echo filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this RS audio echo effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ScaleTempoBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.ScaleTempoBlock.html
# Class ScaleTempoBlock
# Class ScaleTempoBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Audio tempo scaling block that changes playback speed without affecting pitch.
This block provides high-quality time-stretching and pitch-shifting capabilities using
advanced algorithms to modify audio tempo while preserving pitch quality. Features configurable
rate scaling, overlap processing, search windows, and stride lengths for optimal audio quality.
Essential for music production, audio editing, speech processing, and media playback applications
requiring tempo adjustments without pitch distortion.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this tempo scaling block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer scale tempo filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer scale tempo filter.
### GetElement()
Gets the underlying GStreamer element that performs the tempo scaling processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the scale tempo filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this tempo scaling block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SilenceDetectorBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.SilenceDetectorBlock.html
# Class SilenceDetectorBlock
# Class SilenceDetectorBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
Silence detector block that analyzes uncompressed audio streams to detect periods of silence
based on a configurable threshold level. This block monitors audio in real-time, identifies
when audio levels drop below the specified threshold, and tracks the duration of silence periods.
Features include real-time callbacks for silence start/end events, collection of all silence
periods with precise timestamps, and JSON export functionality for detailed analysis and reporting.
Essential for audio editing applications, speech processing, podcast production, and any scenario
requiring automatic silence detection and analysis.
Implements the true if the detector was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this silence detector block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### ClearSilencePeriods()
Clears all detected silence periods from the internal list.
Useful when reusing the detector for multiple audio files or when resetting
detection state between different processing operations.
```csharp
public void ClearSilencePeriods()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### ExportSilencePeriodsJson(bool)
Exports all detected silence periods to a JSON string.
The JSON format includes an array of silence periods, each with start time,
end time, and duration in various formats (milliseconds, seconds, and formatted strings).
Suitable for saving to file, sending to APIs, or further processing by other tools.
```csharp
public string ExportSilencePeriodsJson(bool prettyPrint = true)
```
#### Parameters
Parameters:
- prettyPrint (bool): If true, formats the JSON with indentation for readability. Default: true.
#### Returns
Parameters:
- (string): A JSON string containing all detected silence periods with detailed timing information.
### FinalizeSilencePeriods(TimeSpan)
Finalizes any in-progress silence period and returns all detected periods.
This should be called when the audio stream ends to ensure the final silence period
(if the stream ended during silence) is properly recorded and included in the results.
```csharp
public Listtrue if the level element is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this silence detector block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### OnSilenceEnded
This event occurs when a silence period ends (audio level rises above the threshold).
Provides notification with timestamp, audio level, and complete silence period information
including start time, end time, and duration for recording or analysis purposes.
```csharp
public event EventHandlertrue if the volume block was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the volume filter element.
Called during disposal to ensure proper cleanup of native GStreamer resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the volume filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The VolumeFilter element that performs the volume adjustment.
### GetElement()
Gets the underlying GStreamer element for this volume block.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer volume element that controls audio levels.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this volume block, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this volume block.
## See Also
---
# Class VUMeterBlock
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.VUMeterBlock.html
# Class VUMeterBlock
# Class VUMeterBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioProcessing
**Assembly**: VisioForge.Core.dll
VU (Volume Unit) meter block for real-time audio level monitoring and analysis.
This block provides continuous audio level measurement and peak detection for stereo and mono audio streams.
Features real-time callback events with detailed level information including RMS, peak, and decay values
for both left and right channels. Essential for audio monitoring, level control, automatic gain control,
broadcast applications, and professional audio production environments requiring precise level monitoring.
Implements the true if successfull, false otherwise.
### CleanUp()
Cleans up.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
### OnAudioVUMeter
This event occurs whenever new audio VU meter data is received.
Provides real-time audio level information including RMS, peak, and decay values
for continuous audio monitoring and level control applications.
```csharp
public event EventHandlertrue if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this wide stereo effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer wide stereo filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer wide stereo filter.
### GetElement()
Gets the underlying GStreamer element that performs the stereo width enhancement processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the wide stereo filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this wide stereo effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.AudioProcessing
Link: api/VisioForge.Core.MediaBlocks.AudioProcessing.html
# Namespace VisioForge.Core.MediaBlocks.AudioProcessing
# Namespace VisioForge.Core.MediaBlocks.AudioProcessing
### Classes
Parameters:
- (): Audio amplification block that adjusts the volume level of audio streams.
This block provides configurable gain control with multiple clipping methods to prevent distortion
when amplifying audio signals. Useful for normalizing audio levels or boosting quiet audio sources.
Implements the true if the renderer was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this audio renderer block.
This method disposes of the audio renderer element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the audio renderer element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the audio renderer.
### GetDevicesAsync(AudioOutputDeviceAPI?)
Gets the available audio output devices asynchronously.
Enumerates all audio devices compatible with the specified API.
```csharp
public static Tasktrue if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this audio renderer block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.AudioRendering
Link: api/VisioForge.Core.MediaBlocks.AudioRendering.html
# Namespace VisioForge.Core.MediaBlocks.AudioRendering
# Namespace VisioForge.Core.MediaBlocks.AudioRendering
### Classes
Parameters:
- (): Audio renderer block for real-time audio playback through system audio devices.
This block provides cross-platform audio output capabilities with support for various
audio APIs including DirectSound (Windows), OpenSLES (Android), CoreAudio (macOS/iOS),
and ALSA/PulseAudio (Linux). Features real-time volume control, mute functionality,
synchronization with video streams, device selection, and low-latency playback.
Essential for media players, live streaming applications, audio monitoring systems,
and any scenario requiring high-quality audio output with precise timing control.
Implements the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual bumpscope elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the bumpscope block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualCoronaBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualCoronaBlock.html
# Class LibVisualCoronaBlock
# Class LibVisualCoronaBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual Corona audio visualizer block that creates sun-like corona effects synchronized to audio.
```csharp
public class LibVisualCoronaBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual Corona visualizer creates sun-like corona effects that respond to audio input:
- Dynamic solar corona patterns that pulse and flow with the music
- Bright radial flares that extend from a central point
- Color variations based on frequency and amplitude content
- Organic flowing movements synchronized to audio characteristics
This visualization provides a dramatic and energetic representation of audio signals.
## Constructors
### LibVisualCoronaBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual corona elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the corona block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualInfiniteBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualInfiniteBlock.html
# Class LibVisualInfiniteBlock
# Class LibVisualInfiniteBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual Infinite audio visualizer block that creates flowing infinite patterns synchronized to audio.
```csharp
public class LibVisualInfiniteBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual Infinite visualizer creates mesmerizing infinite tunnel and flowing patterns:
- Dynamic tunnel-like effects that seem to extend infinitely
- Flowing geometric patterns that respond to audio frequencies
- Smooth morphing shapes that pulse with the music
- Hypnotic movements synchronized to audio characteristics
This visualization provides a psychedelic and immersive representation of audio signals.
## Constructors
### LibVisualInfiniteBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual infinite elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the infinite block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualJakdawBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualJakdawBlock.html
# Class LibVisualJakdawBlock
# Class LibVisualJakdawBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual Jakdaw audio visualizer block that creates Jakdaw-style visualization patterns synchronized to audio.
```csharp
public class LibVisualJakdawBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual Jakdaw visualizer creates dynamic bird-like and nature-inspired patterns:
- Organic flowing movements resembling bird flight patterns
- Dynamic particle systems that respond to audio frequencies
- Natural-looking animations synchronized to musical rhythm
- Fluid movements that create artistic visual narratives
This visualization provides an organic and artistic representation of audio signals.
## Constructors
### LibVisualJakdawBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual jakdaw elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the jakdaw block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualJessBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualJessBlock.html
# Class LibVisualJessBlock
# Class LibVisualJessBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual Jess audio visualizer block that creates Jess-style visualization patterns synchronized to audio.
```csharp
public class LibVisualJessBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual Jess visualizer creates distinctive and artistic patterns:
- Unique geometric and abstract visual patterns
- Dynamic color gradients that respond to audio intensity
- Artistic movements synchronized to musical characteristics
- Creative visual compositions that change with the music
This visualization provides a distinctive and artistic representation of audio signals.
## Constructors
### LibVisualJessBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual jess elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the jess block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualLVAnalyzerBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualLVAnalyzerBlock.html
# Class LibVisualLVAnalyzerBlock
# Class LibVisualLVAnalyzerBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual LV Analyzer audio visualizer block that creates analyzer-style frequency display synchronized to audio.
```csharp
public class LibVisualLVAnalyzerBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual LV Analyzer visualizer creates analyzer-style frequency spectrum displays:
- Traditional spectrum analyzer with frequency bars
- Real-time frequency distribution visualization
- Classic audio analyzer interface with frequency bands
- Professional-style frequency analysis display
This visualization provides a technical and precise representation of audio frequency content.
## Constructors
### LibVisualLVAnalyzerBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual LV analyzer elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the LV analyzer block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualLVScopeBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualLVScopeBlock.html
# Class LibVisualLVScopeBlock
# Class LibVisualLVScopeBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual LV Scope audio visualizer block that creates scope-style waveform display synchronized to audio.
```csharp
public class LibVisualLVScopeBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual LV Scope visualizer creates scope-style waveform displays:
- Traditional oscilloscope-style waveform visualization
- Real-time audio waveform representation
- Classic scope interface with time-domain signal display
- Professional-style waveform analysis
This visualization provides a precise and technical representation of audio waveform data.
## Constructors
### LibVisualLVScopeBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual LV scope elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the LV scope block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class LibVisualOinksieBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.LibVisualOinksieBlock.html
# Class LibVisualOinksieBlock
# Class LibVisualOinksieBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
LibVisual Oinksie audio visualizer block that creates Oinksie-style visualization patterns synchronized to audio.
```csharp
public class LibVisualOinksieBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The LibVisual Oinksie visualizer creates playful and dynamic patterns:
- Whimsical and fun visual effects with bright colors
- Bouncing and particle-based animations
- Playful movements synchronized to musical rhythm
- Creative and lighthearted visual displays
This visualization provides a fun and energetic representation of audio signals.
## Constructors
### LibVisualOinksieBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer libvisual oinksie elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the oinksie block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class SpacescopeBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.SpacescopeBlock.html
# Class SpacescopeBlock
# Class SpacescopeBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
Spacescope audio visualizer block that creates a stereo spatial visualization of audio.
```csharp
public class SpacescopeBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The Spacescope visualizer displays audio as a two-dimensional plot where:
- X-axis represents the left channel
- Y-axis represents the right channel
- The resulting pattern shows the stereo field and phase relationships
This visualization is particularly useful for analyzing stereo imaging, phase issues, and mono compatibility.
## Constructors
### SpacescopeBlock(SpacescopeSettings)
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer elements, configures the visualization settings,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the spacescope block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class SpectrascopeBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.SpectrascopeBlock.html
# Class SpectrascopeBlock
# Class SpectrascopeBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
Spectrascope audio visualizer block that creates a frequency spectrum visualization of audio.
```csharp
public class SpectrascopeBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The Spectrascope visualizer displays the frequency spectrum of audio signals in real-time.
It performs Fast Fourier Transform (FFT) analysis on the incoming audio to show:
- Frequency distribution from low to high frequencies along the horizontal axis
- Amplitude/intensity of each frequency band as vertical lines or bars
- Real-time updates showing how the frequency content changes over time
This visualization is useful for audio analysis, equalization monitoring, and identifying frequency characteristics.
## Constructors
### SpectrascopeBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer FFT analysis elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the spectrascope block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class SynaescopeBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.SynaescopeBlock.html
# Class SynaescopeBlock
# Class SynaescopeBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
Synaescope audio visualizer block that creates a synesthetic visualization of audio.
```csharp
public class SynaescopeBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The Synaescope visualizer creates a unique visual representation of audio that combines multiple aspects:
- Frequency analysis combined with color mapping (synesthesia effect)
- Dynamic patterns that respond to both amplitude and frequency content
- Psychedelic-style visualization that creates flowing, organic patterns
- Real-time response to audio characteristics including rhythm and timbre
This visualization provides an artistic and immersive representation of audio signals.
## Constructors
### SynaescopeBlock()
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer synesthetic visualization elements,
and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the synaescope block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Class WavescopeBlock
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.WavescopeBlock.html
# Class WavescopeBlock
# Class WavescopeBlock
**Namespace**: VisioForge.Core.MediaBlocks.AudioVisualizers
**Assembly**: VisioForge.Core.dll
Wavescope audio visualizer block that creates an oscilloscope-style waveform visualization of audio.
```csharp
public class WavescopeBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The Wavescope visualizer displays the audio waveform in real-time, similar to an oscilloscope:
- Shows the amplitude of the audio signal over time
- Displays waveform shape that represents the actual audio samples
- Can show both channels of stereo audio either combined or separately
- Useful for monitoring audio levels, clipping detection, and waveform analysis
This is the most basic and direct visualization of audio signals.
## Constructors
### WavescopeBlock(WavescopeSettings)
Initializes a new instance of the true if the block was successfully built and configured; false if an error occurred.
#### Remarks
This method creates the underlying GStreamer waveform visualization elements,
configures the visualization settings, and establishes the input/output pads for audio/video data flow.
### CleanUp()
Cleans up and releases all resources used by the wavescope block.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer elements and resets the build state.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer base element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The underlying true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline that will contain this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.AudioVisualizers
Link: api/VisioForge.Core.MediaBlocks.AudioVisualizers.html
# Namespace VisioForge.Core.MediaBlocks.AudioVisualizers
# Namespace VisioForge.Core.MediaBlocks.AudioVisualizers
### Classes
Parameters:
- (): LibVisual Bumpscope audio visualizer block that creates bump scope visualization patterns synchronized to audio.
- (): LibVisual Corona audio visualizer block that creates sun-like corona effects synchronized to audio.
- (): LibVisual Infinite audio visualizer block that creates flowing infinite patterns synchronized to audio.
- (): LibVisual Jakdaw audio visualizer block that creates Jakdaw-style visualization patterns synchronized to audio.
- (): LibVisual Jess audio visualizer block that creates Jess-style visualization patterns synchronized to audio.
- (): LibVisual LV Analyzer audio visualizer block that creates analyzer-style frequency display synchronized to audio.
- (): LibVisual LV Scope audio visualizer block that creates scope-style waveform display synchronized to audio.
- (): LibVisual Oinksie audio visualizer block that creates Oinksie-style visualization patterns synchronized to audio.
- (): Spacescope audio visualizer block that creates a stereo spatial visualization of audio.
- (): Spectrascope audio visualizer block that creates a frequency spectrum visualization of audio.
- (): Synaescope audio visualizer block that creates a synesthetic visualization of audio.
- (): Wavescope audio visualizer block that creates an oscilloscope-style waveform visualization of audio.
---
# Class AWSS3SinkBlock
Link: api/VisioForge.Core.MediaBlocks.AWS.AWSS3SinkBlock.html
# Class AWSS3SinkBlock
# Class AWSS3SinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.AWS
**Assembly**: VisioForge.Core.dll
AWS S3 sink block for direct media streaming to Amazon S3 cloud storage.
This block enables real-time upload of media data to AWS S3 buckets, supporting
live streaming, recording, and archival workflows. Features include multipart uploads
for large files, automatic retry on network failures, configurable buffer sizes,
and support for various S3 storage classes. Essential for cloud-based media workflows,
content distribution, backup solutions, and scalable media storage architectures.
Requires AWS credentials and appropriate S3 bucket permissions.
Implements the true if the sink was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this AWS S3 sink block.
This method disposes of the S3 sink element and resets the build state.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type.
This allows the AWS S3 sink to accept multiple media streams (video, audio, etc.)
for multiplexed upload to cloud storage.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media this input pad will accept (Video, Audio, Auto, etc.).
#### Returns
Parameters:
- (MediaBlockPad): A new true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the AWS S3 sink element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the S3 sink.
### GetElement()
Gets the underlying GStreamer element that performs the S3 upload operations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the AWS S3 sink.
### GetFilenameOrURL()
Gets the S3 URI for the upload destination.
Returns the complete S3 path including bucket and object key.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The S3 URI in the format s3://bucket/path/to/object.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the S3 URI for the upload destination.
Updates the target location for media uploads.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The S3 URI in the format s3://bucket/path/to/object.
### Update()
Updates the AWS S3 sink settings during runtime.
This method allows dynamic reconfiguration of S3 upload parameters
without stopping the pipeline.
```csharp
public void Update()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this AWS S3 sink block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.AWS
Link: api/VisioForge.Core.MediaBlocks.AWS.html
# Namespace VisioForge.Core.MediaBlocks.AWS
# Namespace VisioForge.Core.MediaBlocks.AWS
### Classes
Parameters:
- (): AWS S3 sink block for direct media streaming to Amazon S3 cloud storage.
This block enables real-time upload of media data to AWS S3 buckets, supporting
live streaming, recording, and archival workflows. Features include multipart uploads
for large files, automatic retry on network failures, configurable buffer sizes,
and support for various S3 storage classes. Essential for cloud-based media workflows,
content distribution, backup solutions, and scalable media storage architectures.
Requires AWS credentials and appropriate S3 bucket permissions.
Implements the true if the bridge sink was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the bridge audio sink element.
This disconnects from the bridge channel and frees associated resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge audio sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BridgeAudioSink element that manages the channel communication.
### GetElement()
Gets the underlying GStreamer element for this bridge sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles audio bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### UpdateChannel(string)
Updates the channel name for this bridge sink dynamically.
This allows changing the bridge destination without rebuilding the pipeline.
The new channel must exist or be created by a corresponding source.
```csharp
public bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to bridge audio to.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge sink.
## See Also
---
# Class BridgeAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeAudioSourceBlock.html
# Class BridgeAudioSourceBlock
# Class BridgeAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Audio source block that bridges audio data from other pipelines or applications using a channel-based communication system.
This block acts as a source that receives audio data from a named channel created by a BridgeAudioSinkBlock.
It enables inter-pipeline communication for audio streams, allowing complex architectures where audio processing
is distributed across multiple pipelines. The bridge uses an efficient in-memory transport mechanism with minimal
latency and supports real-time audio streaming. Common use cases include receiving audio from another pipeline,
implementing modular audio processing chains, and creating reusable audio processing components. Pair this source
with a BridgeAudioSinkBlock using the same channel name to establish a complete audio bridge connection.
Implements the true if the bridge source was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the bridge audio source element.
This disconnects from the bridge channel and frees associated resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge audio source.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BridgeAudioSource element that manages the channel communication.
### GetElement()
Gets the underlying GStreamer element for this bridge source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles audio bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### RemoveElementsFromPipeline()
Removes all internal elements from the pipeline.
This method is typically called during cleanup or when reconfiguring the pipeline.
It ensures proper disconnection from the bridge channel.
```csharp
public override void RemoveElementsFromPipeline()
```
### UpdateChannel(string)
Updates the channel name for this bridge source dynamically.
This allows changing the bridge source without rebuilding the pipeline.
The new channel must have a corresponding sink providing data.
```csharp
public bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to receive audio from.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge source.
## See Also
---
# Class BridgeBufferSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeBufferSinkBlock.html
# Class BridgeBufferSinkBlock
# Class BridgeBufferSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Buffer sink block that bridges raw buffer data between different pipelines using a pair-based communication system.
This block acts as an endpoint that receives buffer data and makes it available to a corresponding BridgeBufferSourceBlock
through a unique pair identifier. Unlike channel-based bridges, this uses direct buffer passing for lower latency
and supports any media type including video, audio, or custom data. The bridge maintains a cache of sink/source pairs
for efficient lookup and connection. Common use cases include zero-copy data transfer between pipelines, implementing
custom processing chains with raw buffers, and creating high-performance media routing systems. The video information
parameter helps optimize buffer handling for video streams but the block can handle any buffer type.
Implements the true if the bridge sink was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the bridge buffer sink.
Note: The actual element disposal is handled in the Dispose method to ensure
proper removal from the bridge cache before releasing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge buffer sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BridgeBufferSink element that manages the buffer passing.
### GetElement()
Gets the underlying GStreamer element for this bridge sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles buffer bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge sink.
## See Also
---
# Class BridgeBufferSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeBufferSourceBlock.html
# Class BridgeBufferSourceBlock
# Class BridgeBufferSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Buffer source block that bridges raw buffer data from other pipelines using a pair-based communication system.
This block acts as a source that receives buffer data from a BridgeBufferSinkBlock with a matching pair identifier.
Unlike channel-based bridges, this uses direct buffer passing for lower latency and supports any media type including
video, audio, or custom data. The bridge maintains a cache of sink/source pairs for efficient lookup and connection.
Common use cases include zero-copy data transfer between pipelines, implementing custom processing chains with raw buffers,
and creating high-performance media routing systems. The source automatically discovers its corresponding sink through
the global bridge cache and establishes the connection during build time.
Implements the true if the bridge source was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the bridge buffer source.
Note: The actual element disposal is handled in the Dispose method to ensure
proper removal from the bridge cache before releasing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge buffer source.
Note: This implementation returns null as the buffer source uses a different architecture.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for buffer sources.
### GetElement()
Gets the underlying GStreamer element for this bridge source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles buffer bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge source.
## See Also
---
# Class BridgeConfiguration
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeConfiguration.html
# Class BridgeConfiguration
# Class BridgeConfiguration
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Configuration for creating bridge instances.
```csharp
public class BridgeConfiguration
```
#### Inheritance
#### Inherited Members
## Properties
### AudioInfo
Gets or sets audio format information for audio bridges.
Optional for audio bridge configuration.
```csharp
public AudioInfoX AudioInfo { get; set; }
```
#### Property Value
Parameters:
- (AudioInfoX):
### BridgeType
Gets or sets the type of bridge to create.
```csharp
public BridgeType BridgeType { get; set; }
```
#### Property Value
Parameters:
- (BridgeType):
### ChannelName
Gets or sets the channel name for the bridge connection.
If not specified, the Identifier will be used as the channel name.
```csharp
public string ChannelName { get; set; }
```
#### Property Value
Parameters:
- (string):
### CustomSettings
Gets or sets additional settings specific to certain bridge types.
```csharp
public object CustomSettings { get; set; }
```
#### Property Value
Parameters:
- (object):
### CustomSyncFlag
Gets or sets custom synchronization flag for Bridge type.
```csharp
public bool CustomSyncFlag { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Identifier
Gets or sets the identifier for the bridge connection.
```csharp
public Guid Identifier { get; set; }
```
#### Property Value
Parameters:
- (Guid):
### IsSink
Gets or sets a value indicating whether to create a sink (true) or source (false).
```csharp
public bool IsSink { get; set; }
```
#### Property Value
Parameters:
- (bool):
### MediaType
Gets or sets the media type for the bridge.
```csharp
public MediaBlockPadMediaType MediaType { get; set; }
```
#### Property Value
Parameters:
- (MediaBlockPadMediaType):
### VideoInfo
Gets or sets video format information for video bridges.
Required for some bridge types when MediaType is Video.
```csharp
public VideoFrameInfoX VideoInfo { get; set; }
```
#### Property Value
Parameters:
- (VideoFrameInfoX):
## Methods
### Create(BridgeType, MediaBlockPadMediaType, bool, Guid)
Creates a configuration for a specific bridge scenario.
```csharp
public static BridgeConfiguration Create(BridgeType bridgeType, MediaBlockPadMediaType mediaType, bool isSink, Guid identifier)
```
#### Parameters
Parameters:
- bridgeType (BridgeType): The type of bridge.
- mediaType (MediaBlockPadMediaType): The media type.
- isSink (bool): Whether this is a sink or source.
- identifier (Guid): The connection identifier.
#### Returns
Parameters:
- (BridgeConfiguration): A new BridgeConfiguration instance.
### CreateAudio(BridgeType, bool, AudioInfoX)
Creates a configuration for an audio bridge.
```csharp
public static BridgeConfiguration CreateAudio(BridgeType bridgeType, bool isSink, AudioInfoX audioInfo = null)
```
#### Parameters
Parameters:
- bridgeType (BridgeType): The type of bridge.
- isSink (bool): Whether to create a sink or source.
- audioInfo (AudioInfoX): Optional audio format information.
#### Returns
Parameters:
- (BridgeConfiguration): A configured BridgeConfiguration instance.
### CreateDefault()
Creates a default configuration for a video bridge sink with a new GUID.
```csharp
public static BridgeConfiguration CreateDefault()
```
#### Returns
Parameters:
- (BridgeConfiguration): A new BridgeConfiguration instance.
### CreateVideo(BridgeType, bool, VideoFrameInfoX)
Creates a configuration for a video bridge.
```csharp
public static BridgeConfiguration CreateVideo(BridgeType bridgeType, bool isSink, VideoFrameInfoX videoInfo = null)
```
#### Parameters
Parameters:
- bridgeType (BridgeType): The type of bridge.
- isSink (bool): Whether to create a sink or source.
- videoInfo (VideoFrameInfoX): Optional video format information.
#### Returns
Parameters:
- (BridgeConfiguration): A configured BridgeConfiguration instance.
### CreateWithNewId(BridgeType, MediaBlockPadMediaType, bool)
Creates a configuration for a specific bridge scenario with a new GUID.
```csharp
public static BridgeConfiguration CreateWithNewId(BridgeType bridgeType, MediaBlockPadMediaType mediaType, bool isSink)
```
#### Parameters
Parameters:
- bridgeType (BridgeType): The type of bridge.
- mediaType (MediaBlockPadMediaType): The media type.
- isSink (bool): Whether this is a sink or source.
#### Returns
Parameters:
- (BridgeConfiguration): A new BridgeConfiguration instance.
### GetEffectiveChannelName()
Gets the effective channel name for the bridge.
Returns ChannelName if set, otherwise returns Identifier as string.
```csharp
public string GetEffectiveChannelName()
```
#### Returns
Parameters:
- (string): The channel name to use for the bridge.
---
# Class BridgeFactory
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeFactory.html
# Class BridgeFactory
# Class BridgeFactory
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Factory class for creating bridge instances based on configuration.
```csharp
public static class BridgeFactory
```
#### Inheritance
#### Inherited Members
## Methods
### CreateBridgePair(BridgeConfiguration)
Creates a bridge pair (sink and source) with the same configuration.
```csharp
public static (IBridgeSink sink, IBridgeSource source) CreateBridgePair(BridgeConfiguration config)
```
#### Parameters
Parameters:
- config (BridgeConfiguration): The base configuration.
#### Returns
Parameters:
- (( IBridgeSink sink , IBridgeSource source )): A tuple containing the sink and source bridges.
### CreateBridgeSink(BridgeConfiguration)
Creates a bridge sink instance based on the provided configuration.
```csharp
public static IBridgeSink CreateBridgeSink(BridgeConfiguration config)
```
#### Parameters
Parameters:
- config (BridgeConfiguration): The bridge configuration.
#### Returns
Parameters:
- (IBridgeSink): An IBridgeSink implementation.
#### Exceptions
Parameters:
- (ArgumentNullException): Thrown when config is null.
- (NotSupportedException): Thrown when the bridge type or media type combination is not supported.
### CreateBridgeSource(BridgeConfiguration)
Creates a bridge source instance based on the provided configuration.
```csharp
public static IBridgeSource CreateBridgeSource(BridgeConfiguration config)
```
#### Parameters
Parameters:
- config (BridgeConfiguration): The bridge configuration.
#### Returns
Parameters:
- (IBridgeSource): An IBridgeSource implementation.
#### Exceptions
Parameters:
- (ArgumentNullException): Thrown when config is null.
- (NotSupportedException): Thrown when the bridge type or media type combination is not supported.
### IsBridgeTypeAvailable(BridgeType, MediaBlockPadMediaType)
Checks if a specific bridge type is available on the current platform.
```csharp
public static bool IsBridgeTypeAvailable(BridgeType bridgeType, MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- bridgeType (BridgeType): The bridge type to check.
- mediaType (MediaBlockPadMediaType): The media type to check.
#### Returns
Parameters:
- (bool): True if available, false otherwise.
---
# Class BridgeSubtitleSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeSubtitleSinkBlock.html
# Class BridgeSubtitleSinkBlock
# Class BridgeSubtitleSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Subtitle sink block that bridges subtitle data between different pipelines or applications using a channel-based communication system.
This block acts as an endpoint that receives subtitle data (text, SSA/ASS, WebVTT, or other formats) and makes it available
to other pipelines or processes through a named channel. It enables inter-pipeline communication for subtitle streams,
allowing complex architectures where subtitle processing is distributed across multiple pipelines. The bridge supports
various subtitle formats and maintains timing synchronization. Common use cases include subtitle extraction and routing,
implementing subtitle processing chains, overlaying subtitles from different sources, and creating subtitle broadcasting
systems. Pair this sink with a BridgeSubtitleSourceBlock using the same channel name to establish a complete subtitle bridge.
Implements the true if the bridge sink was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the bridge subtitle sink element.
This disconnects from the bridge channel and frees associated resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge subtitle sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BridgeSubtitleSink element that manages the channel communication.
### GetElement()
Gets the underlying GStreamer element for this bridge sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles subtitle bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### UpdateChannel(string)
Updates the channel name for this bridge sink dynamically.
This allows changing the bridge destination without rebuilding the pipeline.
The new channel must exist or be created by a corresponding source.
```csharp
public bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to bridge subtitles to.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge sink.
## See Also
---
# Class BridgeSubtitleSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeSubtitleSourceBlock.html
# Class BridgeSubtitleSourceBlock
# Class BridgeSubtitleSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Subtitle source block that bridges subtitle data from other pipelines or applications using a channel-based communication system.
This block acts as a source that receives subtitle data from a named channel created by a BridgeSubtitleSinkBlock.
It enables inter-pipeline communication for subtitle streams, allowing complex architectures where subtitle processing
is distributed across multiple pipelines. The bridge supports various subtitle formats (text, SSA/ASS, WebVTT, etc.)
and maintains timing synchronization. Common use cases include receiving subtitles from another pipeline, implementing
modular subtitle processing chains, combining subtitles from multiple sources, and creating subtitle distribution systems.
The source includes an internal queue for buffering to ensure smooth playback. Pair this source with a BridgeSubtitleSinkBlock
using the same channel name to establish a complete subtitle bridge connection.
Implements the true if the bridge source was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the bridge subtitle source element and queue.
This disconnects from the bridge channel and frees associated resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge subtitle source.
Note: This implementation returns null as the subtitle source uses a different architecture.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for subtitle sources.
### GetElement()
Gets the underlying GStreamer element for this bridge source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles subtitle bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### UpdateChannel(string)
Updates the channel name for this bridge source dynamically.
This allows changing the bridge source without rebuilding the pipeline.
The new channel must have a corresponding sink providing data.
```csharp
public bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to receive subtitles from.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge source.
## See Also
---
# Enum BridgeType
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeType.html
# Enum BridgeType
# Enum BridgeType
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Defines the types of bridges available for inter-pipeline communication.
```csharp
public enum BridgeType
```
## Fields
Parameters:
- Bridge (): General purpose bridge for video, audio, subtitle, or buffer data.
Supports dynamic channel updates via UpdateChannel method.
- Proxy (): Proxy bridge for communication within the same pipeline.
Minimal overhead, best for internal routing.
- InterPipe (): InterPipe bridge for communication across different pipelines in the same process.
Zero-copy transfer with support for multiple listeners.
- RSInter (): Rust-based inter-pipeline bridge for high-performance scenarios.
Optimized for low latency and high throughput.
---
# Class BridgeVideoSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeVideoSinkBlock.html
# Class BridgeVideoSinkBlock
# Class BridgeVideoSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Video sink block that bridges video data between different pipelines or applications using a channel-based communication system.
This block acts as an endpoint that receives video data and makes it available to other pipelines or processes through
a named channel. It enables inter-pipeline communication for video streams, allowing complex architectures where video
processing is distributed across multiple pipelines. The bridge uses an efficient in-memory transport mechanism with
minimal latency and supports real-time video streaming at high resolutions and frame rates. Common use cases include
splitting video processing across multiple pipelines, implementing modular video processing chains, creating video
distribution systems, and enabling multi-view applications. The sink can handle various video formats and color spaces
with automatic format negotiation. Pair this sink with a BridgeVideoSourceBlock using the same channel name to establish
a complete video bridge connection.
Implements the true if the bridge sink was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the bridge video sink element.
This disconnects from the bridge channel and frees associated resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge video sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BridgeVideoSink element that manages the channel communication.
### GetElement()
Gets the underlying GStreamer element for this bridge sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles video bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### UpdateChannel(string)
Updates the channel name for this bridge sink dynamically.
This allows changing the bridge destination without rebuilding the pipeline.
The new channel must exist or be created by a corresponding source.
```csharp
public bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to bridge video to.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge sink.
## See Also
---
# Class BridgeVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.BridgeVideoSourceBlock.html
# Class BridgeVideoSourceBlock
# Class BridgeVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Video source block that bridges video data from other pipelines or applications using a channel-based communication system.
This block acts as a source that receives video data from a named channel created by a BridgeVideoSinkBlock.
It enables inter-pipeline communication for video streams, allowing complex architectures where video processing
is distributed across multiple pipelines. The bridge uses an efficient in-memory transport mechanism with minimal
latency and supports real-time video streaming at high resolutions and frame rates. Common use cases include
receiving video from another pipeline, implementing modular video processing chains, creating multi-view applications,
and building video distribution systems. The source can handle various video formats and color spaces with automatic
format negotiation. Pair this source with a BridgeVideoSinkBlock using the same channel name to establish a complete
video bridge connection.
Implements the true if the bridge source was successfully built; false if an error occurred.
### CleanUp()
Releases all internal resources and disposes of the bridge video source element.
This disconnects from the bridge channel and frees associated resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the bridge video source.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BridgeVideoSource element that manages the channel communication.
### GetElement()
Gets the underlying GStreamer element for this bridge source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that handles video bridging.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### RemoveElementsFromPipeline()
Removes all internal elements from the pipeline.
This method is typically called during cleanup or when reconfiguring the pipeline.
It ensures proper disconnection from the bridge channel.
```csharp
public override void RemoveElementsFromPipeline()
```
### UpdateChannel(string)
Updates the channel name for this bridge source dynamically.
This allows changing the bridge source without rebuilding the pipeline.
The new channel must have a corresponding sink providing data.
```csharp
public bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to receive video from.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this bridge source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this bridge source.
## See Also
---
# Interface IBridge
Link: api/VisioForge.Core.MediaBlocks.Bridge.IBridge.html
# Interface IBridge
# Interface IBridge
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Base interface for all bridge implementations that enable data transfer between pipelines.
```csharp
public interface IBridge : IDisposable
```
#### Implements
## Properties
### BridgeType
Gets the type of this bridge.
```csharp
BridgeType BridgeType { get; }
```
#### Property Value
Parameters:
- (BridgeType):
### ChannelName
Gets the channel name used for the bridge connection.
```csharp
string ChannelName { get; }
```
#### Property Value
Parameters:
- (string):
### Identifier
Gets the unique identifier for this bridge connection.
```csharp
Guid Identifier { get; }
```
#### Property Value
Parameters:
- (Guid):
### MediaType
Gets the media type supported by this bridge.
```csharp
MediaBlockPadMediaType MediaType { get; }
```
#### Property Value
Parameters:
- (MediaBlockPadMediaType):
## Methods
### GetMediaBlock()
Gets the underlying MediaBlock instance.
```csharp
MediaBlock GetMediaBlock()
```
#### Returns
Parameters:
- (MediaBlock):
### IsAvailable()
Checks if this bridge type is available on the current platform.
```csharp
bool IsAvailable()
```
#### Returns
Parameters:
- (bool): True if available, false otherwise.
### UpdateChannelName(string)
Updates the channel name dynamically.
```csharp
bool UpdateChannelName(string channelName)
```
#### Parameters
Parameters:
- channelName (string): The new channel name.
#### Returns
Parameters:
- (bool): True if the update was successful, false otherwise.
### UpdateIdentifier(Guid)
Updates the connection identifier dynamically.
```csharp
bool UpdateIdentifier(Guid identifier)
```
#### Parameters
Parameters:
- identifier (Guid): The new identifier.
#### Returns
Parameters:
- (bool): True if the update was successful, false otherwise.
---
# Interface IBridgeSink
Link: api/VisioForge.Core.MediaBlocks.Bridge.IBridgeSink.html
# Interface IBridgeSink
# Interface IBridgeSink
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Interface for bridge sink implementations that send data to a bridge connection.
```csharp
public interface IBridgeSink : IBridge, IDisposable
```
#### Implements
## Properties
### ConnectedSourceCount
Gets the number of connected source blocks listening to this sink.
```csharp
int ConnectedSourceCount { get; }
```
#### Property Value
Parameters:
- (int):
### HasConnectedSources
Gets a value indicating whether the sink is currently connected to any sources.
```csharp
bool HasConnectedSources { get; }
```
#### Property Value
Parameters:
- (bool):
## Methods
### Register()
Registers this sink in the global bridge cache if supported by the bridge type.
```csharp
bool Register()
```
#### Returns
Parameters:
- (bool): True if registration was successful, false otherwise.
### Unregister()
Unregisters this sink from the global bridge cache if previously registered.
```csharp
bool Unregister()
```
#### Returns
Parameters:
- (bool): True if unregistration was successful, false otherwise.
---
# Interface IBridgeSource
Link: api/VisioForge.Core.MediaBlocks.Bridge.IBridgeSource.html
# Interface IBridgeSource
# Interface IBridgeSource
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Interface for bridge source implementations that receive data from a bridge connection.
```csharp
public interface IBridgeSource : IBridge, IDisposable
```
#### Implements
## Properties
### IsConnected
Gets a value indicating whether the source is currently connected to a sink.
```csharp
bool IsConnected { get; }
```
#### Property Value
Parameters:
- (bool):
### IsReceivingData
Gets a value indicating whether the source is currently receiving data.
```csharp
bool IsReceivingData { get; }
```
#### Property Value
Parameters:
- (bool):
## Methods
### Connect()
Attempts to connect to a sink with the current identifier.
```csharp
bool Connect()
```
#### Returns
Parameters:
- (bool): True if connection was successful, false otherwise.
### Disconnect()
Disconnects from the current sink if connected.
```csharp
bool Disconnect()
```
#### Returns
Parameters:
- (bool): True if disconnection was successful, false otherwise.
### GetPairedSink()
Gets the paired sink if available and accessible.
```csharp
IBridgeSink GetPairedSink()
```
#### Returns
Parameters:
- (IBridgeSink): The paired sink or null if not available.
---
# Interface IMediaBlocksBridge
Link: api/VisioForge.Core.MediaBlocks.Bridge.IMediaBlocksBridge.html
# Interface IMediaBlocksBridge
# Interface IMediaBlocksBridge
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Interface for media blocks that support bridge functionality with dynamic channel updates.
This interface is implemented by bridge source and sink blocks that use channel-based communication,
allowing them to change their channel assignment at runtime without rebuilding the pipeline.
```csharp
public interface IMediaBlocksBridge
```
## Methods
### UpdateChannel(string)
Updates the channel name for this bridge block dynamically.
This allows changing the bridge connection without rebuilding the pipeline.
For sink blocks, this changes where data is sent. For source blocks, this changes where data is received from.
The channel must exist or be created by the corresponding sink/source pair.
```csharp
bool UpdateChannel(string channel)
```
#### Parameters
Parameters:
- channel (string): The new channel name to use for bridging data.
#### Returns
Parameters:
- (bool): true if the channel was successfully updated; false if the update failed or the block doesn't support dynamic channel changes.
---
# Class InterPipeSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.InterPipeSinkBlock.html
# Class InterPipeSinkBlock
# Class InterPipeSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
InterPipe sink block that enables high-performance inter-pipeline communication using the GStreamer interpipe plugin.
This block acts as an endpoint that publishes data to a named pipe, making it available to InterPipeSourceBlock
instances with the same pipe name. InterPipe provides zero-copy data transfer between pipelines running in the same
process, with support for multiple listeners, dynamic connection/disconnection, and automatic format negotiation.
The sink maintains compatibility with standard GStreamer elements while providing enhanced performance for local
pipeline communication. Common use cases include splitting processing across multiple pipelines for modularity,
implementing one-to-many data distribution, creating reusable processing components, and building complex media
processing graphs. The video information parameter helps optimize buffer handling for video streams but the block
can handle any media type.
Implements the true if the InterPipe sink was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the InterPipe sink.
Note: The actual element disposal is commented out, likely to maintain the named pipe
for other pipelines that may still be connected.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the InterPipe sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The InterPipeSink element that manages the named pipe.
### GetElement()
Gets the underlying GStreamer element for this InterPipe sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer interpipesink element.
### GetNumListeners()
Gets the number of InterPipeSourceBlock elements currently listening to this sink.
```csharp
public int GetNumListeners()
```
#### Returns
Parameters:
- (int): The number of listeners connected to this sink.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this InterPipe sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this InterPipe sink.
## See Also
---
# Class InterPipeSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.InterPipeSourceBlock.html
# Class InterPipeSourceBlock
# Class InterPipeSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
InterPipe source block that enables high-performance inter-pipeline communication using the GStreamer interpipe plugin.
This block acts as a source that listens to a named pipe created by an InterPipeSinkBlock with the same pipe name.
InterPipe provides zero-copy data transfer between pipelines running in the same process, with support for dynamic
connection/disconnection, automatic format negotiation, and seamless pipeline synchronization. Multiple source blocks
can connect to the same sink, enabling one-to-many data distribution patterns. The source maintains compatibility
with standard GStreamer elements while providing enhanced performance for local pipeline communication. Common use
cases include receiving data from modular processing pipelines, implementing multi-view applications, creating
reusable processing components, and building complex media processing graphs with dynamic routing.
Implements the true if the InterPipe source was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the InterPipe source.
Note: The actual element disposal is commented out, likely to maintain flexibility
for dynamic pipeline reconfiguration.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the InterPipe source.
Note: This implementation returns null as the InterPipe source uses a different architecture.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for InterPipe sources.
### GetElement()
Gets the underlying GStreamer element for this InterPipe source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer interpipesrc element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SwitchListenTo(string)
Dynamically switches this source to listen to a different InterPipeSinkBlock.
This allows runtime reconfiguration of pipeline connections without rebuilding.
```csharp
public void SwitchListenTo(string newPairID)
```
#### Parameters
Parameters:
- newPairID (string): The PairID of the InterPipeSinkBlock to start listening to.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this InterPipe source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this InterPipe source.
## See Also
---
# Class ProxySinkBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.ProxySinkBlock.html
# Class ProxySinkBlock
# Class ProxySinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Proxy sink block that enables direct element-to-element communication within the same pipeline using GStreamer's proxy elements.
This block acts as a sink that pairs with a ProxySourceBlock to create an internal bridge within a single pipeline,
allowing dynamic pipeline reconfiguration and data routing without traditional pad connections. The proxy mechanism
provides a way to decouple pipeline sections, making it easier to implement dynamic pipeline topologies, switchable
processing paths, and modular pipeline designs. Unlike InterPipe which works across pipelines, proxy elements work
within the same pipeline with minimal overhead. The sink automatically registers itself in a global cache for discovery
by its paired source. Common use cases include implementing switchable effects chains, creating reusable processing
modules within a pipeline, and building dynamic routing systems.
Implements the true if the proxy sink was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the proxy sink.
Note: The actual element disposal is handled in the Dispose method to ensure
proper removal from the bridge cache before releasing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the proxy sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The ProxySink element that manages the proxy connection.
### GetElement()
Gets the underlying GStreamer element for this proxy sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer proxysink element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this proxy sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this proxy sink.
## See Also
---
# Class ProxySourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.ProxySourceBlock.html
# Class ProxySourceBlock
# Class ProxySourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
Proxy source block that enables direct element-to-element communication within the same pipeline using GStreamer's proxy elements.
This block acts as a source that pairs with a ProxySinkBlock to create an internal bridge within a single pipeline,
receiving data without traditional pad connections. The proxy mechanism provides a way to decouple pipeline sections,
making it easier to implement dynamic pipeline topologies, switchable processing paths, and modular pipeline designs.
Unlike InterPipe which works across pipelines, proxy elements work within the same pipeline with minimal overhead.
The source automatically discovers its paired sink through a global cache and establishes the connection during build.
Common use cases include implementing switchable effects chains, creating reusable processing modules within a pipeline,
building dynamic routing systems, and enabling runtime pipeline reconfiguration without rebuilding the entire graph.
Implements the true if the proxy source was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the proxy source.
Note: The actual element disposal is handled in the Dispose method to ensure
proper removal from the bridge cache before releasing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the proxy source.
Note: This implementation returns null as the proxy source uses a different architecture.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for proxy sources.
### GetElement()
Gets the underlying GStreamer element for this proxy source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer proxysrc element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this proxy source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this proxy source.
## See Also
---
# Class RSInterSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.RSInterSinkBlock.html
# Class RSInterSinkBlock
# Class RSInterSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
RS (Rust) inter sink block that enables high-performance inter-pipeline communication using Rust-based GStreamer elements.
This block acts as a sink that publishes data to a named channel, making it available to RSInterSourceBlock instances
with the same channel name. RS inter elements provide optimized performance through Rust implementations while maintaining
compatibility with standard GStreamer pipelines. The sink supports zero-copy data transfer, multiple listeners, dynamic
connection/disconnection, and automatic format negotiation. Unlike standard InterPipe elements, RS inter elements may
offer better performance characteristics and additional features through their Rust implementation. Common use cases
include high-throughput data distribution, low-latency pipeline communication, implementing scalable media processing
architectures, and building performance-critical applications. The media type parameter ensures proper type safety
and format negotiation.
Implements the true if the RS inter sink was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the RS inter sink.
Note: The actual element disposal is commented out, likely to maintain the named channel
for other pipelines that may still be connected.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the RS inter sink.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The RSInterSink element that manages the named channel.
### GetElement()
Gets the underlying GStreamer element for this RS inter sink.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The Rust-based GStreamer inter sink element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this RS inter sink, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this RS inter sink.
## See Also
---
# Class RSInterSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Bridge.RSInterSourceBlock.html
# Class RSInterSourceBlock
# Class RSInterSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Bridge
**Assembly**: VisioForge.Core.dll
RS (Rust) inter source block that enables high-performance inter-pipeline communication using Rust-based GStreamer elements.
This block acts as a source that listens to a named channel created by an RSInterSinkBlock with the same channel name.
RS inter elements provide optimized performance through Rust implementations while maintaining compatibility with
standard GStreamer pipelines. The source supports zero-copy data transfer, dynamic connection/disconnection, automatic
format negotiation, and seamless pipeline synchronization. Multiple source blocks can connect to the same sink,
enabling one-to-many data distribution patterns. Unlike standard InterPipe elements, RS inter elements may offer
better performance characteristics and additional features through their Rust implementation. Common use cases include
high-throughput data reception, low-latency pipeline communication, implementing scalable media processing architectures,
and building performance-critical applications. The media type parameter ensures proper type safety and format negotiation.
Implements the true if the RS inter source was successfully built; false if an error occurred.
### CleanUp()
Performs cleanup operations for the RS inter source.
Note: The actual element disposal is commented out, likely to maintain flexibility
for dynamic pipeline reconfiguration.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the RS inter source.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The RSInterSource element that manages the channel communication.
### GetElement()
Gets the underlying GStreamer element for this RS inter source.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The Rust-based GStreamer inter source element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### RemoveElementsFromPipeline()
Removes all internal elements from the pipeline.
This method is typically called during cleanup or when reconfiguring the pipeline.
It ensures proper disconnection from the RS inter channel.
```csharp
public override void RemoveElementsFromPipeline()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this RS inter source, providing access to shared resources.
This method is called internally during pipeline construction.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this RS inter source.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.Bridge
Link: api/VisioForge.Core.MediaBlocks.Bridge.html
# Namespace VisioForge.Core.MediaBlocks.Bridge
# Namespace VisioForge.Core.MediaBlocks.Bridge
### Classes
Parameters:
- (): Audio sink block that bridges audio data between different pipelines or applications using a channel-based communication system.
This block acts as an endpoint that receives audio data and makes it available to other pipelines or processes
through a named channel. It enables inter-pipeline communication for audio streams, allowing complex architectures
where audio processing is distributed across multiple pipelines. The bridge uses an efficient in-memory transport
mechanism with minimal latency and supports real-time audio streaming. Common use cases include splitting audio
processing across multiple pipelines, implementing modular audio processing chains, and creating reusable audio
processing components. Pair this sink with a BridgeAudioSourceBlock using the same channel name to establish
a complete audio bridge connection.
Implements the true if the build was successful; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources including the GStreamer element.
This method releases the DeckLink hardware resources and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of DeckLink hardware resources and GStreamer elements.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced manipulation.
This provides access to the underlying DecklinkAudioSink element for direct GStreamer operations.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper containing the DecklinkAudioSink GStreamer element.
### GetDevicesAsync()
Asynchronously enumerates all available DeckLink audio output devices on the system.
This method scans for DeckLink hardware capable of audio output and returns device information.
```csharp
public static Tasktrue if DeckLink audio output is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
This internal method is called by the MediaBlocks framework to establish the pipeline relationship.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class DecklinkAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Decklink.DecklinkAudioSourceBlock.html
# Class DecklinkAudioSourceBlock
# Class DecklinkAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Decklink
**Assembly**: VisioForge.Core.dll
Provides audio input capabilities from Blackmagic DeckLink hardware devices.
This block captures audio streams from professional DeckLink capture cards,
supporting high-quality audio capture for broadcast and professional video production workflows.
The captured audio is processed through a queue and converter for optimal format compatibility.
Implements the true if the build was successful; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources including all GStreamer elements.
This method releases the DeckLink hardware resources, queue, converter, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of DeckLink hardware resources and GStreamer elements.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced manipulation.
This provides access to the underlying DecklinkAudioSource element for direct GStreamer operations.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper containing the DecklinkAudioSource GStreamer element.
### GetDevicesAsync()
Asynchronously enumerates all available DeckLink audio capture devices on the system.
This method scans for DeckLink hardware capable of audio input and returns device information.
```csharp
public static Tasktrue if DeckLink audio capture is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
This internal method is called by the MediaBlocks framework to establish the pipeline relationship.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class DecklinkVideoAudioSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Decklink.DecklinkVideoAudioSinkBlock.html
# Class DecklinkVideoAudioSinkBlock
# Class DecklinkVideoAudioSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Decklink
**Assembly**: VisioForge.Core.dll
Provides combined video and audio output capabilities for Blackmagic DeckLink hardware devices.
This block accepts synchronized video and audio streams and outputs them through professional DeckLink
capture/playback cards, supporting high-quality output for broadcast and professional video production workflows.
The block manages separate video and audio sinks internally to ensure proper synchronization.
Implements the true if both video and audio sinks were built successfully; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources including both video and audio sink elements.
This method releases all DeckLink hardware resources and resets the build state.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new dynamic input pad. Not implemented for this block as it has fixed video and audio inputs.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): Not implemented - throws NotImplementedException.
#### Exceptions
Parameters:
- (NotImplementedException): This block does not support dynamic input creation.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of both video and audio DeckLink hardware resources and GStreamer elements.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper. Returns null as this block manages multiple elements.
Use the individual video and audio sink properties to access specific elements.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this composite block.
### GetElement()
Gets the raw GStreamer element. Returns null as this block manages multiple elements.
Use the individual video and audio sink properties to access specific elements.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always returns null for this composite block.
### GetInput(MediaBlockPadMediaType)
Gets an existing input pad based on the specified media type.
This block has fixed video and audio input pads.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media pad to retrieve (Video or Audio).
#### Returns
Parameters:
- (MediaBlockPad): The corresponding input pad for the specified media type, or null if not found.
### IsAvailable()
Determines whether DeckLink video and audio output functionality is available on the current system.
This checks for the presence of required DeckLink drivers and both video and audio GStreamer plugins.
Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if both DeckLink video and audio output are available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
This internal method is called by the MediaBlocks framework to establish the pipeline relationship.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class DecklinkVideoAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Decklink.DecklinkVideoAudioSourceBlock.html
# Class DecklinkVideoAudioSourceBlock
# Class DecklinkVideoAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Decklink
**Assembly**: VisioForge.Core.dll
Provides combined video and audio input capabilities from Blackmagic DeckLink hardware devices.
This block captures synchronized video and audio streams from professional DeckLink capture cards,
supporting high-quality capture for broadcast and professional video production workflows.
The captured streams are processed through a multi-queue element to maintain synchronization.
Implements the true if both video and audio sources were built successfully; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources including video source, audio source, and multi-queue elements.
This method releases all DeckLink hardware resources and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of both video and audio DeckLink hardware resources and GStreamer elements.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper. Returns null as this block manages multiple elements.
Use the individual video and audio source properties to access specific elements.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this composite block.
### GetDevicesAsync()
Asynchronously enumerates all available DeckLink video capture devices on the system.
This method scans for DeckLink hardware capable of video input and returns device information.
Note: Audio capture availability is determined by the same devices that support video.
```csharp
public static Tasktrue if DeckLink video capture is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
This internal method is called by the MediaBlocks framework to establish the pipeline relationship.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class DecklinkVideoSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Decklink.DecklinkVideoSinkBlock.html
# Class DecklinkVideoSinkBlock
# Class DecklinkVideoSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Decklink
**Assembly**: VisioForge.Core.dll
Provides video output capabilities for Blackmagic DeckLink hardware devices.
This block accepts video streams and outputs them through professional DeckLink capture/playback cards,
supporting high-quality video output for broadcast and professional video production workflows.
Supports various video formats, resolutions, and frame rates as supported by the DeckLink hardware.
Implements the true if the build was successful; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources including the GStreamer element.
This method releases the DeckLink hardware resources and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of DeckLink hardware resources and GStreamer elements.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced manipulation.
This provides access to the underlying DecklinkVideoSink element for direct GStreamer operations.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper containing the DecklinkVideoSink GStreamer element.
### GetDevicesAsync()
Asynchronously enumerates all available DeckLink video output devices on the system.
This method scans for DeckLink hardware capable of video output and returns device information.
```csharp
public static Tasktrue if DeckLink video output is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
This internal method is called by the MediaBlocks framework to establish the pipeline relationship.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class DecklinkVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Decklink.DecklinkVideoSourceBlock.html
# Class DecklinkVideoSourceBlock
# Class DecklinkVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Decklink
**Assembly**: VisioForge.Core.dll
Provides video input capabilities from Blackmagic DeckLink hardware devices.
This block captures professional-quality video streams from DeckLink capture cards, supporting
broadcast standards including SD/HD/4K/8K SDI and HDMI inputs. The captured video is processed
through a queue and converter for optimal format compatibility with downstream pipeline elements.
Common use cases include broadcast production, live streaming, video recording, and professional
video capture workflows requiring frame-accurate synchronization and low latency.
Implements the true if the build was successful; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources including all GStreamer elements.
This method releases the DeckLink hardware resources, queue, converter, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper. Returns null as this block manages multiple elements.
Use GetElement() to access the primary DecklinkVideoSource element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this composite block.
### GetDevicesAsync()
Asynchronously enumerates all available DeckLink video capture devices on the system.
This method scans for DeckLink hardware capable of video input and returns device information
including model names, supported formats, and connection types (SDI/HDMI).
```csharp
public static Tasktrue if DeckLink video capture is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
This internal method is called by the MediaBlocks framework to establish the pipeline relationship.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.Decklink
Link: api/VisioForge.Core.MediaBlocks.Decklink.html
# Namespace VisioForge.Core.MediaBlocks.Decklink
# Namespace VisioForge.Core.MediaBlocks.Decklink
### Classes
Parameters:
- (): Provides audio output capabilities for Blackmagic DeckLink hardware devices.
This block accepts audio streams and outputs them through professional DeckLink capture/playback cards,
supporting high-quality audio output for broadcast and professional video production workflows.
Implements the The UniversalAutoDemuxerBlock is a MediaBlocks component that automatically detects the format of an incoming stream and creates the appropriate demuxer dynamically. It uses GStreamer's typefind element to identify the media format and then instantiates the correct demuxer element on the fly.
Key features: - Automatic format detection using typefind - Dynamic demuxer creation based on detected format - Support for all common container formats (MP4, MKV, AVI, WebM, etc.) - Pre-created output pads based on constructor parameters - Configurable output stream selection (video, audio, subtitle, metadata)
Output pads are pre-created based on constructor parameters: - If renderVideo is true, creates 1 video output pad - If renderAudio is true, creates 1 audio output pad - If renderSubtitle is true, creates 1 subtitle output pad - If renderMetadata is true, creates 1 metadata output pad
## Constructors ### UniversalAutoDemuxerBlock(bool, bool, bool, bool) Initializes a new instance of thetrue if the block was successfully added, false otherwise.
### Build()
Builds the complete pipeline by creating and configuring all underlying GStreamer elements
and establishing the connections between media blocks. This must be called before starting playback.
```csharp
bool Build()
```
#### Returns
Parameters:
- (bool): true if the pipeline was successfully built, false if an error occurred.
### Connect(MediaBlockPad, MediaBlockPad)
Connects two media blocks by linking an output pad from one block to an input pad of another block.
This establishes the data flow path in the media processing pipeline.
```csharp
bool Connect(MediaBlockPad output, MediaBlockPad input)
```
#### Parameters
Parameters:
- output (MediaBlockPad): The output pad from the source media block.
- input (MediaBlockPad): The input pad of the destination media block.
#### Returns
Parameters:
- (bool): true if the connection was established successfully, false otherwise.
### GetBlock(string)
Retrieves a media block from the pipeline by its unique name identifier.
```csharp
IMediaBlock GetBlock(string name)
```
#### Parameters
Parameters:
- name (string): The unique name of the block to retrieve.
#### Returns
Parameters:
- (IMediaBlock): The media block with the specified name, or null if not found.
### GetBlock(MediaBlockType)
Retrieves the first media block of the specified type from the pipeline.
Useful for finding blocks by their functional category (source, sink, effect, etc.).
```csharp
IMediaBlock GetBlock(MediaBlockType type_)
```
#### Parameters
Parameters:
- type_ (MediaBlockType): The type of media block to search for.
#### Returns
Parameters:
- (IMediaBlock): The first media block of the specified type, or null if not found.
### GetContext()
Gets the GStreamer context that provides access to the underlying pipeline infrastructure,
including the GStreamer pipeline object, bus, and other low-level components.
```csharp
ContextX GetContext()
```
#### Returns
Parameters:
- (ContextX): The ContextX instance containing GStreamer pipeline infrastructure.
### Pause()
Pauses the pipeline execution, temporarily halting media processing while maintaining the current state.
The pipeline can be resumed from the current position using Resume().
```csharp
bool Pause()
```
#### Returns
Parameters:
- (bool): true if the pipeline was successfully paused, false otherwise.
### Resume()
Resumes pipeline execution from a paused state, continuing media processing from the current position.
```csharp
bool Resume()
```
#### Returns
Parameters:
- (bool): true if the pipeline was successfully resumed, false otherwise.
### Start(bool)
Starts the pipeline execution, beginning media processing and playback.
The pipeline must be built before calling this method.
```csharp
bool Start(bool onlyPreload = false)
```
#### Parameters
Parameters:
- onlyPreload (bool): If set to true, only preloads the pipeline and sets it to paused state without starting playback.
#### Returns
Parameters:
- (bool): true if the pipeline started successfully, false otherwise.
### Stop(bool)
Stops the pipeline execution and halts all media processing.
This will bring the pipeline to a complete stop and free up resources.
```csharp
bool Stop(bool force = false)
```
#### Parameters
Parameters:
- force (bool): If set to true, forces an immediate stop without waiting for graceful shutdown.
#### Returns
Parameters:
- (bool): true if the pipeline stopped successfully, false otherwise.
### OnError
Event raised when an error occurs during pipeline execution.
Provides detailed error information for debugging and error handling.
```csharp
event EventHandlertrue if the block was successfully built; otherwise, false.
### ClearPads()
Clears all input and output pad references for this media block.
This method is typically called during cleanup or disposal to ensure proper resource release.
```csharp
public void ClearPads()
```
### CreateElements()
Creates the internal GStreamer elements used by this media block.
Override this method in derived classes that need to create GStreamer elements.
This method is typically called from the Build() method.
```csharp
public virtual bool CreateElements()
```
#### Returns
Parameters:
- (bool): true if elements were successfully created; otherwise, false.
### DeepCopy(string)
Creates and returns a deep copy of this media block with a new unique name.
The clone will have the same configuration but will be a separate instance.
Override this method in derived classes to implement block-specific cloning logic.
```csharp
public virtual IMediaBlock DeepCopy(string newName = null)
```
#### Parameters
Parameters:
- newName (string): The name to assign to the cloned block. If null or empty, a name will be auto-generated.
#### Returns
Parameters:
- (IMediaBlock): A new instance of the media block with the same configuration as the original.
#### Exceptions
Parameters:
- (NotImplementedException): Thrown when the derived class has not implemented cloning.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Override this method in derived classes to implement block-specific cleanup logic.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### ~MediaBlock()
Finalizes an instance of the true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### ~MediaBlockPad()
Finalizes an instance of the true, errors are logged but no UI dialogs are shown, useful for headless or service applications.
```csharp
public bool Debug_DisableMessageDialogs { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
Set this to true in scenarios where UI dialogs are inappropriate:
- Background services
- Console applications
- Automated testing
- Applications with custom error handling UI
Always handle the OnError event for production applications rather than relying on default dialogs.
### Debug_Mode
Gets or sets a value indicating whether debug mode is enabled for detailed logging and diagnostics.
When enabled, the pipeline generates comprehensive log files and saves pipeline graph visualizations.
```csharp
public bool Debug_Mode { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
Debug mode features:
- Detailed log files with all operations and state changes
- Pipeline graph DOT files for visualization
- More verbose console output
- Performance may be slightly reduced due to additional logging
Recommended for development and troubleshooting. Disable in production for optimal performance.
### Debug_Telemetry
Gets or sets a value indicating whether anonymous error telemetry is sent to VisioForge during Visual Studio debugging sessions.
This helps improve SDK quality by reporting errors encountered during development. No personal data is transmitted.
```csharp
public bool Debug_Telemetry { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
Telemetry information includes:
- Exception messages and stack traces
- Pipeline configuration (anonymized)
- SDK version and platform information
- Media element usage patterns
Telemetry is only active when debugging in Visual Studio and is automatically disabled in production builds.
No personal information, file paths, or media content is transmitted.
### Loop
Gets or sets a value indicating whether playback automatically restarts from the beginning when the end is reached.
Enables continuous looping playback for presentations, kiosks, or background video displays.
```csharp
public bool Loop { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
When enabled, the OnLoop event is fired each time the media restarts.
The OnStop event will not be fired during loop restarts, only when Stop() is called explicitly.
Loop mode works with seekable sources (files) but not with live streams.
### Name
Gets or sets the name of this pipeline instance for identification in logs and debugging output.
Provides a human-readable identifier to distinguish between multiple pipeline instances.
```csharp
public string Name { get; set; }
```
#### Property Value
Parameters:
- (string):
### PauseOnStop
Gets or sets a value indicating whether the pipeline seeks to the beginning and pauses when playback completes.
When enabled, reaching the end of media results in a paused state at the start position instead of stopping.
```csharp
public bool PauseOnStop { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
This property affects End-of-Stream (EOS) behavior:
- When true: Pipeline seeks to start and enters paused state (ready to play again)
- When false: Pipeline stops and enters Free state (requires full restart)
Useful for video preview scenarios where quick replay is desired without full pipeline restart overhead.
### SDK_BuildDate
Gets the SDK build date indicating when this version of the MediaBlocks framework was compiled.
Useful for version verification and support inquiries.
```csharp
public static DateTime SDK_BuildDate { get; }
```
#### Property Value
Parameters:
- (DateTime):
### SDK_Version
Gets the semantic version number of the MediaBlocks SDK indicating feature set and compatibility level.
Use this for version checks and compatibility verification in your application.
```csharp
public static Version SDK_Version { get; }
```
#### Property Value
Parameters:
- (Version):
### StartPosition
Gets or sets the time position where playback should begin for seekable media sources.
When set before starting, the pipeline will automatically seek to this position after initialization.
```csharp
public TimeSpan? StartPosition { get; set; }
```
#### Property Value
Parameters:
- (TimeSpan ?):
#### Remarks
This property only affects seekable sources like media files. It has no effect on live sources.
The actual seek operation occurs during the pipeline state transition to Paused.
For precise seeking, consider using seekToKeyframe parameter based on your accuracy requirements.
### State
Gets the current playback state of the pipeline (Free, Play, Pause, etc.).
This property reflects the real-time status of media processing operations.
```csharp
public PlaybackState State { get; }
```
#### Property Value
Parameters:
- (PlaybackState):
### StopPosition
Gets or sets the time position where playback should stop for seekable media sources.
When set along with StartPosition, defines a segment of media to play or process.
```csharp
public TimeSpan? StopPosition { get; set; }
```
#### Property Value
Parameters:
- (TimeSpan ?):
#### Remarks
This property enables segment playback by defining the end boundary.
Both StartPosition and StopPosition must be set to create a valid segment.
The pipeline will automatically stop or loop (if Loop is enabled) when reaching this position.
Useful for previewing specific portions of media or processing media segments.
## Methods
### AddBlock(IMediaBlock)
Adds a media processing block to the pipeline.
The block will be included in the pipeline's processing chain and can be connected to other blocks.
This method is thread-safe and can only be called when the pipeline is in the Free state.
```csharp
public bool AddBlock(IMediaBlock block)
```
#### Parameters
Parameters:
- block (IMediaBlock): The media block to add to the pipeline. Cannot be null.
#### Returns
Parameters:
- (bool): true if the block was successfully added; false if the operation failed (e.g., null block, pipeline not in Free state, or block already exists).
#### Examples
var sourceBlock = new UniversalSourceBlock(sourceSettings);
bool success = pipeline.AddBlock(sourceBlock);
if (success)
{
Console.WriteLine("Block added successfully");
}true if the pipeline was successfully built; false if the build process failed.
#### Examples
// Add blocks to pipeline
pipeline.AddBlock(sourceBlock);
pipeline.AddBlock(encoderBlock);
// Build the pipeline
if (pipeline.Build())
{
await pipeline.StartAsync();
}// Stop the pipeline first
await pipeline.StopAsync();
// Clear all blocks
pipeline.ClearBlocks();
// Add new blocks for different processing
pipeline.AddBlock(newSourceBlock);true if the connection was successfully established; false if the operation failed due to null pads, null blocks, or connection errors.
### Connect(MediaBlock, MediaBlock)
Connects two media blocks using their default output and input pads.
This is a convenience method that automatically uses the primary output pad of the source block
and the primary input pad of the destination block to establish the connection.
```csharp
public bool Connect(MediaBlock output, MediaBlock input)
```
#### Parameters
Parameters:
- output (MediaBlock): The source media block that will provide data from its default output pad.
- input (MediaBlock): The destination media block that will receive data on its default input pad.
#### Returns
Parameters:
- (bool): true if the blocks were successfully connected; false if the operation failed due to null blocks or connection errors.
### Connect(MediaBlockPad[][])
Connects multiple media block pad pairs in a batch operation.
This method allows connecting several output pads to input pads in a single call,
useful for establishing multiple connections efficiently in complex pipelines.
```csharp
public bool Connect(MediaBlockPad[][] pairs)
```
#### Parameters
Parameters:
- pairs (MediaBlockPad [ ] [ ]): An array of pad pair arrays, where each inner array contains exactly 2 elements: [output_pad, input_pad].
#### Returns
Parameters:
- (bool): true if all connections were successful; false if any connection failed.
#### Exceptions
Parameters:
- (Exception): Thrown when any pad pair array does not contain exactly 2 elements.
### ConnectLive(MediaBlockPad, MediaBlockPad)
Dynamically connects two media block pads while the pipeline is already running (live connection).
This method enables runtime modification of the pipeline by establishing new connections between blocks
without stopping playback. Useful for dynamic routing scenarios like switching between video sources.
```csharp
public bool ConnectLive(MediaBlockPad output, MediaBlockPad input)
```
#### Parameters
Parameters:
- output (MediaBlockPad): The source pad that will provide media data.
- input (MediaBlockPad): The destination pad that will receive media data.
#### Returns
Parameters:
- (bool): true if the live connection was successfully established; false if the operation failed.
#### Remarks
Live connections allow for dynamic pipeline reconfiguration without interrupting playback.
This is more complex than pre-built connections and may cause brief disruptions in data flow.
Both pads must be in a compatible state for live linking to succeed.
### CreateEditingPipeline(string, ContextX)
Creates a specialized MediaBlocksPipeline configured for non-linear video editing workflows.
This factory method initializes a pipeline with timeline editing engine support for timeline-based editing.
```csharp
public static MediaBlocksPipeline CreateEditingPipeline(string name = null, ContextX context = null)
```
#### Parameters
Parameters:
- name (string): Optional pipeline name for identification in logs and debugging.
- context (ContextX): Optional logging context for centralized logging.
#### Returns
Parameters:
- (MediaBlocksPipeline): A new MediaBlocksPipeline instance configured with editing capabilities.
#### Remarks
The editing pipeline uses the timeline editing engine which provides:
- Timeline-based editing with multiple layers
- Non-linear editing capabilities
- Transition and effect support
- Project management
This is distinct from the standard playback/recording pipeline and is intended for video editing applications.
### Debug_GetPipeline()
Gets the current media pipeline structure as a DOT format string for programmatic analysis or visualization.
This method returns the raw DOT graph data without writing to a file.
```csharp
public string Debug_GetPipeline()
```
#### Returns
Parameters:
- (string): DOT format string representing the complete pipeline structure with all elements, pads, and connections,
or empty string if the pipeline is not available or DOT generation fails.
#### Remarks
The returned DOT string includes:
- All media elements with their properties
- Pad connections and caps
- Element states
- Data flow directions
Use this method when you need to:
- Programmatically analyze pipeline structure
- Send pipeline graphs over network
- Store graphs in databases
- Generate custom visualizations
The DOT format can be processed by Graphviz or other graph visualization libraries.
### Debug_SavePipeline(string)
Saves the current media pipeline structure to a DOT file for visualization and debugging.
The DOT file can be rendered into a graph image using Graphviz tools to visualize the complete pipeline structure.
```csharp
public void Debug_SavePipeline(string name)
```
#### Parameters
Parameters:
- name (string): The base filename for the DOT file (without extension). The .dot extension will be added automatically.
The file will be saved to the Debug_Dir directory.
#### Remarks
Pipeline graphs show:
- All media elements in the pipeline
- Pad connections between elements
- Element properties and states
- Caps (capabilities) negotiated between elements
To view the graph:
1. Install Graphviz (https://graphviz.org/)
2. Run: dot -Tpng graph.dot -o graph.png
3. Open the resulting PNG file
This is invaluable for debugging pad linking issues, caps negotiation problems, and understanding pipeline structure.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### DisposeAsync()
Disposes the asynchronous.
```csharp
public ValueTask DisposeAsync()
```
#### Returns
Parameters:
- (ValueTask): System.Threading.Tasks.ValueTask.
### Duration()
Gets the total duration of the media content in the pipeline.
This method queries the pipeline for the total duration of the media being processed.
Duration is only available for seekable sources like files; live sources will return TimeSpan.Zero.
```csharp
public TimeSpan Duration()
```
#### Returns
Parameters:
- (TimeSpan): A var duration = pipeline.Duration();
if (duration > TimeSpan.Zero)
{
Console.WriteLine($"Media duration: {duration:hh\\:mm\\:ss}");
}
else
{
Console.WriteLine("Duration not available (live source)");
}null if no block is found or the name is invalid.
#### Examples
var sourceBlock = pipeline.GetBlock("VideoSource");
if (sourceBlock != null)
{
// Use the retrieved block
Console.WriteLine($"Found block: {sourceBlock.Name}");
}null if no matching block is found.
#### Examples
var videoRenderer = pipeline.GetBlock(MediaBlockType.VideoRenderer);
if (videoRenderer is VideoRendererBlock renderer)
{
// Configure the video renderer
renderer.SetOutputSize(1920, 1080);
}true if the frame step was successful; false if the operation failed or video renderer is unavailable.
#### Remarks
Frame stepping requires a video renderer to be present in the pipeline.
The pipeline will be automatically paused before stepping to the next frame.
Frame stepping precision depends on the video codec and whether frames are keyframes or predictive frames.
### OnPropertyChanged(string)
Raises the PropertyChanged event for the specified property.
This method is called automatically when properties are modified to notify listeners of changes.
```csharp
protected virtual void OnPropertyChanged(string propertyName = null)
```
#### Parameters
Parameters:
- propertyName (string): The name of the property that changed. This is automatically populated by the CallerMemberName attribute.
### Pause()
Pauses the media pipeline playback.
This method transitions the pipeline from playing state to paused state, maintaining the current position.
Playback can be resumed later using Resume() or ResumeAsync() methods.
```csharp
public bool Pause()
```
#### Returns
Parameters:
- (bool): true if the pipeline was successfully paused; false if the operation failed or the pipeline is not available.
#### Examples
if (pipeline.Pause())
{
Console.WriteLine("Pipeline paused successfully");
// Later resume playback
pipeline.Resume();
}true, seeks to the nearest keyframe for faster seeking but potentially less precise positioning. If false, seeks to the exact position which may be slower but more accurate.
### Position_SetAsync(TimeSpan, bool)
Asynchronously sets the playback position (seeking) without blocking the calling thread.
This is the recommended method for seeking from UI threads to maintain responsiveness.
```csharp
public Task Position_SetAsync(TimeSpan position, bool seekToKeyframe = false)
```
#### Parameters
Parameters:
- position (TimeSpan): The target position to seek to in the media timeline.
- seekToKeyframe (bool): If true, seeks to the nearest keyframe for faster seeking but potentially less precise positioning.
If false, seeks to the exact position which may be slower but more accurate.
#### Returns
Parameters:
- (Task): A Task representing the asynchronous seek operation.
### Position_SetRange(TimeSpan, TimeSpan, bool)
Sets the playback range by seeking to a specific start and stop position in the media.
This method performs a segment seek operation to limit playback to the specified time range.
```csharp
public void Position_SetRange(TimeSpan startPosition, TimeSpan stopPosition, bool seekToKeyframe = false)
```
#### Parameters
Parameters:
- startPosition (TimeSpan): The position where playback should begin.
- stopPosition (TimeSpan): The position where playback should end.
- seekToKeyframe (bool): If true, seeks to the nearest keyframe for more accurate positioning; if false, seeks to exact position.
### Position_SetRangeAsync(TimeSpan, TimeSpan, bool)
Asynchronously sets the playback range by seeking to a specific start and stop position in the media.
This method performs a segment seek operation to limit playback to the specified time range without blocking the calling thread.
```csharp
public Task Position_SetRangeAsync(TimeSpan startPosition, TimeSpan stopPosition, bool seekToKeyframe = false)
```
#### Parameters
Parameters:
- startPosition (TimeSpan): The position where playback should begin.
- stopPosition (TimeSpan): The position where playback should end.
- seekToKeyframe (bool): If true, seeks to the nearest keyframe for more accurate positioning; if false, seeks to exact position.
#### Returns
Parameters:
- (Task): A Task representing the asynchronous seek operation.
### Rate_Get()
Gets the current playback rate (speed) of the media pipeline.
The rate determines how fast the media plays relative to normal speed (1.0 = normal, 2.0 = double speed, 0.5 = half speed).
```csharp
public double Rate_Get()
```
#### Returns
Parameters:
- (double): A true if the rate was successfully changed; false if the operation failed due to missing video renderer or other errors.
### Rate_SetAsync(double)
Asynchronously sets the playback rate (speed) without blocking the calling thread.
This is the recommended method for rate changes from UI threads to maintain responsiveness.
```csharp
public Tasktrue if the rate change was successful, false otherwise.
### Resume()
Resumes media pipeline playback from a paused state.
This method transitions the pipeline from paused state back to playing state,
continuing from the current position without seeking.
```csharp
public bool Resume()
```
#### Returns
Parameters:
- (bool): true if the pipeline was successfully resumed; false if the operation failed or the pipeline is not available.
#### Examples
// Pause the pipeline
pipeline.Pause();
// Later resume from the same position
if (pipeline.Resume())
{
Console.WriteLine("Playback resumed successfully");
}true if resume was successful, false otherwise.
### SendEOS()
Sends an End-of-Stream (EOS) event to the pipeline for graceful playback termination.
This method allows the pipeline to finish processing any remaining data before stopping,
ensuring proper file closure and resource cleanup. This is the recommended way to stop recording or playback.
```csharp
public void SendEOS()
```
#### Examples
// Gracefully stop recording to ensure file integrity
pipeline.SendEOS();
// Wait for the pipeline to finish processing
await pipeline.WaitForStateChangeAsync(PlaybackState.Stop);pipeline.SetLicenseKey("your_license_key_here", "username", "email@example.com");true only preload and set to Pause.
#### Returns
Parameters:
- (bool): true if successfull, false otherwise.
### StartAsync(bool)
Starts the media pipeline asynchronously for playback or recording.
This method builds the media pipeline, connects all media blocks, and transitions to the playing state.
Optionally, the pipeline can be preloaded to a paused state for faster subsequent playback.
```csharp
public Tasktrue, the pipeline will be built and preloaded but remain in paused state instead of playing. This allows for faster playback startup later.
#### Returns
Parameters:
- (Task < bool >): A true if the pipeline started successfully; otherwise, false.
#### Examples
// Standard playback start
bool started = await pipeline.StartAsync();
if (started)
{
Console.WriteLine("Pipeline started successfully");
}
// Preload for faster subsequent playback
bool preloaded = await pipeline.StartAsync(onlyPreload: true);
if (preloaded)
{
// Later start actual playback quickly
await pipeline.ResumeAsync();
}true, forces immediate pipeline shutdown without waiting for graceful EOS processing. For file outputs, this may cause incomplete frames or file corruption. Use graceful shutdown (false) for production recording scenarios.
#### Returns
Parameters:
- (bool): true if the pipeline was successfully stopped; false if the operation failed or stop was already in progress.
### StopAsync(bool)
Asynchronously stops the media pipeline and halts all processing operations without blocking the calling thread.
This is the recommended method for stopping from UI threads to maintain responsiveness.
```csharp
public Tasktrue, forces immediate pipeline shutdown without waiting for graceful EOS (End-of-Stream) processing.
For file outputs, this may cause incomplete frames or file corruption.
Use graceful shutdown (false) for production recording scenarios to ensure proper file finalization.
#### Returns
Parameters:
- (Task < bool >): A Task that completes with a boolean value: true if stop was successful, false if already stopped.
### ToString()
Returns a true if the download element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this NVIDIA data download block.
This method disposes of the GPU download element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the NVIDIA data download element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GPU download element.
### GetElement()
Gets the underlying GStreamer element that performs the GPU memory download.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the NVIDIA data downloader.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for NVIDIA GPU hardware and required CUDA libraries.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA hardware acceleration is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this NVIDIA data download block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class NVDataUploadBlock
Link: api/VisioForge.Core.MediaBlocks.Nvidia.NVDataUploadBlock.html
# Class NVDataUploadBlock
# Class NVDataUploadBlock
**Namespace**: VisioForge.Core.MediaBlocks.Nvidia
**Assembly**: VisioForge.Core.dll
NVIDIA data upload block for transferring video data from system memory to GPU.
This block efficiently uploads video frames from system memory (CPU) to NVIDIA GPU
memory (CUDA) for hardware-accelerated processing. It's the entry point for GPU
acceleration in video pipelines, enabling subsequent GPU-based operations like
encoding, decoding, effects, and transformations. Supports high-performance memory
transfers with minimal CPU overhead, optimized for NVIDIA CUDA architecture.
Essential for leveraging NVIDIA hardware acceleration in video processing workflows.
Implements the true if the upload element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this NVIDIA data upload block.
This method disposes of the GPU upload element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the NVIDIA data upload element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GPU upload element.
### GetElement()
Gets the underlying GStreamer element that performs the GPU memory upload.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the NVIDIA data uploader.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for NVIDIA GPU hardware and required CUDA libraries.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA hardware acceleration is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this NVIDIA data upload block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class NVDSDewarpBlock
Link: api/VisioForge.Core.MediaBlocks.Nvidia.NVDSDewarpBlock.html
# Class NVDSDewarpBlock
# Class NVDSDewarpBlock
**Namespace**: VisioForge.Core.MediaBlocks.Nvidia
**Assembly**: VisioForge.Core.dll
NVIDIA DeepStream dewarp block for GPU-accelerated fisheye image dewarping.
This block performs high-performance fisheye lens distortion correction using NVIDIA CUDA,
supporting real-time dewarping of camera feeds from fisheye lenses. Essential for
security camera systems, automotive applications, and panoramic video processing
where fisheye cameras provide wide field-of-view but require geometric correction.
Leverages NVIDIA DeepStream SDK for optimal GPU performance and memory management.
Implements the true if the dewarp element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this NVIDIA DeepStream dewarp block.
This method disposes of the GPU dewarp filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the NVIDIA DeepStream dewarp element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the dewarp functionality.
### GetElement()
Gets the underlying GStreamer element that performs the GPU dewarp operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the NVIDIA DeepStream dewarp filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for NVIDIA GPU hardware and required DeepStream libraries.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA DeepStream dewarp functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this NVIDIA DeepStream dewarp block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class NVVideoConverterBlock
Link: api/VisioForge.Core.MediaBlocks.Nvidia.NVVideoConverterBlock.html
# Class NVVideoConverterBlock
# Class NVVideoConverterBlock
**Namespace**: VisioForge.Core.MediaBlocks.Nvidia
**Assembly**: VisioForge.Core.dll
NVIDIA video converter block for GPU-accelerated format conversion and color space transformation.
This block performs high-performance video format conversions entirely on NVIDIA GPU hardware,
supporting various pixel formats (YUV, RGB, NV12, etc.) and color space transformations.
Leverages CUDA cores for parallel processing, achieving real-time conversion speeds even
for high-resolution video. Essential for GPU-accelerated pipelines where format compatibility
is required between different processing stages. Minimizes CPU usage and memory bandwidth
by keeping data on the GPU throughout the conversion process.
Implements the true if the converter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this NVIDIA video converter block.
This method disposes of the GPU converter element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the NVIDIA video converter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GPU converter.
### GetElement()
Gets the underlying GStreamer element that performs the GPU format conversion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the NVIDIA video converter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for NVIDIA GPU hardware and required CUDA libraries.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA hardware acceleration is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this NVIDIA video converter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class NVVideoResizeBlock
Link: api/VisioForge.Core.MediaBlocks.Nvidia.NVVideoResizeBlock.html
# Class NVVideoResizeBlock
# Class NVVideoResizeBlock
**Namespace**: VisioForge.Core.MediaBlocks.Nvidia
**Assembly**: VisioForge.Core.dll
NVIDIA video resize block for GPU-accelerated video scaling and resolution conversion.
This block performs high-performance video resizing entirely on NVIDIA GPU hardware,
supporting upscaling and downscaling with various interpolation algorithms optimized
for CUDA. Achieves real-time performance even for 4K/8K video processing by leveraging
parallel GPU cores. Essential for resolution adaptation, multi-resolution encoding,
video wall applications, and any scenario requiring efficient video scaling.
Maintains video quality through advanced GPU-based filtering while minimizing latency.
Implements the true if the resize filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this NVIDIA video resize block.
This method disposes of the GPU resize filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the NVIDIA video resize filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GPU resize filter.
### GetElement()
Gets the underlying GStreamer element that performs the GPU video resizing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the NVIDIA resize filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for NVIDIA GPU hardware and required CUDA libraries.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA hardware acceleration is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this NVIDIA video resize block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.Nvidia
Link: api/VisioForge.Core.MediaBlocks.Nvidia.html
# Namespace VisioForge.Core.MediaBlocks.Nvidia
# Namespace VisioForge.Core.MediaBlocks.Nvidia
### Classes
Parameters:
- (): NVIDIA DeepStream dewarp block for GPU-accelerated fisheye image dewarping.
This block performs high-performance fisheye lens distortion correction using NVIDIA CUDA,
supporting real-time dewarping of camera feeds from fisheye lenses. Essential for
security camera systems, automotive applications, and panoramic video processing
where fisheye cameras provide wide field-of-view but require geometric correction.
Leverages NVIDIA DeepStream SDK for optimal GPU performance and memory management.
Implements the true if the dewarp element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV dewarp block.
This method disposes of the dewarp element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV dewarp element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the dewarp functionality.
### GetElement()
Gets the underlying GStreamer element that performs the dewarp operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV dewarp filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and geometric transformation support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV dewarp functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV dewarp block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVDilateBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVDilateBlock.html
# Class CVDilateBlock
# Class CVDilateBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV dilate block for morphological image processing operations.
This block performs dilation, a fundamental morphological operation that expands white regions
(foreground objects) in binary or grayscale images. Dilation is commonly used for noise removal,
object enhancement, filling gaps in contours, and connecting nearby objects. The operation uses
a structuring element (kernel) that defines the shape and size of the dilation. Essential for
image preprocessing in computer vision applications, medical imaging, and object detection.
Implements the true if the dilate element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV dilate block.
This method disposes of the dilate element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV dilate element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the dilate functionality.
### GetElement()
Gets the underlying GStreamer element that performs the dilate operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV dilate filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and morphological operations support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV dilate functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV dilate block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVEdgeDetectBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVEdgeDetectBlock.html
# Class CVEdgeDetectBlock
# Class CVEdgeDetectBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV edge detection block for identifying boundaries and contours in video streams.
This block performs edge detection using various computer vision algorithms including Canny,
Sobel, Laplacian, and Scharr operators. Edge detection is fundamental for object recognition,
feature extraction, image segmentation, and computer vision applications. The block provides
configurable threshold parameters, gradient calculations, and noise reduction capabilities.
Essential for medical imaging, industrial inspection, autonomous vehicles, and surveillance systems.
Implements the true if the edge detection element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV edge detection block.
This method disposes of the edge detection element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV edge detection element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the edge detection functionality.
### GetElement()
Gets the underlying GStreamer element that performs the edge detection operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV edge detection filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and edge detection algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV edge detection functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV edge detection block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVEqualizeHistogramBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVEqualizeHistogramBlock.html
# Class CVEqualizeHistogramBlock
# Class CVEqualizeHistogramBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV histogram equalization block for automatic image contrast enhancement.
This block performs histogram equalization to improve image contrast by redistributing
pixel intensities across the full dynamic range. The algorithm analyzes the image histogram
and applies a transformation that spreads out the most frequent intensity values, resulting
in enhanced visual quality. Essential for medical imaging, surveillance systems, and
low-light video enhancement where contrast improvement is critical for analysis.
Implements the true if the histogram equalization element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV histogram equalization block.
This method disposes of the histogram equalization element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV histogram equalization element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the histogram equalization functionality.
### GetElement()
Gets the underlying GStreamer element that performs the histogram equalization operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV histogram equalization filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and histogram processing support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV histogram equalization functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV histogram equalization block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVErodeBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVErodeBlock.html
# Class CVErodeBlock
# Class CVErodeBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV erode block for morphological image processing operations.
This block performs erosion, a fundamental morphological operation that shrinks white regions
(foreground objects) in binary or grayscale images. Erosion is commonly used for noise removal,
thin line detection, separating connected objects, and removing small artifacts. The operation
uses a structuring element (kernel) that defines the shape and size of the erosion. Often
paired with dilation for opening/closing operations in computer vision preprocessing.
Implements the true if the erode element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV erode block.
This method disposes of the erode element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV erode element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the erode functionality.
### GetElement()
Gets the underlying GStreamer element that performs the erode operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV erode filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and morphological operations support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV erode functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV erode block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVFaceBlurBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVFaceBlurBlock.html
# Class CVFaceBlurBlock
# Class CVFaceBlurBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV face blur block for automatic privacy protection in video streams.
This block combines face detection with blur effects to automatically obscure faces
for privacy compliance. Uses machine learning algorithms to detect human faces in
real-time and applies configurable blur effects to protect individual privacy.
Essential for surveillance systems, social media platforms, and video conferencing
applications where privacy regulations require face anonymization. Supports multiple
blur algorithms and adjustable detection sensitivity for various lighting conditions.
Implements the true if the face blur element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV face blur block.
This method disposes of the face blur element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV face blur element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the face blur functionality.
### GetElement()
Gets the underlying GStreamer element that performs the face blur operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV face blur filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and face detection/blurring support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV face blur functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV face blur block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVFaceDetectBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVFaceDetectBlock.html
# Class CVFaceDetectBlock
# Class CVFaceDetectBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV face detection block for identifying and tracking human faces in video streams.
This block uses advanced computer vision algorithms including Haar cascades, LBP (Local Binary Patterns),
and deep learning models to detect faces in real-time. Provides configurable detection parameters,
face tracking capabilities, and event notifications when faces are found. Essential for security
systems, attendance tracking, emotion recognition, and interactive applications. Supports multiple
face detection simultaneously with bounding box coordinates and confidence scores.
Implements the true if the face detection element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV face detection block.
This method disposes of the face detection element, unsubscribes from events, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV face detection element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the face detection functionality.
### GetElement()
Gets the underlying GStreamer element that performs the face detection operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV face detection filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and face detection algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV face detection functionality is available; otherwise, false.
### ProcessBusMessage(Structure)
Processes GStreamer bus messages for face detection events and notifications.
This method handles internal communication and triggers face detection events.
```csharp
public void ProcessBusMessage(Structure data)
```
#### Parameters
Parameters:
- data (Structure): The GStreamer message data containing detection information.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV face detection block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### FaceDetected
Event raised when faces are detected in the video stream.
Provides face coordinates, confidence scores, and detection metadata.
```csharp
public event EventHandlertrue if the hand detection element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV hand detection block.
This method disposes of the hand detection element, unsubscribes from events, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV hand detection element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the hand detection functionality.
### GetElement()
Gets the underlying GStreamer element that performs the hand detection operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV hand detection filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and hand detection algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV hand detection functionality is available; otherwise, false.
### ProcessBusMessage(Structure)
Processes GStreamer bus messages for hand detection events and notifications.
This method handles internal communication and triggers hand detection events.
```csharp
public void ProcessBusMessage(Structure data)
```
#### Parameters
Parameters:
- data (Structure): The GStreamer message data containing detection information.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV hand detection block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### HandDetected
Event raised when hands are detected in the video stream.
Provides hand coordinates, gesture information, and detection metadata.
```csharp
public event EventHandlertrue if the Laplacian element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV Laplacian block.
This method disposes of the Laplacian element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV Laplacian element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the Laplacian functionality.
### GetElement()
Gets the underlying GStreamer element that performs the Laplacian operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV Laplacian filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and Laplacian operator support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV Laplacian functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV Laplacian block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVMotionCellsBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVMotionCellsBlock.html
# Class CVMotionCellsBlock
# Class CVMotionCellsBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV motion detection block for intelligent surveillance and movement analysis.
This block divides the video frame into a grid of cells and detects motion within each cell,
providing fine-grained motion analysis capabilities. Uses background subtraction and frame
differencing algorithms to identify moving objects and track motion patterns. Essential for
security systems, traffic monitoring, and automated surveillance applications. Provides
configurable sensitivity, region-of-interest selection, and motion event notifications.
Implements the true if the motion detection element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV motion detection block.
This method disposes of the motion detection element, unsubscribes from events, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV motion detection element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the motion detection functionality.
### GetElement()
Gets the underlying GStreamer element that performs the motion detection operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV motion detection filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and motion detection algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV motion detection functionality is available; otherwise, false.
### ProcessBusMessage(Structure)
Processes GStreamer bus messages for motion detection events and notifications.
This method handles internal communication and triggers motion detection events.
```csharp
public void ProcessBusMessage(Structure data)
```
#### Parameters
Parameters:
- data (Structure): The GStreamer message data containing detection information.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV motion detection block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### MotionDetected
Event raised when motion is detected in the video stream.
Provides motion cell coordinates, intensity levels, and detection metadata.
```csharp
public event EventHandlertrue if the smoothing element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV smoothing block.
This method disposes of the smoothing element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV smoothing element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the smoothing functionality.
### GetElement()
Gets the underlying GStreamer element that performs the smoothing operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV smoothing filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and smoothing algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV smoothing functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV smoothing block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVSobelBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVSobelBlock.html
# Class CVSobelBlock
# Class CVSobelBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV Sobel edge detection block for gradient-based image analysis.
This block applies the Sobel operator to detect edges by calculating image gradients
in horizontal and vertical directions. The Sobel filter is particularly effective
for edge detection in noisy images due to its built-in smoothing capabilities.
Provides separate X and Y gradient calculations, magnitude computation, and directional
filtering options. Essential for computer vision applications, feature extraction,
and image preprocessing where robust edge detection is required.
Implements the true if the Sobel element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV Sobel block.
This method disposes of the Sobel element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV Sobel element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the Sobel functionality.
### GetElement()
Gets the underlying GStreamer element that performs the Sobel operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV Sobel filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and Sobel operator support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV Sobel functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV Sobel block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVTemplateMatchBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVTemplateMatchBlock.html
# Class CVTemplateMatchBlock
# Class CVTemplateMatchBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV template matching block for object detection and pattern recognition.
This block searches for specific template images within the video stream using various
correlation algorithms including normalized cross-correlation, squared difference, and
correlation coefficient methods. Essential for automated inspection, object tracking,
quality control, and computer vision applications where specific patterns or objects
need to be located. Provides configurable matching algorithms, threshold settings,
and multiple match detection capabilities.
Implements the true if the template matching element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV template matching block.
This method disposes of the template matching element, unsubscribes from events, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV template matching element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the template matching functionality.
### GetElement()
Gets the underlying GStreamer element that performs the template matching operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV template matching filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and template matching algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV template matching functionality is available; otherwise, false.
### ProcessBusMessage(Structure)
Processes GStreamer bus messages for template matching events and notifications.
This method handles internal communication and triggers template matching events.
```csharp
public void ProcessBusMessage(Structure data)
```
#### Parameters
Parameters:
- data (Structure): The GStreamer message data containing detection information.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV template matching block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### TemplateMatch
Event raised when template matches are found in the video stream.
Provides match coordinates, confidence scores, and detection metadata.
```csharp
public event EventHandlertrue if the text overlay element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV text overlay block.
This method disposes of the text overlay element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV text overlay element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the text overlay functionality.
### GetElement()
Gets the underlying GStreamer element that performs the text overlay operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV text overlay filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and text rendering support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV text overlay functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV text overlay block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CVTrackerBlock
Link: api/VisioForge.Core.MediaBlocks.OpenCV.CVTrackerBlock.html
# Class CVTrackerBlock
# Class CVTrackerBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenCV
**Assembly**: VisioForge.Core.dll
OpenCV object tracking block for continuous monitoring of moving objects in video streams.
This block implements advanced tracking algorithms including KCF (Kernelized Correlation Filters),
CSRT (Channel and Spatial Reliability Tracker), Median Flow, and MIL (Multiple Instance Learning)
trackers. Provides robust object tracking capabilities for surveillance, sports analysis,
autonomous vehicles, and interactive applications. Supports initialization from bounding boxes,
adaptive model updates, and tracking confidence reporting. Essential for maintaining object
identity across frames despite occlusions, scale changes, and appearance variations.
Implements the true if the tracking element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenCV tracking block.
This method disposes of the tracking element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenCV tracking element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the tracking functionality.
### GetElement()
Gets the underlying GStreamer element that performs the tracking operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenCV tracking filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenCV library availability and object tracking algorithm support.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenCV tracking functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenCV tracking block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.OpenCV
Link: api/VisioForge.Core.MediaBlocks.OpenCV.html
# Namespace VisioForge.Core.MediaBlocks.OpenCV
# Namespace VisioForge.Core.MediaBlocks.OpenCV
### Classes
Parameters:
- (): OpenCV dewarp block for geometric distortion correction in video streams.
This block performs lens distortion correction, perspective transformation, and barrel/pincushion
distortion removal using OpenCV's computer vision algorithms. Essential for correcting footage
from wide-angle lenses, fisheye cameras, or action cameras that produce geometric distortions.
Supports various distortion models including radial and tangential distortion correction.
Commonly used in surveillance systems, automotive applications, and 360-degree video processing.
Implements the true if the alpha element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenGL alpha block.
This method disposes of the alpha filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenGL alpha filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the alpha functionality.
### GetElement()
Gets the underlying GStreamer element that performs the alpha blending operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenGL alpha filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenGL support and GPU shader capabilities.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenGL alpha functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenGL alpha block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GLBlurBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLBlurBlock.html
# Class GLBlurBlock
# Class GLBlurBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL blur block for GPU-accelerated image smoothing and blur effects.
This block provides high-performance blur processing using OpenGL shaders and GPU
parallel processing capabilities. Supports various blur algorithms including Gaussian,
box blur, and motion blur with configurable intensity and direction parameters.
Essential for creating cinematic effects, depth-of-field simulation, background
defocusing, and artistic video treatments. Achieves real-time performance even
with high-resolution video through efficient GPU computation.
Implements the true if the blur element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenGL blur block.
This method disposes of the blur filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenGL blur filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the blur functionality.
### GetElement()
Gets the underlying GStreamer element that performs the blur operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenGL blur filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenGL support and GPU shader capabilities.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenGL blur functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenGL blur block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GLBulgeBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLBulgeBlock.html
# Class GLBulgeBlock
# Class GLBulgeBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL bulge effect block for spherical geometric distortion and lens simulation.
This block creates a bulge or bubble effect that simulates looking through a convex lens
or magnifying glass. Uses GPU-accelerated OpenGL shaders to perform real-time geometric
transformation that expands the center of the image while compressing the edges.
Essential for creating artistic visual effects, lens simulation, virtual reality content,
and creative video transformations. Provides configurable bulge intensity and center positioning.
Implements the true if the bulge element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenGL bulge block.
This method disposes of the bulge filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenGL bulge filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the bulge functionality.
### GetElement()
Gets the underlying GStreamer element that performs the bulge operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenGL bulge filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenGL support and GPU shader capabilities.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenGL bulge functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenGL bulge block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GLColorBalanceBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLColorBalanceBlock.html
# Class GLColorBalanceBlock
# Class GLColorBalanceBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL color balance block for professional color correction and grading.
This block provides GPU-accelerated color adjustment capabilities including hue, saturation,
brightness, contrast, gamma correction, and white balance adjustments. Uses OpenGL shaders
for real-time color manipulation with professional-grade precision. Essential for broadcast
video production, color grading workflows, and correcting color cast issues. Supports
RGB channel-specific adjustments and maintains color accuracy throughout the processing pipeline.
Implements the true if the color balance element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenGL color balance block.
This method disposes of the color balance filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenGL color balance filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the color balance functionality.
### GetElement()
Gets the underlying GStreamer element that performs the color balance operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenGL color balance filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenGL support and GPU shader capabilities.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenGL color balance functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenGL color balance block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GLDeinterlaceBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLDeinterlaceBlock.html
# Class GLDeinterlaceBlock
# Class GLDeinterlaceBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL deinterlace block for GPU-accelerated interlaced video conversion.
This block converts interlaced video (where odd and even lines are captured at different times)
into progressive video using advanced OpenGL shader algorithms. Essential for processing
legacy broadcast content, security camera footage, and older video formats. Provides
multiple deinterlacing algorithms including line doubling, motion-adaptive, and temporal
interpolation methods. Achieves superior quality and performance compared to CPU-based
deinterlacing through GPU parallel processing.
Implements the true if the deinterlace element was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this OpenGL deinterlace block.
This method disposes of the deinterlace filter and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the OpenGL deinterlace filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the deinterlace functionality.
### GetElement()
Gets the underlying GStreamer element that performs the deinterlace operation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the OpenGL deinterlace filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for OpenGL support and GPU shader capabilities.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenGL deinterlace functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this OpenGL deinterlace block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GLDownloadBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLDownloadBlock.html
# Class GLDownloadBlock
# Class GLDownloadBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL GPU to system memory download block for transferring video frames from GPU memory to system memory.
This block is essential for retrieving processed video data from GPU-accelerated OpenGL operations
back to system memory for further CPU-based processing, encoding, or output operations.
Implements the true if the download block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL download operation, including GStreamer elements and GPU memory allocations.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL download block.
Properly disposes of GStreamer elements and GPU memory resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer download element.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the OpenGL download operation.
### IsAvailable()
Determines whether OpenGL download functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OpenGL download operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL download block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this download block.
## See Also
---
# Class GLEquirectangularViewBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLEquirectangularViewBlock.html
# Class GLEquirectangularViewBlock
# Class GLEquirectangularViewBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated equirectangular view block for immersive 360-degree and VR video processing.
Provides GPU-accelerated transformation of equirectangular (spherical) video content into perspective views
with interactive controls for yaw, pitch, roll, and field of view, enabling VR video playback and immersive media experiences.
Implements the true if the equirectangular view block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL equirectangular view operations, including GStreamer elements and GPU VR shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL equirectangular view block.
Properly disposes of GStreamer elements and GPU VR transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer equirectangular view element.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the equirectangular VR view filter.
### IsAvailable()
Determines whether OpenGL equirectangular view functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL VR transformation plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if 360-degree VR view operations are supported; otherwise, false.
### IsModeSupported(VRMode)
Checks if a specific VR mode is supported by the implementing component (e.g., video block, effect, or renderer).
```csharp
public bool IsModeSupported(VRMode mode)
```
#### Parameters
Parameters:
- mode (VRMode): The true if the mode is supported; otherwise, false.
### Update()
Updates the VR view settings dynamically, applying new perspective parameters and view controls in real-time.
```csharp
public void Update()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL equirectangular view block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this equirectangular view block.
### SettingsChanged
Occurs when VR view settings are changed, providing notification for dynamic view parameter updates.
```csharp
public event EventHandlertrue if the fish eye effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL fish eye effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL fish eye effect block.
Properly disposes of GStreamer elements and GPU shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer fish eye filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the fish eye distortion filter.
### IsAvailable()
Determines whether OpenGL fish eye effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL effect plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if fish eye distortion effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL fish eye effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this fish eye effect block.
## See Also
---
# Class GLFlipBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLFlipBlock.html
# Class GLFlipBlock
# Class GLFlipBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated video flip transformation block for horizontal and vertical mirroring operations.
Provides GPU-accelerated flipping capabilities including horizontal flip (mirror), vertical flip,
and combined transformations for creating mirror effects and correcting camera orientations.
Implements the true if the flip transformation block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL flip transformation, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL flip transformation block.
Properly disposes of GStreamer elements and GPU transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer flip filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the flip transformation filter.
### IsAvailable()
Determines whether OpenGL flip transformation functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL transformation plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if flip transformation operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL flip transformation block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this flip transformation block.
## See Also
---
# Class GLGlowLightingBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLGlowLightingBlock.html
# Class GLGlowLightingBlock
# Class GLGlowLightingBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated glow lighting effect block for creating atmospheric luminous effects around bright areas.
Produces cinematic glow and bloom effects by detecting bright regions in the video and extending their
luminosity with soft, diffused light halos that create dramatic lighting atmospheres and enhanced visual impact.
Implements the true if the glow lighting effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL glow lighting effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL glow lighting effect block.
Properly disposes of GStreamer elements and GPU lighting shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer glow lighting filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the glow lighting effect filter.
### IsAvailable()
Determines whether OpenGL glow lighting effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL lighting effect plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if glow lighting effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL glow lighting effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this glow lighting effect block.
## See Also
---
# Class GLGrayscaleBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLGrayscaleBlock.html
# Class GLGrayscaleBlock
# Class GLGrayscaleBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated grayscale conversion block for transforming color video into monochrome output.
Provides GPU-accelerated color-to-grayscale conversion using luminance-based algorithms that maintain
proper brightness levels and contrast while removing color information for artistic or technical purposes.
Implements the true if the grayscale conversion block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL grayscale conversion, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL grayscale conversion block.
Properly disposes of GStreamer elements and GPU color conversion resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer grayscale filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the grayscale conversion filter.
### IsAvailable()
Determines whether OpenGL grayscale conversion functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL color conversion plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if grayscale conversion operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL grayscale conversion block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this grayscale conversion block.
## See Also
---
# Class GLHeatBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLHeatBlock.html
# Class GLHeatBlock
# Class GLHeatBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated heat shimmer effect block for creating thermal distortion and atmospheric heat wave effects.
Simulates the visual distortion seen when looking through hot air, such as heat rising from pavement or fire,
creating dynamic wavering and shimmering effects that add realism to hot environments and thermal scenarios.
Implements the true if the heat effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL heat effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL heat effect block.
Properly disposes of GStreamer elements and GPU distortion shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer heat effect filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the heat distortion effect filter.
### IsAvailable()
Determines whether OpenGL heat effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL distortion effect plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if heat distortion effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL heat effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this heat effect block.
## See Also
---
# Class GLLaplacianBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLLaplacianBlock.html
# Class GLLaplacianBlock
# Class GLLaplacianBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated Laplacian edge detection filter block for advanced image processing and edge enhancement.
Implements the Laplacian operator, a second-order derivative filter that detects edges and fine details
by highlighting areas of rapid intensity change, commonly used for sharpening and feature detection in computer vision applications.
Implements the true if the Laplacian edge detection block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL Laplacian edge detection, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL Laplacian edge detection block.
Properly disposes of GStreamer elements and GPU image processing shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer Laplacian filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the Laplacian edge detection filter.
### IsAvailable()
Determines whether OpenGL Laplacian edge detection functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL image processing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Laplacian edge detection operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL Laplacian edge detection block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this Laplacian edge detection block.
## See Also
---
# Class GLLightTunnelBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLLightTunnelBlock.html
# Class GLLightTunnelBlock
# Class GLLightTunnelBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated light tunnel effect block for creating dramatic radial lighting and tunnel vision effects.
Generates dynamic tunnel-like light patterns that draw the viewer's attention to the center of the frame,
creating cinematic depth effects and dramatic visual focus with customizable radial light distribution.
Implements the true if the light tunnel effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL light tunnel effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL light tunnel effect block.
Properly disposes of GStreamer elements and GPU lighting shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer light tunnel filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the light tunnel effect filter.
### IsAvailable()
Determines whether OpenGL light tunnel effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL lighting effect plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if light tunnel effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL light tunnel effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this light tunnel effect block.
## See Also
---
# Class GLLumaCrossProcessingBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLLumaCrossProcessingBlock.html
# Class GLLumaCrossProcessingBlock
# Class GLLumaCrossProcessingBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated luma cross processing effect block for creating stylized color grading and film-look effects.
Applies cross-channel processing to the luminance component, creating distinctive color shifts and tonal adjustments
that simulate various film stocks and artistic color grading techniques for cinematic visual enhancement.
Implements the true if the luma cross processing block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL luma cross processing, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL luma cross processing block.
Properly disposes of GStreamer elements and GPU color processing shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer luma cross processing filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the luma cross processing filter.
### IsAvailable()
Determines whether OpenGL luma cross processing functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL color processing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if luma cross processing operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL luma cross processing block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this luma cross processing block.
## See Also
---
# Class GLMirrorBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLMirrorBlock.html
# Class GLMirrorBlock
# Class GLMirrorBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated mirror reflection effect block for creating symmetrical video reflections and kaleidoscope patterns.
Provides GPU-accelerated mirroring capabilities that can reflect video content along horizontal, vertical, or diagonal axes,
creating artistic mirror effects, symmetrical compositions, and kaleidoscopic visual patterns for creative video processing.
Implements the true if the mirror reflection block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL mirror reflection, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL mirror reflection block.
Properly disposes of GStreamer elements and GPU transformation shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer mirror filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the mirror reflection filter.
### IsAvailable()
Determines whether OpenGL mirror reflection functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL transformation plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if mirror reflection operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL mirror reflection block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this mirror reflection block.
## See Also
---
# Class GLOverlayBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLOverlayBlock.html
# Class GLOverlayBlock
# Class GLOverlayBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated image overlay block for compositing static images and graphics onto video streams.
Provides GPU-accelerated overlay capabilities with alpha blending, positioning, scaling, and rotation support
for watermarks, logos, graphics overlays, and picture-in-picture compositions with real-time performance.
Implements the true if the overlay block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL overlay operation, including GStreamer elements and GPU compositing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL overlay block.
Properly disposes of GStreamer elements and GPU compositing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer overlay element.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the image overlay compositor.
### IsAvailable()
Determines whether OpenGL overlay functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL compositing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if overlay composition operations are supported; otherwise, false.
### UpdateSettings()
Updates the overlay settings in real-time, allowing dynamic changes to image position, scale, rotation, and alpha blending.
```csharp
public void UpdateSettings()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL overlay block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this overlay block.
## See Also
---
# Class GLResizeBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLResizeBlock.html
# Class GLResizeBlock
# Class GLResizeBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated video resize block for high-performance video scaling and resolution transformation.
Provides GPU-accelerated resizing capabilities with various interpolation algorithms, aspect ratio control,
and optimized scaling operations for real-time video processing with minimal CPU overhead.
Implements the true if the video resize block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL video resize operation, including GStreamer elements and GPU processing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL video resize block.
Properly disposes of GStreamer elements and GPU scaling resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer video resize filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the video resize filter.
### IsAvailable()
Determines whether OpenGL video resize functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL video processing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if video resize operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL video resize block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this video resize block.
## See Also
---
# Class GLSepiaBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLSepiaBlock.html
# Class GLSepiaBlock
# Class GLSepiaBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated sepia tone effect block for creating vintage and nostalgic visual aesthetics.
Applies warm brown and golden color tones that simulate the appearance of aged photographs,
creating classic vintage effects commonly used in artistic video processing and retro styling.
Implements the true if the sepia tone effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL sepia tone effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL sepia tone effect block.
Properly disposes of GStreamer elements and GPU color processing shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer sepia filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the sepia tone effect filter.
### IsAvailable()
Determines whether OpenGL sepia tone effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL color effect plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if sepia tone effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL sepia tone effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this sepia tone effect block.
## See Also
---
# Class GLShaderBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLShaderBlock.html
# Class GLShaderBlock
# Class GLShaderBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated programmable shader block for custom GPU-based video processing and effects.
Provides high-performance custom shader execution capabilities using GLSL vertex and fragment shaders
to create custom visual effects, color transformations, and advanced video processing operations with full GPU acceleration.
Implements the true if the shader block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL shader operations, including GStreamer elements and compiled GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL shader block.
Properly disposes of GStreamer elements and GPU shader program resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer shader filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the custom shader filter.
### IsAvailable()
Determines whether OpenGL shader functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL shader execution plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if custom shader operations are supported; otherwise, false.
### Update()
Updates the shader programs and uniform variables with the current settings.
Recompiles and reloads GLSL shader code and applies new uniform variable values for dynamic shader effects.
```csharp
public void Update()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL shader block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this shader block.
## See Also
---
# Class GLSinCityBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLSinCityBlock.html
# Class GLSinCityBlock
# Class GLSinCityBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated Sin City noir effect block for creating dramatic black and white compositions with selective color.
Implements the distinctive film noir visual style with high contrast monochrome imagery and selective color preservation,
creating cinematic effects reminiscent of graphic novel aesthetics and dramatic storytelling visuals.
Implements the true if the Sin City noir effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL Sin City noir effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL Sin City noir effect block.
Properly disposes of GStreamer elements and GPU color processing shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer Sin City filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the Sin City noir effect filter.
### IsAvailable()
Determines whether OpenGL Sin City noir effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL color processing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Sin City noir effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL Sin City noir effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this Sin City noir effect block.
## See Also
---
# Class GLSobelBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLSobelBlock.html
# Class GLSobelBlock
# Class GLSobelBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated Sobel edge detection filter block for advanced computer vision and image analysis.
Implements the Sobel operator, a first-order derivative filter that detects edges by computing gradients
in horizontal and vertical directions, widely used for edge detection, feature extraction, and image sharpening in computer vision applications.
Implements the true if the Sobel edge detection block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL Sobel edge detection, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL Sobel edge detection block.
Properly disposes of GStreamer elements and GPU image processing shader resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer Sobel filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the Sobel edge detection filter.
### IsAvailable()
Determines whether OpenGL Sobel edge detection functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL image processing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Sobel edge detection operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL Sobel edge detection block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this Sobel edge detection block.
## See Also
---
# Class GLSquareBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLSquareBlock.html
# Class GLSquareBlock
# Class GLSquareBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated square geometric distortion effect block for creating angular and pixelated visual effects.
Applies square-based geometric transformations that create blocky, angular distortions and pixelation effects,
useful for creating retro gaming aesthetics, digital art effects, and stylized geometric video processing.
Implements the true if the square geometric effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL square geometric effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL square geometric effect block.
Properly disposes of GStreamer elements and GPU geometric transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer square filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the square geometric effect filter.
### IsAvailable()
Determines whether OpenGL square geometric effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL geometric transformation plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if square geometric effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL square geometric effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this square geometric effect block.
## See Also
---
# Class GLSqueezeBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLSqueezeBlock.html
# Class GLSqueezeBlock
# Class GLSqueezeBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated squeeze geometric distortion effect block for creating compression and pinch visual effects.
Applies radial compression transformations that squeeze or pinch portions of the video towards a central point,
creating dramatic perspective distortions, focus effects, and artistic geometric manipulations for visual impact.
Implements the true if the squeeze compression effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL squeeze compression effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL squeeze compression effect block.
Properly disposes of GStreamer elements and GPU geometric transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer squeeze filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the squeeze compression effect filter.
### IsAvailable()
Determines whether OpenGL squeeze compression effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL geometric distortion plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if squeeze compression effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL squeeze compression effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this squeeze compression effect block.
## See Also
---
# Class GLStretchBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLStretchBlock.html
# Class GLStretchBlock
# Class GLStretchBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated stretch geometric distortion effect block for creating expansion and stretching visual effects.
Applies radial expansion transformations that stretch or expand portions of the video away from a central point,
creating dramatic perspective distortions, magnification effects, and artistic geometric manipulations for dynamic visual impact.
Implements the true if the stretch expansion effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL stretch expansion effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL stretch expansion effect block.
Properly disposes of GStreamer elements and GPU geometric transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer stretch filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the stretch expansion effect filter.
### IsAvailable()
Determines whether OpenGL stretch expansion effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL geometric distortion plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if stretch expansion effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL stretch expansion effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this stretch expansion effect block.
## See Also
---
# Class GLTransformationBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLTransformationBlock.html
# Class GLTransformationBlock
# Class GLTransformationBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated comprehensive video transformation block for advanced geometric and spatial video manipulations.
Provides GPU-accelerated transformation capabilities including rotation, scaling, translation, perspective correction,
and complex matrix-based transformations for professional video processing, motion graphics, and geometric corrections.
Implements the true if the transformation block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL transformation operations, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL transformation block.
Properly disposes of GStreamer elements and GPU transformation matrix resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer transformation filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the comprehensive transformation filter.
### IsAvailable()
Determines whether OpenGL transformation functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL geometric transformation plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if transformation operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL transformation block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this transformation block.
## See Also
---
# Class GLTwirlBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLTwirlBlock.html
# Class GLTwirlBlock
# Class GLTwirlBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated twirl swirl distortion effect block for creating spiral and rotational geometric effects.
Applies radial twisting transformations that rotate portions of the video around a central point in a spiral pattern,
creating dynamic swirl effects, vortex distortions, and artistic spiral manipulations for dramatic visual impact.
Implements the true if the twirl swirl effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL twirl swirl effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL twirl swirl effect block.
Properly disposes of GStreamer elements and GPU geometric transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer twirl filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the twirl swirl effect filter.
### IsAvailable()
Determines whether OpenGL twirl swirl effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL geometric distortion plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if twirl swirl effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL twirl swirl effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this twirl swirl effect block.
## See Also
---
# Class GLUploadBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLUploadBlock.html
# Class GLUploadBlock
# Class GLUploadBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated video data upload block for transferring video frames from system memory to GPU memory.
Provides high-performance video frame upload operations that transfer video data from CPU memory to OpenGL textures
on the GPU, enabling GPU-accelerated video processing, effects, and transformations within the OpenGL pipeline.
Implements the true if the upload block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL upload operations, including GStreamer elements and GPU memory allocations.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL upload block.
Properly disposes of GStreamer elements and GPU memory transfer resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer upload element.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the OpenGL upload filter.
### IsAvailable()
Determines whether OpenGL upload functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL memory transfer plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if upload operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL upload block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this upload block.
## See Also
---
# Class GLVideoConverterBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLVideoConverterBlock.html
# Class GLVideoConverterBlock
# Class GLVideoConverterBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated video format conversion block for high-performance pixel format and colorspace transformations.
Provides GPU-accelerated video conversion capabilities including pixel format changes, colorspace transformations,
chroma subsampling conversions, and color depth adjustments optimized for OpenGL pipeline processing.
Implements the true if the video converter block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL video conversion operations, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL video converter block.
Properly disposes of GStreamer elements and GPU format conversion resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer video converter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the OpenGL video converter filter.
### IsAvailable()
Determines whether OpenGL video conversion functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL video conversion plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if video conversion operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL video converter block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this video converter block.
## See Also
---
# Class GLVideoMixerBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLVideoMixerBlock.html
# Class GLVideoMixerBlock
# Class GLVideoMixerBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated video mixer block for high-performance multi-stream video compositing and blending.
Provides GPU-accelerated video mixing capabilities with multiple input streams, real-time positioning, scaling, rotation,
alpha blending, chroma key effects, and advanced compositing operations for live streaming and video production.
Implements the true if the video mixer block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL video mixer operations, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL video mixer block.
Properly disposes of GStreamer elements and GPU compositing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer video mixer.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the OpenGL video mixer filter.
### Input_Get(Guid)
Gets the video mixer input stream configuration by its unique identifier.
```csharp
public VideoMixerStream Input_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream.
#### Returns
Parameters:
- (VideoMixerStream): The VideoMixerStream configuration for the specified input stream.
### Input_List()
Gets all configured input stream configurations for the video mixer.
```csharp
public VideoMixerStream[] Input_List()
```
#### Returns
Parameters:
- (VideoMixerStream [ ]): An array of VideoMixerStream configurations for all input streams.
### Input_Move(Guid, Rect, TimeSpan, double?, double?)
Animates the position and opacity of a specific input stream over time with smooth transitions.
```csharp
public void Input_Move(Guid id, Rect rect, TimeSpan duration, double? startAlpha, double? endAlpha)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to animate.
- rect (Rect): The target rectangle position and size for the animation.
- duration (TimeSpan): The duration of the animation transition.
- startAlpha (double ?): The starting alpha opacity value (optional, null to use current).
- endAlpha (double ?): The ending alpha opacity value (optional, null to use current).
### Input_SetChromaKeyEnabled(Guid, bool)
Enables or disables chroma key (green screen) processing for a specific input stream.
```csharp
public void Input_SetChromaKeyEnabled(Guid id, bool enabled)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to modify.
- enabled (bool): True to enable chroma key transparency, false to disable.
### Input_Update(VideoMixerStream)
Updates the configuration of a specific input stream with new positioning, scaling, and blending parameters.
```csharp
public void Input_Update(VideoMixerStream stream)
```
#### Parameters
Parameters:
- stream (VideoMixerStream): The VideoMixerStream configuration with updated parameters for the input stream.
### Input_UpdateChromaKeySettings(Guid, ChromaKeySettingsX)
Updates the chroma key (green screen) settings for a specific input stream, configuring color-based transparency.
```csharp
public void Input_UpdateChromaKeySettings(Guid id, ChromaKeySettingsX settings)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to update.
- settings (ChromaKeySettingsX): The new chroma key settings defining the color range and transparency parameters.
### IsAvailable()
Determines whether OpenGL video mixer functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL video compositing plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if video mixing operations are supported; otherwise, false.
### SetSettings(VideoMixerBaseSettings)
Updates the video mixer settings with new configuration parameters for compositing behavior.
```csharp
public void SetSettings(VideoMixerBaseSettings settings)
```
#### Parameters
Parameters:
- settings (VideoMixerBaseSettings): The new video mixer base settings to apply to the compositing operation.
### StartFadeIn(Guid, TimeSpan)
Starts a fade-in animation for a specific input stream, gradually increasing opacity from transparent to opaque.
```csharp
public void StartFadeIn(Guid id, TimeSpan duration)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to fade in.
- duration (TimeSpan): The duration of the fade-in animation.
### StartFadeOut(Guid, TimeSpan)
Starts a fade-out animation for a specific input stream, gradually decreasing opacity from opaque to transparent.
```csharp
public void StartFadeOut(Guid id, TimeSpan duration)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to fade out.
- duration (TimeSpan): The duration of the fade-out animation.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL video mixer block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this video mixer block.
## See Also
---
# Class GLVideoRendererBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLVideoRendererBlock.html
# Class GLVideoRendererBlock
# Class GLVideoRendererBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated video renderer block for high-performance video display and presentation.
Provides GPU-accelerated video rendering capabilities with direct OpenGL texture rendering to display surfaces,
enabling hardware-accelerated video playback, real-time preview, and efficient video output with cross-platform support.
Implements the true if the video renderer block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL video renderer, including GStreamer elements and display surface connections.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL video renderer block.
Properly disposes of GStreamer elements and GPU rendering resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer video renderer.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the OpenGL video renderer.
### GetVideoView()
Gets the video view control that provides the display surface for video rendering.
```csharp
public IVideoView GetVideoView()
```
#### Returns
Parameters:
- (IVideoView): The IVideoView interface for the associated display surface.
### IsAvailable()
Determines whether OpenGL video renderer functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL video rendering plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if video rendering operations are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL video renderer block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this video renderer block.
## See Also
---
# Class GLVirtualVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLVirtualVideoSourceBlock.html
# Class GLVirtualVideoSourceBlock
# Class GLVirtualVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated virtual video source block for generating programmable GPU-based video content.
Provides high-performance virtual video generation capabilities using OpenGL shaders and GPU rendering
to create synthetic video content, test patterns, procedural animations, and custom graphics for pipeline processing.
Implements the true if the virtual video source block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL virtual video source, including GStreamer elements and GPU rendering contexts.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL virtual video source block.
Properly disposes of GStreamer elements and GPU rendering resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the virtual video source.
### IsAvailable()
Determines whether OpenGL virtual video source functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL video generation plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if virtual video generation is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL virtual video source block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this virtual video source block.
## See Also
---
# Class GLXRayBlock
Link: api/VisioForge.Core.MediaBlocks.OpenGL.GLXRayBlock.html
# Class GLXRayBlock
# Class GLXRayBlock
**Namespace**: VisioForge.Core.MediaBlocks.OpenGL
**Assembly**: VisioForge.Core.dll
OpenGL-accelerated X-ray visual effect block for creating medical imaging and skeletal visualization effects.
Applies GPU-accelerated X-ray transformations that invert colors, enhance edges, and create high-contrast skeletal imagery
simulating medical X-ray imaging, with artistic applications for dramatic visual effects and scientific visualizations.
Implements the true if the X-ray imaging effect block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OpenGL X-ray imaging effect, including GStreamer elements and GPU shader programs.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OpenGL X-ray imaging effect block.
Properly disposes of GStreamer elements and GPU imaging transformation resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper providing access to the underlying GStreamer X-ray filter.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native Gst.Element representing the X-ray imaging effect filter.
### IsAvailable()
Determines whether OpenGL X-ray effect functionality is available on the current system.
Requires OpenGL support and appropriate GStreamer OpenGL imaging effect plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if X-ray imaging effects are supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OpenGL X-ray imaging effect block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this X-ray imaging effect block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.OpenGL
Link: api/VisioForge.Core.MediaBlocks.OpenGL.html
# Namespace VisioForge.Core.MediaBlocks.OpenGL
# Namespace VisioForge.Core.MediaBlocks.OpenGL
### Classes
Parameters:
- (): OpenGL alpha blending block for advanced transparency and compositing effects.
This block provides GPU-accelerated alpha channel manipulation using OpenGL shaders
for high-performance video compositing. Supports various alpha blending modes,
transparency gradients, and real-time alpha channel modifications. Essential for
creating professional video overlays, chroma key effects, and complex multi-layer
compositions. Leverages GPU parallel processing for smooth real-time alpha blending
even with high-resolution video streams.
Implements the The AV1ParseBlock analyzes AV1 bitstreams to identify frame boundaries, extract metadata, and prepare the stream for further processing. AV1 uses OBU (Open Bitstream Unit) structures to organize video data, including sequence headers, frame headers, and tile data.
Key features: - OBU parsing and validation - Frame boundary detection for proper packetization - Sequence and frame header extraction - Temporal unit and frame group identification - Profile and level verification - HDR metadata extraction when present
Common use cases: - Streaming: Preparing AV1 streams for RTP/WebRTC transmission - Muxing: Packaging AV1 video into container formats (MP4, WebM, MKV) - Analysis: Extracting codec configuration and stream properties - Transcoding: Providing properly parsed frames to decoders
The parser handles both Annex B format (with temporal unit delimiters) and raw OBU streams, automatically detecting the input format and processing accordingly.
## Constructors ### AV1ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer AV1 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing data once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for AV1 parsing.
### IsAvailable()
Determines whether the AV1 parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the AV1 parser plugin is available; otherwise, false.
This requires the GStreamer libav or bad plugins to be installed.
#### Remarks
The AV1 parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class H263ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.H263ParseBlock.html
# Class H263ParseBlock
# Class H263ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses H.263 video bitstreams for frame boundary detection and header analysis.
```csharp
public class H263ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The H263ParseBlock processes H.263 encoded video streams, identifying picture start codes, extracting picture headers, and ensuring proper frame alignment. H.263 is a legacy video codec primarily used in video conferencing and older mobile video applications.
Key features: - Picture start code (PSC) detection and validation - GOB (Group of Blocks) header parsing - Picture type identification (I, P, PB frames) - Optional modes detection (Annex D, F, I, J, T) - Frame boundary detection for proper segmentation - Temporal reference extraction
Common use cases: - Video conferencing: Processing H.263 streams from legacy endpoints - Streaming: Preparing H.263 video for RTP transmission (RFC 2190) - Transcoding: Converting H.263 to modern codecs - File conversion: Extracting H.263 from 3GP containers
The parser handles both baseline H.263 and H.263+ (H.263v2) formats, automatically detecting optional features and annexes used in the stream.
## Constructors ### H263ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer H.263 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing data once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for H.263 parsing.
### IsAvailable()
Determines whether the H.263 parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the H.263 parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The H.263 parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class H264ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.H264ParseBlock.html
# Class H264ParseBlock
# Class H264ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses H.264/AVC (Advanced Video Coding) bitstreams for NAL unit processing and frame boundary detection.
```csharp
public class H264ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The H264ParseBlock processes H.264 encoded video streams, parsing NAL (Network Abstraction Layer) units, extracting SPS/PPS parameters, and ensuring proper access unit boundaries. H.264 is the most widely adopted video codec for streaming, broadcasting, and video storage.
Key features: - NAL unit parsing and validation (start codes and length-prefixed) - SPS (Sequence Parameter Set) and PPS (Picture Parameter Set) extraction - Access unit boundary detection based on H.264 specification - SEI (Supplemental Enhancement Information) message parsing - Slice header analysis for frame type detection - Support for both Annex B (start codes) and AVCC (length-prefixed) formats
Common use cases: - Streaming: Preparing H.264 for HLS, DASH, or RTP transmission - Muxing: Packaging H.264 into MP4, MKV, or TS containers - Analysis: Extracting codec parameters and stream properties - Transcoding: Providing properly parsed NAL units to decoders - Video editing: Frame-accurate cutting and splicing
The parser handles various H.264 profiles (Baseline, Main, High) and levels, automatically adapting to the stream's characteristics and ensuring compliance with the H.264 specification (ITU-T H.264 / ISO/IEC 14496-10).
## Constructors ### H264ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer H.264 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing NAL units once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for H.264 NAL unit parsing.
### IsAvailable()
Determines whether the H.264 parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the H.264 parser plugin is available; otherwise, false.
This requires the GStreamer base plugins to be installed.
#### Remarks
The H.264 parser is provided by the GStreamer base plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class H265ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.H265ParseBlock.html
# Class H265ParseBlock
# Class H265ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses H.265/HEVC (High Efficiency Video Coding) bitstreams for NAL unit processing and frame boundary detection.
```csharp
public class H265ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The H265ParseBlock processes H.265/HEVC encoded video streams, parsing NAL (Network Abstraction Layer) units, extracting VPS/SPS/PPS parameters, and ensuring proper access unit boundaries. H.265 offers approximately 50% better compression than H.264 while maintaining similar video quality.
Key features: - NAL unit parsing with support for multi-layer extensions - VPS (Video Parameter Set), SPS, and PPS extraction - Access unit boundary detection per HEVC specification - Temporal layer identification and scalability support - SEI message parsing including HDR metadata (HDR10, HLG) - Support for both Annex B and HVCC (length-prefixed) formats - Slice segment header analysis for frame type detection
Common use cases: - Streaming: Preparing HEVC for HLS, DASH, or RTP transmission - Muxing: Packaging HEVC into MP4, MKV, or TS containers - HDR processing: Extracting and preserving HDR metadata - Transcoding: Providing properly parsed NAL units to HEVC decoders - 4K/8K video: Handling high-resolution video streams efficiently
The parser handles various HEVC profiles including Main, Main 10, Main Still Picture, and Range Extensions. It automatically detects stream characteristics including bit depth, chroma format, and HDR signaling.
## Constructors ### H265ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer H.265 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing NAL units once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for H.265/HEVC NAL unit parsing.
### IsAvailable()
Determines whether the H.265/HEVC parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the H.265 parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The H.265 parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class JPEG2000ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.JPEG2000ParseBlock.html
# Class JPEG2000ParseBlock
# Class JPEG2000ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses JPEG 2000 codestreams and JP2 file format for frame boundary detection and metadata extraction.
```csharp
public class JPEG2000ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The JPEG2000ParseBlock processes JPEG 2000 encoded image and video streams, identifying codestream markers, extracting header information, and ensuring proper frame segmentation. JPEG 2000 is a wavelet-based image compression standard offering superior compression and quality scalability compared to traditional JPEG.
Key features: - Codestream marker detection (SOC, SOT, SOD, EOC) - Main header and tile-part header parsing - Component information extraction - Resolution level and quality layer identification - JP2 box structure parsing for file format compliance - Support for both raw codestreams and JP2 container format - Progressive decoding metadata extraction
Common use cases: - Digital cinema: Processing DCI-compliant JPEG 2000 streams - Medical imaging: Handling DICOM JPEG 2000 compressed images - Archival systems: Working with lossless JPEG 2000 content - Broadcasting: Processing JPEG 2000 video sequences - Geospatial imaging: Handling large satellite imagery
The parser supports both lossy and lossless compression modes, multiple component images (including arbitrary color spaces), and can handle very large image resolutions common in professional applications.
## Constructors ### JPEG2000ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer JPEG 2000 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing data once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for JPEG 2000 parsing.
### IsAvailable()
Determines whether the JPEG 2000 parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the JPEG 2000 parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The JPEG 2000 parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class MPEG12VideoParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.MPEG12VideoParseBlock.html
# Class MPEG12VideoParseBlock
# Class MPEG12VideoParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses MPEG-1 and MPEG-2 video elementary streams for picture boundary detection and header analysis.
```csharp
public class MPEG12VideoParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The MPEG12VideoParseBlock processes MPEG-1 and MPEG-2 video elementary streams, identifying picture start codes, extracting sequence and picture headers, and ensuring proper GOP (Group of Pictures) alignment. These formats are foundational video compression standards used in DVD, digital TV broadcasting, and legacy video systems.
Key features: - Start code detection and validation (picture, sequence, GOP) - Sequence header parsing (resolution, frame rate, aspect ratio) - Picture header analysis (I, P, B frame types) - GOP structure identification and temporal reference - Extension header parsing for MPEG-2 features - Progressive and interlaced content handling - Closed caption data extraction when present
Common use cases: - DVD playback: Processing MPEG-2 video from DVD sources - Broadcasting: Handling MPEG-2 streams from DVB/ATSC systems - Legacy conversion: Transcoding MPEG-1/2 to modern formats - Video analysis: Extracting GOP structure and frame types - Muxing: Preparing elementary streams for program streams or transport streams
The parser supports various MPEG-2 profiles and levels including Main Profile @ Main Level (MP@ML) for SD content and Main Profile @ High Level (MP@HL) for HD content. It handles both MPEG-1 constrained parameters and full MPEG-2 feature sets.
## Constructors ### MPEG12VideoParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer MPEG video parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing data once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for MPEG-1/2 video parsing.
### IsAvailable()
Determines whether the MPEG-1/2 video parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the MPEG video parser plugin is available; otherwise, false.
This requires the GStreamer base plugins to be installed.
#### Remarks
The MPEG-1/2 video parser is provided by the GStreamer base plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class MPEG4ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.MPEG4ParseBlock.html
# Class MPEG4ParseBlock
# Class MPEG4ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses MPEG-4 Part 2 (MPEG-4 Visual) bitstreams for VOP boundary detection and codec parameter extraction.
```csharp
public class MPEG4ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The MPEG4ParseBlock processes MPEG-4 Part 2 encoded video streams, parsing Visual Object Sequences (VOS), Visual Object Layer (VOL) headers, and Video Object Planes (VOPs) to ensure proper frame boundaries. MPEG-4 Part 2 includes profiles like Simple Profile, Advanced Simple Profile (ASP), and others used in formats like DivX, Xvid, and early MP4 videos.
Key features: - Visual Object Sequence (VOS) header parsing for profile/level detection - Visual Object Layer (VOL) processing for resolution and timing info - Video Object Plane (VOP) boundary detection and type identification (I, P, B, S) - Support for rectangular and arbitrary shaped video objects - Handles packed bitstream mode and B-frame processing - Interlaced content support with field-based processing - Sprite (S-VOP) and GMC (Global Motion Compensation) support
Common use cases: - Streaming: Processing MPEG-4 content for adaptive streaming - Muxing: Packaging MPEG-4 Visual into MP4, AVI, or MKV containers - Transcoding: Providing properly parsed VOPs to MPEG-4 decoders - Legacy support: Handling DivX/Xvid content in media players - Video analysis: Extracting codec parameters and stream properties
The parser handles various MPEG-4 Visual profiles including Simple Profile (SP), Advanced Simple Profile (ASP), Core Profile, and Main Profile, automatically detecting stream characteristics and ensuring compliance with ISO/IEC 14496-2.
## Constructors ### MPEG4ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer MPEG-4 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing VOPs once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for MPEG-4 Visual VOP parsing.
### IsAvailable()
Determines whether the MPEG-4 Visual parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the MPEG-4 parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The MPEG-4 Visual parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class MPEGAudioParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.MPEGAudioParseBlock.html
# Class MPEGAudioParseBlock
# Class MPEGAudioParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses MPEG Audio (MP1/MP2/MP3) bitstreams for frame boundary detection and audio parameter extraction.
```csharp
public class MPEGAudioParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The MPEGAudioParseBlock processes MPEG-1 Audio Layer I/II/III and MPEG-2 Audio bitstreams, parsing frame headers to ensure proper frame boundaries and extract audio properties. This includes the widely-used MP3 format as well as MP2 (used in broadcasting) and MP1.
Key features: - Frame header parsing for all MPEG audio layers (I, II, III) - Bitrate detection (CBR and VBR with Xing/VBRI headers) - Sample rate and channel configuration extraction - CRC error detection for protected frames - ID3v1 and ID3v2 tag preservation - Gapless playback support via LAME/encoder delay info - Free format bitstream support
Common use cases: - Streaming: Preparing MP3/MP2 for HTTP Live Streaming or Icecast - Muxing: Packaging MPEG audio into containers like MP4, MKV, or TS - Transcoding: Providing properly framed audio to MPEG audio decoders - Broadcasting: Processing MP2 audio in DVB and DAB applications - Audio analysis: Extracting bitrate, duration, and encoding parameters
The parser handles various MPEG audio versions and layers: - MPEG-1 Audio Layer I (MP1): 32-448 kbps - MPEG-1 Audio Layer II (MP2): 32-384 kbps - MPEG-1 Audio Layer III (MP3): 32-320 kbps - MPEG-2 LSF (Lower Sampling Frequencies) extensions - MPEG-2.5 unofficial extension for very low bitrates
## Constructors ### MPEGAudioParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer MPEG audio parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing audio frames once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for MPEG audio frame parsing.
### IsAvailable()
Determines whether the MPEG audio parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the MPEG audio parser plugin is available; otherwise, false.
This requires the GStreamer good plugins to be installed.
#### Remarks
The MPEG audio parser is provided by the GStreamer good plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class PNGParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.PNGParseBlock.html
# Class PNGParseBlock
# Class PNGParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses PNG (Portable Network Graphics) image streams for chunk validation and metadata extraction.
```csharp
public class PNGParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The PNGParseBlock processes PNG image streams, parsing the chunk-based structure to validate image integrity and extract metadata. PNG is a lossless image format widely used for web graphics, screenshots, and images requiring transparency support.
Key features: - PNG signature validation (89 50 4E 47 0D 0A 1A 0A) - Critical chunk parsing: IHDR, PLTE, IDAT, IEND - Ancillary chunk support: tEXt, iTXt, gAMA, cHRM, sRGB, etc. - CRC-32 validation for each chunk - Interlaced PNG support (Adam7 interlacing) - Color type detection (grayscale, RGB, palette, alpha) - Bit depth validation (1, 2, 4, 8, 16 bits per channel) - APNG (Animated PNG) frame detection
Common use cases: - Image processing: Validating PNG files before decoding - Streaming: Extracting PNG images from video or data streams - Metadata extraction: Reading text chunks and color space information - Format conversion: Preparing PNG data for transcoding - Web applications: Processing uploaded PNG images - Animation: Handling APNG sequences
The parser ensures PNG specification compliance (ISO/IEC 15948:2003) and handles various PNG variants including standard PNG, APNG (animated), and PNG with extensive metadata. It validates chunk ordering and detects malformed files.
## Constructors ### PNGParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer PNG parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin validating PNG chunks once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for PNG chunk parsing.
### IsAvailable()
Determines whether the PNG parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the PNG parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The PNG parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class VC1ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.VC1ParseBlock.html
# Class VC1ParseBlock
# Class VC1ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses VC-1/WMV3 (Windows Media Video) bitstreams for frame boundary detection and codec parameter extraction.
```csharp
public class VC1ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The VC1ParseBlock processes VC-1 encoded video streams, parsing Sequence Layer Headers, Entry Point Headers, and Picture Headers to ensure proper frame boundaries. VC-1 is Microsoft's video codec standard (SMPTE 421M) used in WMV9, HD DVD, and Blu-ray.
Key features: - Sequence Layer Header parsing for codec profile and level detection - Entry Point Header processing for display parameters - Picture Header analysis for frame type determination (I, P, B, BI) - Support for Simple, Main, and Advanced Profiles - Handles both ASF encapsulated and raw VC-1 bitstreams - Frame boundary detection based on VC-1 specification - Interlaced and progressive content support
Common use cases: - Streaming: Processing WMV content for adaptive streaming - Muxing: Packaging VC-1 into ASF, MP4, or MKV containers - Transcoding: Providing properly parsed frames to VC-1 decoders - Broadcast: Handling VC-1 streams in broadcast applications - Media analysis: Extracting codec parameters and stream properties
The parser handles all VC-1 profiles including Simple Profile (WMV9 Simple), Main Profile (WMV9 Main), and Advanced Profile (WVC1), automatically adapting to the stream characteristics and ensuring compliance with SMPTE 421M.
## Constructors ### VC1ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer VC-1 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing VC-1 frames once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for VC-1 bitstream parsing.
### IsAvailable()
Determines whether the VC-1 parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the VC-1 parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The VC-1 parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Class VP9ParseBlock
Link: api/VisioForge.Core.MediaBlocks.Parsers.VP9ParseBlock.html
# Class VP9ParseBlock
# Class VP9ParseBlock
**Namespace**: VisioForge.Core.MediaBlocks.Parsers
**Assembly**: VisioForge.Core.dll
Parses VP9 video bitstreams for superframe boundary detection and codec parameter extraction.
```csharp
public class VP9ParseBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The VP9ParseBlock processes VP9 encoded video streams, parsing frame headers and superframe structures to ensure proper frame boundaries. VP9 is Google's open-source video codec offering efficient compression for web video, competing with H.265/HEVC while remaining royalty-free.
Key features: - Superframe parsing and frame boundary detection - Profile detection (0-3) including high bit depth support - Frame header parsing for resolution and reference frame info - Temporal and spatial scalability layer identification - Color space and HDR metadata extraction (BT.709, BT.2020, etc.) - Lossless compression mode detection - Show existing frame and invisible frame handling - Segmentation and tile boundary processing
Common use cases: - Streaming: Preparing VP9 for WebM/DASH adaptive streaming - Muxing: Packaging VP9 into WebM, MP4, or MKV containers - Web video: Processing VP9 content for HTML5 video playback - Transcoding: Providing properly parsed frames to VP9 decoders - YouTube: Handling VP9 streams from YouTube and similar platforms - WebRTC: Processing VP9 in real-time communication applications
The parser supports all VP9 profiles: - Profile 0: 8-bit 4:2:0 (most common) - Profile 1: 8-bit 4:2:2, 4:4:4 - Profile 2: 10/12-bit 4:2:0 - Profile 3: 10/12-bit 4:2:2, 4:4:4 It handles both traditional frame-based streams and superframe-packed formats commonly used in WebM containers.
## Constructors ### VP9ParseBlock() Initializes a new instance of thetrue if the parser was successfully created and configured;
false if initialization failed or required plugins are missing.
#### Remarks
This method creates the GStreamer VP9 parser element, initializes it within
the pipeline context, and connects the input/output pads. The parser will
begin processing VP9 frames and superframes once the pipeline transitions to the playing state.
### CleanUp()
Performs cleanup of the parser resources and resets the build state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the GStreamer element and resets internal state.
It is called during disposal to ensure proper resource cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapper providing access to common GStreamer functionality.
### GetElement()
Gets the underlying native GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element instance used for VP9 frame parsing.
### IsAvailable()
Determines whether the VP9 parser is available in the current GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the VP9 parser plugin is available; otherwise, false.
This requires the GStreamer bad plugins to be installed.
#### Remarks
The VP9 parser is provided by the GStreamer bad plugins collection. Ensure the
appropriate VisioForge SDK redistribution package is included in your project.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The media pipeline that will contain this parser block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.Parsers
Link: api/VisioForge.Core.MediaBlocks.Parsers.html
# Namespace VisioForge.Core.MediaBlocks.Parsers
# Namespace VisioForge.Core.MediaBlocks.Parsers
### Classes
Parameters:
- (): Parses AV1 (AOMedia Video 1) bitstreams for frame boundary detection and metadata extraction.
- (): Parses H.263 video bitstreams for frame boundary detection and header analysis.
- (): Parses H.264/AVC (Advanced Video Coding) bitstreams for NAL unit processing and frame boundary detection.
- (): Parses H.265/HEVC (High Efficiency Video Coding) bitstreams for NAL unit processing and frame boundary detection.
- (): Parses JPEG 2000 codestreams and JP2 file format for frame boundary detection and metadata extraction.
- (): Parses MPEG-1 and MPEG-2 video elementary streams for picture boundary detection and header analysis.
- (): Parses MPEG-4 Part 2 (MPEG-4 Visual) bitstreams for VOP boundary detection and codec parameter extraction.
- (): Parses MPEG Audio (MP1/MP2/MP3) bitstreams for frame boundary detection and audio parameter extraction.
- (): Parses PNG (Portable Network Graphics) image streams for chunk validation and metadata extraction.
- (): Parses VC-1/WMV3 (Windows Media Video) bitstreams for frame boundary detection and codec parameter extraction.
- (): Parses VP9 video bitstreams for superframe boundary detection and codec parameter extraction.
---
# Class ASFSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.ASFSinkBlock.html
# Class ASFSinkBlock
# Class ASFSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
ASF (Advanced Systems Format) sink block for writing media streams to ASF/WMV/WMA container files.
```csharp
public class ASFSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The ASF sink block supports writing audio and video streams to the Advanced Systems Format container, commonly used for Windows Media files (.wmv for video, .wma for audio, .asf for generic content). This format is optimized for streaming and supports advanced features like DRM, multiple bitrates, and metadata embedding.
Key Features:
Typical Use Cases:
Limitations:
true if the sink was successfully built and all requested input pads were created;
false if initialization failed or required pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer ASF muxer element and configures input pads
for each media stream that was previously added via true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output filename or URL for the ASF file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The file path or URL where the ASF file should be written.
For local files, use a standard file path. The directory must exist.
#### Remarks
This method updates both the settings and the underlying GStreamer element
if the sink has already been built. Changing the filename during recording
may not be supported and could cause errors.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the AVI output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the AVI output operations, including encoders, sink, and file handles.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of video and audio streams.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the AVI output block.
Properly disposes of GStreamer elements, encoders, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the AVI content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the AVI output destination.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable(IH264EncoderSettings, IAACEncoderSettings)
Determines whether AVI output functionality is available on the current system with the specified encoder settings.
Requires GStreamer AVI muxer and the specified video and audio encoder plugins to be installed and functional.
```csharp
public static bool IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)
```
#### Parameters
Parameters:
- h264settings (IH264EncoderSettings): The H.264 video encoder settings to validate for availability.
- aacSettings (IAACEncoderSettings): The AAC audio encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if AVI output with the specified encoders is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the AVI file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where AVI content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this AVI output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this AVI output block.
## See Also
---
# Class AVISinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.AVISinkBlock.html
# Class AVISinkBlock
# Class AVISinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block for writing media data to AVI (Audio Video Interleave) container files.
Supports multiple audio and video streams with configurable encoding parameters.
AVI is a multimedia container format that stores audio and video data in a file container
that allows synchronous audio-with-video playback.
```csharp
public class AVISinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The AVISinkBlock provides functionality to write media streams to AVI files, supporting: - Multiple video streams with different codecs - Multiple audio streams with various encoders - Configurable container and codec settings - Frame-accurate synchronization
This block accepts dynamic inputs for video and audio streams, which must be added before building the pipeline. Each stream can have its own encoding configuration.
Common use cases include: - Recording video from cameras to AVI files - Converting media to AVI format - Creating multi-stream AVI files - Archiving video content
## Constructors ### AVISinkBlock(AVISinkSettings) Initializes a new instance of thesettings is null.
### AVISinkBlock(string)
Initializes a new instance of the true if the build was successful; otherwise, false.
#### Remarks
This method:
- Creates the underlying AVI sink element
- Configures it with the provided settings
- Sets up input pads for all added streams
- Validates that all components are properly initialized
### CleanUp()
Performs cleanup of resources used by the AVI sink.
```csharp
public void CleanUp()
```
#### Remarks
This method releases the underlying GStreamer element and resets the build state.
It is called during disposal to ensure proper resource cleanup.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media this input will accept (video, audio, etc.).
#### Returns
Parameters:
- (MediaBlockPad): A new true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for the AVI file.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The full path to the output AVI file.
### GetInput(MediaBlockPadMediaType)
Gets an existing input pad that matches the specified media type.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first input pad matching the media type; null if no match is found.
#### Remarks
This method is useful when you need to connect to an existing input pad
rather than creating a new one.
### IsAvailable()
Determines whether the AVI sink functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if AVI sink is available; otherwise, false.
Availability depends on GStreamer plugins and platform support.
#### Remarks
This method checks for the presence of required GStreamer plugins (avimux, filesink)
and should be called before attempting to create an AVISinkBlock instance.
### SetFilenameOrURL(string)
Sets the output filename for the AVI file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The full path where the AVI file should be written.
#### Remarks
The directory must exist and be writable. The file will be overwritten if it already exists.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class BufferSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.BufferSinkBlock.html
# Class BufferSinkBlock
# Class BufferSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block that captures media data into memory buffers for processing or analysis.
Provides frame-by-frame access to video, audio, or raw data through event callbacks.
```csharp
public class BufferSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The BufferSinkBlock is designed for scenarios where you need direct access to media frames in memory rather than writing to a file. It supports: - Video frame capture with format conversion - Audio frame capture with resampling - Raw data capture for custom media types - Frame dropping for performance optimization - Synchronization control for playback vs transcoding
Frame data is delivered through event callbacks, allowing real-time processing, analysis, or custom rendering. The block can be configured to drop frames when the processing cannot keep up with the media rate.
Common use cases include: - Video frame analysis and processing - Audio visualization - Custom rendering implementations - Media stream monitoring - Frame extraction for thumbnails
## Constructors ### BufferSinkBlock(VideoFormatX, bool) Initializes a new instance of thetrue, allows dropping frames when processing cannot keep up.
#### Remarks
Use this constructor when you know you'll be capturing video frames and want to specify
the output format. The sink will automatically convert incoming video to the specified format.
### BufferSinkBlock(AudioFormatX, bool)
Initializes a new instance of the true, allows dropping frames when processing cannot keep up.
#### Remarks
Use this constructor when you know you'll be capturing audio frames and want to specify
the output format. The sink will automatically resample incoming audio to the specified format.
### BufferSinkBlock()
Initializes a new instance of the When enabled, media is processed at its natural rate, maintaining proper timing for playback. When disabled, media is processed as fast as possible, which is ideal for transcoding or analysis.
Typical settings: - Playback/Preview: true (maintains proper frame timing) - Transcoding: false (processes as fast as possible) - Live capture: true (follows real-time constraints)
### Output Gets the output. ```csharp public override MediaBlockPad Output { get; } ``` #### Property Value Parameters: - (MediaBlockPad): ### Outputs Gets the outputs. ```csharp public override MediaBlockPad[] Outputs { get; } ``` #### Property Value Parameters: - (MediaBlockPad [ ]): ### Type Gets the type of this media block. ```csharp public override MediaBlockType Type { get; } ``` #### Property Value Parameters: - (MediaBlockType): ## Methods ### Build() Builds the buffer sink block and prepares it for capturing media frames. ```csharp public override bool Build() ``` #### Returns Parameters: - (bool):true if the build was successful; otherwise, false.
#### Remarks
This method:
- Creates the appropriate buffer sink based on the media format
- Registers event handlers for frame callbacks
- Configures synchronization and frame dropping settings
- Initializes the input pad for media reception
### CleanUp()
Performs cleanup of resources used by the buffer sink.
```csharp
public void CleanUp()
```
#### Remarks
This method releases the underlying GStreamer element and resets the build state.
Any pending frames are discarded during cleanup.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the filename or URL for this sink.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): Always returns null as buffer sinks don't write to files.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the filename or URL for this sink.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The value to set (ignored).
#### Remarks
This method has no effect as buffer sinks capture to memory, not files.
It exists to satisfy the IMediaBlockSink interface.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
### OnAudioFrameBuffer
Occurs when a new audio frame is captured and ready for processing.
```csharp
public event EventHandlerThis is a low-level event that provides direct access to GStreamer samples. When this event is subscribed, the higher-level events (OnVideoFrameBuffer, OnAudioFrameBuffer, OnDataFrameBuffer) will not be raised.
IMPORTANT: The sample must be disposed after processing to prevent memory leaks. Use this event only when you need direct GStreamer sample manipulation.
### OnVideoFrameBuffer Occurs when a new video frame is captured and ready for processing. ```csharp public event EventHandlerThe DASH sink block generates MPEG-DASH content, an international standard for adaptive bitrate streaming. DASH works by breaking the overall stream into a sequence of small HTTP-based file segments, each representing a short interval of playback time. This enables adaptive streaming, VOD, and live broadcasts.
Key Features:
Typical Use Cases:
Technical Specifications:
Output Structure: The sink creates a directory structure with an MPD manifest file and segment files. For live streaming, old segments are automatically removed based on time shift buffer settings.
## Constructors ### DASHSinkBlock(DASHSinkSettings) Initializes a new instance of thetrue if the sink was successfully built and configured;
false if initialization failed or required pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer DASH sink element and configures
separate video and audio input pads. The sink will create the output directory
structure and begin generating manifest files when the pipeline starts.
### CleanUp()
Cleans up resources and resets the sink block to an unbuilt state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer DASH sink element.
Any incomplete segments may be finalized and the manifest updated before cleanup.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. DASH supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output location for DASH manifest.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The file path where the MPD manifest should be written.
The directory will be created if it doesn't exist.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not currently implemented. Configure the location through settings instead.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the Facebook Live streaming block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the Facebook Live streaming operations, including encoders, sink, and network connections.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of video and audio streams for live streaming.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video or Audio) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the Facebook Live streaming block.
Properly disposes of GStreamer elements, encoders, and network streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite streaming blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite streaming blocks with multiple internal elements.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video or Audio) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable()
Determines whether Facebook Live streaming functionality is available on the current system.
Requires GStreamer RTMP streaming plugins and network connectivity for Facebook Live platform access.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Facebook Live streaming is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this Facebook Live streaming block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this Facebook Live streaming block.
## See Also
---
# Class FacebookLiveSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.FacebookLiveSinkBlock.html
# Class FacebookLiveSinkBlock
# Class FacebookLiveSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block for streaming live video and audio to Facebook Live.
Enables real-time broadcasting to Facebook's streaming platform using RTMP protocol.
```csharp
public class FacebookLiveSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The FacebookLiveSinkBlock provides functionality to stream media content directly to Facebook Live. It supports: - H.264 video streaming with configurable bitrate and resolution - AAC audio streaming with adjustable quality - RTMP/RTMPS protocol for secure streaming - Multiple stream quality settings - Automatic reconnection on network failures
To use this block, you need: - A Facebook Live stream key from your Facebook account - Properly encoded video (H.264) and audio (AAC) streams - Stable internet connection with sufficient upload bandwidth
Common use cases include: - Live event broadcasting - Gaming streams - Educational content streaming - Live product demonstrations
## Constructors ### FacebookLiveSinkBlock(FacebookLiveSinkSettings) Initializes a new instance of thesettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the Facebook Live streaming configuration.
```csharp
public FacebookLiveSinkSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (FacebookLiveSinkSettings):
#### Remarks
The settings include:
- Stream key: Your unique Facebook Live stream key
- Server URL: Facebook's RTMP ingest server (usually automatic)
- Video settings: Resolution, framerate, bitrate
- Audio settings: Sample rate, channels, bitrate
- Network settings: Buffer sizes, timeout values
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds this instance.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if successfull, false otherwise.
### CleanUp()
Performs cleanup of resources used by the Facebook Live sink.
```csharp
public void CleanUp()
```
#### Remarks
This method releases the underlying streaming element and resets the build state.
Any active stream connection will be terminated.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream (video or audio only).
#### Returns
Parameters:
- (MediaBlockPad): A new true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the stream key or URL for Facebook Live streaming.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The Facebook Live stream key.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether Facebook Live streaming functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Facebook Live sink is available; otherwise, false.
Requires RTMP support and appropriate GStreamer plugins.
#### Remarks
This method checks for the presence of required GStreamer plugins (rtmpsink, flvmux)
and network capabilities needed for Facebook Live streaming.
### SetFilenameOrURL(string)
Sets the stream key or URL for Facebook Live streaming.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The stream key value.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not implemented. Use Settings.Key instead.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class FDSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.FDSinkBlock.html
# Class FDSinkBlock
# Class FDSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block that writes media data to a file descriptor (Unix-style file handle).
Enables writing to pipes, sockets, or other file descriptor-based outputs.
```csharp
public class FDSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The FDSinkBlock provides low-level output capabilities by writing directly to file descriptors. This is particularly useful for: - Inter-process communication via pipes - Network streaming via sockets - Integration with external processes - Writing to special device files
File descriptors are integer values that reference open files, pipes, or sockets in Unix-like operating systems. Standard descriptors include: - 0: Standard input (stdin) - 1: Standard output (stdout) - 2: Standard error (stderr) - 3+: Custom file descriptors
The block can optionally add a queue before the sink to handle buffering and prevent blocking in the main pipeline thread.
## Constructors ### FDSinkBlock(int, bool) Initializes a new instance of thetrue, adds a queue element for buffering to prevent blocking.
#### Remarks
Adding a queue is recommended for most use cases to prevent the sink from blocking
the pipeline if the file descriptor write operations are slow.
## Properties
### Descriptor
Gets or sets the file descriptor number to write to.
```csharp
public int Descriptor { get; set; }
```
#### Property Value
Parameters:
- (int):
#### Remarks
The file descriptor must be open and writable before starting the pipeline.
Writing to a closed descriptor will cause pipeline errors.
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds this instance.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if successful, false otherwise.
### CleanUp()
Performs cleanup of resources used by the file descriptor sink.
```csharp
public void CleanUp()
```
#### Remarks
This method releases the underlying GStreamer element and resets the build state.
Note that it does not close the file descriptor itself, which remains the
responsibility of the code that opened it.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad (returns the existing single input pad).
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type (ignored as FD sink accepts any data).
#### Returns
Parameters:
- (MediaBlockPad): The single input pad of this sink.
#### Remarks
FD sink has only one input pad that accepts any media type.
This method always returns the same pad regardless of the media type parameter.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the filename or URL for this sink.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): Always returns an empty string as FD sinks use descriptors, not filenames.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether file descriptor sink functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if FD sink is available; otherwise, false.
Typically available on Unix-like systems (Linux, macOS) but limited on Windows.
#### Remarks
File descriptor support varies by platform. On Windows, this may only work
with certain types of handles that can be treated as file descriptors.
### SetFilenameOrURL(string)
Sets the filename or URL for this sink.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The value to set (ignored).
#### Remarks
This method has no effect as FD sinks use file descriptors, not filenames.
It exists to satisfy the IMediaBlockSink interface.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class FileSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.FileSinkBlock.html
# Class FileSinkBlock
# Class FileSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block that writes raw media data directly to a file without any container format.
Suitable for writing elementary streams or raw data that will be processed later.
```csharp
public class FileSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The FileSinkBlock provides basic file writing functionality for media streams. Unlike container-based sinks (MP4, AVI, etc.), this sink writes raw data directly to disk without any file structure or metadata. This makes it suitable for: - Elementary video streams (raw H.264, HEVC) - Raw audio data (PCM, compressed audio frames) - Intermediate processing files - Custom data formats
The sink accepts any type of media data and writes it sequentially to the specified file. An optional queue can be added to prevent the file I/O from blocking the pipeline.
Common use cases include: - Debugging pipeline output - Creating raw stream files for analysis - Temporary storage during multi-pass processing - Writing custom binary formats
## Constructors ### FileSinkBlock(string, bool) Initializes a new instance of thetrue, adds a queue element for buffering to prevent blocking.
#### Remarks
Adding a queue is recommended to prevent file I/O operations from blocking
the pipeline, especially when writing to slow storage devices.
## Properties
### Filename
Gets or sets the output filename where data will be written.
```csharp
public string Filename { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
If the file already exists, it will be overwritten.
Ensure the directory exists before starting the pipeline.
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds this instance.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if successful, false otherwise.
### CleanUp()
Performs cleanup of resources used by the file sink.
```csharp
public void CleanUp()
```
#### Remarks
This method releases the underlying GStreamer element and resets the build state.
Any buffered data is flushed to disk before cleanup.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad (returns the existing single input pad).
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type (ignored as file sink accepts any data).
#### Returns
Parameters:
- (MediaBlockPad): The single input pad of this sink.
#### Remarks
File sink has only one input pad that accepts any media type.
This method always returns the same pad regardless of the media type parameter.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for this sink.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The full path to the output file.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether file sink functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if file sink is available; otherwise, false.
This basic functionality is typically available on all platforms.
#### Remarks
File sink is a core GStreamer element and should be available on all platforms
where GStreamer is properly installed.
### SetFilenameOrURL(string)
Sets the output filename for this sink.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The full path where the file should be written.
#### Remarks
Changing the filename after the pipeline has started may not take effect
until the pipeline is restarted.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class FLACOutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.FLACOutputBlock.html
# Class FLACOutputBlock
# Class FLACOutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
FLAC (Free Lossless Audio Codec) output block for creating high-quality lossless audio files with professional audio encoding.
Provides uncompressed audio archival and professional audio production with configurable FLAC encoding for music production, audio mastering,
and high-fidelity audio content creation with industry-standard lossless compression for audiophile-quality audio preservation.
Implements the true if the FLAC output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the FLAC output operations, including encoder, sink, and file handles.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the FLAC output block.
Properly disposes of GStreamer elements, encoder, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the FLAC content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the FLAC output destination.
### IsAvailable()
Determines whether FLAC output functionality is available on the current system.
Requires GStreamer FLAC encoder and file sink plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if FLAC output is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the FLAC file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where FLAC content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this FLAC output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this FLAC output block.
## See Also
---
# Class HLSSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.HLSSinkBlock.html
# Class HLSSinkBlock
# Class HLSSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
HLS (HTTP Live Streaming) sink block for creating segmented streaming content.
```csharp
public class HLSSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The HLS sink block generates HTTP Live Streaming content, Apple's adaptive bitrate streaming protocol that has become an industry standard. HLS works by breaking the overall stream into a sequence of small HTTP-based file downloads, each containing a segment of the stream. This enables adaptive streaming, VOD, and live broadcasts.
Key Features:
Typical Use Cases:
Technical Specifications:
Output Structure: The sink creates a directory structure with playlist files (.m3u8) and segment files (.ts/.m4s). For live streaming, old segments are automatically removed based on playlist settings.
## Constructors ### HLSSinkBlock(HLSSinkSettings) Initializes a new instance of thetrue if the sink was successfully built and configured;
false if initialization failed or required pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer HLS sink element and configures
separate video and audio input pads. The sink will create the output directory
structure and begin generating playlist files when the pipeline starts.
### CleanUp()
Cleans up resources and resets the sink block to an unbuilt state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer HLS sink element.
Any incomplete segments may be finalized and the playlist updated before cleanup.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. HLS supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output location for HLS segments and playlists.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The directory path where HLS files should be written.
The directory will be created if it doesn't exist.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not currently implemented. Configure the location through settings instead.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The The HTTPMJPEGLiveSinkBlock provides a lightweight video streaming solution using the Motion JPEG format over HTTP. Key features include: - Simple HTTP server on a specified port - MJPEG stream compatible with web browsers - Multiple simultaneous client connections - No special client software required - Low latency streaming
MJPEG streams each video frame as a separate JPEG image, making it: - Easy to implement and decode - Compatible with most browsers and devices - Suitable for local network streaming - Higher bandwidth than modern codecs but simpler
Common use cases include: - Security camera viewing - Local network video distribution - Simple web-based video monitoring - Development and testing of video pipelines
Clients can view the stream by navigating to: http://[server-ip]:[port]/ in a web browser
## Constructors ### HTTPMJPEGLiveSinkBlock(int) Initializes a new instance of thetrue if successfull, false otherwise.
### CleanUp()
Performs cleanup of resources used by the HTTP MJPEG sink.
```csharp
public void CleanUp()
```
#### Remarks
This method stops the HTTP server, closes all client connections,
and releases the underlying GStreamer element.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad (returns the existing video input pad).
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type (should be video for MJPEG streaming).
#### Returns
Parameters:
- (MediaBlockPad): The video input pad of this sink.
#### Remarks
HTTP MJPEG sink only accepts video input. The video frames will be
automatically converted to JPEG format for streaming.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the URL where the MJPEG stream can be accessed.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): Not implemented for HTTP MJPEG sink.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not applicable for HTTP streaming.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether HTTP MJPEG streaming functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if HTTP MJPEG sink is available; otherwise, false.
Requires GStreamer's multipartmux and souphttpsrc plugins.
#### Remarks
This functionality requires specific GStreamer plugins for HTTP serving
and MJPEG multiplexing. Availability may vary by platform.
### SetFilenameOrURL(string)
Sets the filename or URL for this sink.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The value to set (not applicable).
#### Remarks
HTTP MJPEG sink uses a port number, not a filename or URL.
The URL is determined by the server's IP address and port.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not applicable for HTTP streaming.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class KLVFileSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.KLVFileSinkBlock.html
# Class KLVFileSinkBlock
# Class KLVFileSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block for writing KLV (Key-Length-Value) metadata to files.
Supports MISB standards for metadata encoding used in surveillance and aerospace applications.
```csharp
public class KLVFileSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The KLVFileSinkBlock specializes in handling KLV-encoded metadata streams, which are widely used in defense, surveillance, and aerospace industries. Key features: - MISB (Motion Imagery Standards Board) compliant metadata handling - STANAG 4609 compatible encoding - Synchronous metadata storage with video streams - Support for various KLV data types and structures
KLV metadata typically includes: - GPS coordinates and altitude - Camera orientation (pan, tilt, roll) - Platform information (aircraft, drone, vehicle) - Timestamp and synchronization data - Target tracking information - Environmental data (weather, visibility)
Common use cases: - UAV/Drone video metadata recording - Surveillance system metadata storage - Military and defense applications - Geospatial video indexing - Compliance with government standards
The sink writes raw KLV data that can be multiplexed with video or stored separately for later synchronization.
## Constructors ### KLVFileSinkBlock(string) Initializes a new instance of thefilename is null or empty.
## Properties
### Filename
Gets or sets the output filename for KLV metadata storage.
```csharp
public string Filename { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
The file will contain raw KLV packets that can be parsed by KLV-aware applications
or multiplexed with corresponding video streams.
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds this instance.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if successfull, false otherwise.
### CleanUp()
Performs cleanup of resources used by the KLV file sink.
```csharp
public void CleanUp()
```
#### Remarks
This method ensures all KLV packets are written to disk,
closes the file, and releases the underlying GStreamer element.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for KLV metadata storage.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The full path to the KLV output file.
### IsAvailable()
Determines whether KLV file sink functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if KLV sink is available; otherwise, false.
Requires specialized KLV handling plugins.
#### Remarks
KLV support requires specific GStreamer plugins that may not be available
in standard distributions. Professional or specialized builds may be required.
### SetFilenameOrURL(string)
Sets the output filename for KLV metadata storage.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The full path where the KLV file should be written.
#### Remarks
Changing the filename after the pipeline has started may not take effect
until the pipeline is restarted.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class M4AOutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.M4AOutputBlock.html
# Class M4AOutputBlock
# Class M4AOutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
M4A audio container output block for creating high-quality AAC audio files with MP4 container format.
Provides professional audio file creation with configurable AAC encoding for music production, podcasting,
and audio content distribution with industry-standard M4A format supporting metadata and chapter information.
Implements the true if the M4A output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the M4A output operations, including encoder, sink, and file handles.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of audio streams.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (typically Audio) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the M4A output block.
Properly disposes of GStreamer elements, encoder, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the M4A content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the M4A output destination.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (typically Audio) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable(IAACEncoderSettings)
Determines whether M4A output functionality is available on the current system with the specified encoder settings.
Requires GStreamer MP4 muxer and AAC audio encoder plugins to be installed and functional.
```csharp
public static bool IsAvailable(IAACEncoderSettings aacSettings)
```
#### Parameters
Parameters:
- aacSettings (IAACEncoderSettings): The AAC audio encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if M4A output with AAC encoding is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the M4A file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where M4A content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this M4A output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this M4A output block.
## See Also
---
# Class MKVOutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MKVOutputBlock.html
# Class MKVOutputBlock
# Class MKVOutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
MKV (Matroska Video) multimedia container output block for creating versatile video files with advanced encoding capabilities.
Provides comprehensive MKV file creation with support for multiple video encoders (H.264, HEVC, VP8/VP9, AV1) and audio encoders (AAC, MP3, Vorbis, OPUS, Speex)
for professional video production, streaming content preparation, and multimedia archival storage with industry-leading container format flexibility.
Implements the true if the MKV output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the MKV output operations, including encoders, sink, and file handles.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of video and audio streams.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the MKV output block.
Properly disposes of GStreamer elements, encoders, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the MKV content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the MKV output destination.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable(IH264EncoderSettings, IAACEncoderSettings)
Determines whether MKV output functionality is available on the current system with the specified encoder settings.
Requires GStreamer MKV muxer and the specified video and audio encoder plugins to be installed and functional.
```csharp
public static bool IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)
```
#### Parameters
Parameters:
- h264settings (IH264EncoderSettings): The H.264 video encoder settings to validate for availability.
- aacSettings (IAACEncoderSettings): The AAC audio encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if MKV output with the specified encoders is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the MKV file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where MKV content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this MKV output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this MKV output block.
## See Also
---
# Class MKVSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MKVSinkBlock.html
# Class MKVSinkBlock
# Class MKVSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
MKV (Matroska) sink block for creating highly flexible multimedia container files.
```csharp
public class MKVSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The MKV sink block creates Matroska files, one of the most flexible and feature-rich multimedia container formats available. Matroska is an open-source format that can hold an unlimited number of video, audio, subtitle, and metadata tracks in a single file. It's particularly popular for high-quality video archiving and distribution.
Key Features:
Typical Use Cases:
Technical Specifications:
Advantages over other containers: MKV offers more features than MP4 but may have less universal playback support. It's ideal when flexibility and features are more important than compatibility. Modern players and devices increasingly support MKV natively.
## Constructors ### MKVSinkBlock(MKVSinkSettings) Initializes a new instance of thetrue if the sink was successfully built and all requested input pads were created;
false if initialization failed or required pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer Matroska muxer and configures input pads
for video, audio, and subtitle streams. MKV's flexibility means it can accept multiple
streams of each type, creating a multi-track output file.
### CleanUp()
Cleans up resources and finalizes the MKV file.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer Matroska muxer and ensures
the MKV file is properly finalized with all necessary headers, indexes,
and seek tables for optimal playback.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. MKV supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists. Note that MKV can have
multiple pads of the same type for multi-track files.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output filename for the MKV file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The file path where the MKV file should be written.
The directory must exist. Use the .mkv extension for video files.
#### Remarks
This method only updates the settings. The filename cannot be changed
once the pipeline is running and writing has begun.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The The MOVSinkBlock creates QuickTime movie files (.mov), Apple's multimedia container format. Key features include: - Multiple video tracks with various codecs (H.264, ProRes, etc.) - Multiple audio tracks with different formats (AAC, PCM, etc.) - Chapter markers and metadata support - Fast-start optimization for web streaming - Professional video editing compatibility
MOV files are preferred for: - macOS and iOS compatibility - Professional video editing workflows - ProRes video storage - Multi-track editing projects - Broadcast and production environments
The sink supports various Apple-specific features: - Timecode tracks - Color space metadata - HDR information - Professional codec support
Common use cases: - Final Cut Pro compatible exports - Professional video archiving - Multi-angle video projects - High-quality video distribution
## Constructors ### MOVSinkBlock(MOVSinkSettings) Initializes a new instance of thesettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the MOV file creation settings.
```csharp
public MOVSinkSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (MOVSinkSettings):
#### Remarks
Settings control:
- Output filename and location
- Fast-start mode for progressive download
- Fragment duration for streaming
- Metadata and tagging options
- Codec-specific parameters for each track
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds this instance.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if successfull, false otherwise.
### CleanUp()
Performs cleanup of resources used by the MOV sink.
```csharp
public void CleanUp()
```
#### Remarks
This method finalizes the MOV file structure, writes all indexes,
and ensures the file is properly closed for playback compatibility.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for adding a media track to the MOV file.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media track to add (video or audio).
#### Returns
Parameters:
- (MediaBlockPad): A new true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for the MOV file.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The full path to the output MOV file.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether MOV file creation functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if MOV sink is available; otherwise, false.
Requires GStreamer's qtmux element and compatible codecs.
#### Remarks
MOV support requires the GStreamer good plugins package.
Some professional codecs like ProRes may require additional plugins.
### SetFilenameOrURL(string)
Sets the output filename for the MOV file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The full path where the MOV file should be written.
#### Remarks
The file extension should be .mov for proper format recognition.
Changing the filename after pipeline start requires a restart.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class MP3OutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MP3OutputBlock.html
# Class MP3OutputBlock
# Class MP3OutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
MP3 audio output block for creating widely compatible compressed audio files with professional encoding capabilities.
Provides industry-standard MP3 audio file creation with configurable lossy compression for music distribution, podcasting,
and audio content creation with broad device compatibility and efficient file sizes for streaming and storage optimization.
Implements the true if the MP3 output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the MP3 output operations, including encoder, sink, and file handles.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the MP3 output block.
Properly disposes of GStreamer elements, encoder, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the MP3 content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the MP3 output destination.
### IsAvailable()
Determines whether MP3 output functionality is available on the current system.
Requires GStreamer MP3 encoder and file sink plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if MP3 output is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the MP3 file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where MP3 content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this MP3 output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this MP3 output block.
## See Also
---
# Class MP4OutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MP4OutputBlock.html
# Class MP4OutputBlock
# Class MP4OutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
MP4 multimedia container output block for creating industry-standard MP4 video files with integrated encoding capabilities.
Provides comprehensive MP4 file creation with configurable video and audio encoders, supporting H.264/H.265 video with AAC/MP3 audio
for professional video production, streaming content preparation, and multimedia distribution with broad device compatibility.
Implements the true if the MP4 output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the MP4 output operations, including encoders, sink, and file handles.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of video and audio streams.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the MP4 output block.
Properly disposes of GStreamer elements, encoders, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the MP4 content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the MP4 output destination.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable(IH264EncoderSettings, IAACEncoderSettings)
Determines whether MP4 output functionality is available on the current system with the specified encoder settings.
Requires GStreamer MP4 muxer and the specified video and audio encoder plugins to be installed and functional.
```csharp
public static bool IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)
```
#### Parameters
Parameters:
- h264settings (IH264EncoderSettings): The H.264 video encoder settings to validate for availability.
- aacSettings (IAACEncoderSettings): The AAC audio encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if MP4 output with the specified encoders is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the MP4 file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where MP4 content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this MP4 output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this MP4 output block.
## See Also
---
# Class MP4SinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MP4SinkBlock.html
# Class MP4SinkBlock
# Class MP4SinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
MP4 (MPEG-4 Part 14) sink block for writing media streams to MP4 container files.
```csharp
public class MP4SinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The MP4 sink block provides comprehensive support for creating MP4 files, the industry-standard container format for digital multimedia. MP4 files can contain video, audio, subtitles, and metadata tracks, making it ideal for a wide range of applications from video recording to streaming content preparation.
Key Features:
Typical Use Cases:
Technical Specifications:
true if the sink was successfully built, all requested input pads were created,
and output pad was configured (if in mux-only mode); false if initialization
failed or required pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer MP4 muxer (qtmux) element and configures
input pads for each media stream. For split sink configurations, it uses specialized
pad templates. The method is idempotent and will return immediately if already built.
### CleanUp()
Cleans up resources and resets the sink block to an unbuilt state.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer MP4 muxer element and
resets the build state. After cleanup, the block can be rebuilt with
new settings if needed. Any ongoing file writing will be terminated.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept on this input pad. MP4 supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists. Use true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output filename or URL for the MP4 file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The file path where the MP4 file should be written. For standard recording,
this should be a complete filename. For split recording, use a template with
format specifiers (e.g., "video_%05d.mp4") to generate sequential filenames.
#### Remarks
This method updates both the settings and the underlying GStreamer element
if the sink has already been built. Changing the filename during active
recording is not recommended and may cause unexpected behavior.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The The MPEGPSSinkBlock creates MPEG Program Stream files, a container format primarily used for: - DVD-Video authoring and playback - MPEG-1 and MPEG-2 video storage - Legacy video archiving systems - Standalone media player compatibility
MPEG-PS characteristics: - Designed for reliable storage media (DVDs, hard drives) - Contains timing information for synchronized playback - Supports multiple video and audio streams - Variable bitrate encoding support - System clock reference (SCR) for timing
Typical stream configurations: - Video: MPEG-2 (DVD), MPEG-1 (VCD) - Audio: MPEG-1 Layer II (MP2), AC-3, PCM - Subtitles: DVD subpicture format - Maximum bitrate: 10.08 Mbps for DVD compliance
Common use cases: - DVD authoring and production - Legacy video system compatibility - Archival storage of MPEG content - Set-top box and hardware player support
## Constructors ### MPEGPSSinkBlock(string) Initializes a new instance of thefilename is null or empty.
## Properties
### Filename
Gets or sets the output filename for the MPEG-PS file.
```csharp
public string Filename { get; set; }
```
#### Property Value
Parameters:
- (string):
#### Remarks
For DVD compliance, ensure the filename follows DVD naming conventions
(e.g., VTS_01_1.VOB for DVD-Video).
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the MPEG-PS sink and prepares it for multiplexing.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the build was successful; otherwise, false.
#### Remarks
This method creates the MPEG-PS muxer and configures input pads for all
connected streams. The muxer will handle proper packet interleaving and
timing information generation.
### CleanUp()
Performs cleanup of resources used by the MPEG-PS sink.
```csharp
public void CleanUp()
```
#### Remarks
This method finalizes the MPEG-PS file structure, ensures all packets
are written, and releases the underlying muxer element.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for adding a stream to the MPEG-PS file.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of stream to add (video, audio, or subtitle).
#### Returns
Parameters:
- (MediaBlockPad): A new true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for the MPEG-PS file.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The full path to the output MPEG-PS file.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether MPEG-PS muxing functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if MPEG-PS sink is available; otherwise, false.
Requires GStreamer's mpegpsmux element.
#### Remarks
MPEG-PS support is typically available in GStreamer's bad plugins package.
DVD-compliant muxing may require additional configuration.
### SetFilenameOrURL(string)
Sets the output filename for the MPEG-PS file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The full path where the MPEG-PS file should be written.
#### Remarks
Changing the filename after the pipeline has started requires a pipeline restart.
For DVD authoring, follow proper naming conventions.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class MPEGTSSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MPEGTSSinkBlock.html
# Class MPEGTSSinkBlock
# Class MPEGTSSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Implements a sink block for creating MPEG Transport Stream (MPEG-TS) files or streams.
Supports broadcasting, streaming, and digital TV distribution formats.
```csharp
public class MPEGTSSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The MPEGTSSinkBlock creates MPEG Transport Streams, the standard format for: - Digital television broadcasting (DVB, ATSC, ISDB) - IPTV and streaming services - Blu-ray disc video - Network streaming protocols (HLS, MPEG-DASH)
MPEG-TS characteristics: - Fixed-size 188-byte packets for error resilience - Designed for unreliable transmission (broadcast, network) - Program Association Table (PAT) and Program Map Table (PMT) - Support for multiple programs in a single stream - PCR (Program Clock Reference) for synchronization
Key features: - Multiple video/audio/data streams per program - Service information (SI) tables - Conditional access support (encryption) - Time-stamped packets for live streaming - Can output to file or network stream
Common use cases: - Live TV broadcasting and recording - HLS streaming preparation - Network video distribution - Set-top box recording format - Professional broadcast workflows
## Constructors ### MPEGTSSinkBlock(MPEGTSSinkSettings) Initializes a new instance of thesettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the MPEG-TS sink and configures it for operation.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the build was successful; otherwise, false.
#### Remarks
This method:
- Creates the MPEG-TS muxer with specified settings
- Configures input pads for all elementary streams
- Sets up output (file or streaming pad)
- Initializes program tables and PIDs
### CleanUp()
Performs cleanup of resources used by the MPEG-TS sink.
```csharp
public void CleanUp()
```
#### Remarks
This method ensures all packets are written, finalizes the transport stream
structure, and releases the underlying muxer element.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for adding an elementary stream to the transport stream.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of elementary stream (video, audio, or data).
#### Returns
Parameters:
- (MediaBlockPad): A new true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for the MPEG-TS file.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The full path to the output file, or null if configured for streaming output.
### GetInput(MediaBlockPadMediaType)
Gets the existing input.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): Type of the media.
#### Returns
Parameters:
- (MediaBlockPad): MediaBlockPad.
### IsAvailable()
Determines whether MPEG-TS muxing functionality is available on the current platform.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if MPEG-TS sink is available; otherwise, false.
Requires GStreamer's mpegtsmux element.
#### Remarks
MPEG-TS support is part of GStreamer's bad plugins package.
This is a widely supported format across all platforms.
### SetFilenameOrURL(string)
Sets the output filename for the MPEG-TS file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The full path where the MPEG-TS file should be written.
#### Remarks
This only applies when the sink is configured for file output.
For streaming output, use the output pad instead.
Common extensions are .ts, .mts, or .m2ts.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class MXFSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.MXFSinkBlock.html
# Class MXFSinkBlock
# Class MXFSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Provides a media sink for writing MXF (Material eXchange Format) files with professional broadcast features.
```csharp
public class MXFSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Create MXF sink for broadcast-quality recording
var settings = new MXFSinkSettings
{
Filename = "output.mxf",
VideoStreamType = MXFVideoStreamType.DNxHD,
AudioStreamType = MXFAudioStreamType.Uncompressed
};
var mxfSink = new MXFSinkBlock(settings);
// Create inputs for video and audio
var videoInput = mxfSink.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInput = mxfSink.CreateNewInput(MediaBlockPadMediaType.Audio);
// Connect to pipeline
pipeline.Connect(videoEncoder.Output, videoInput);
pipeline.Connect(audioSource.Output, audioInput);The MXFSinkBlock enables recording of audio and video content to MXF files, a professional format widely used in broadcast and post-production workflows. It supports multiple video and audio stream types with broadcast-quality encoding options.
Key features include:
Common use cases:
The block automatically selects appropriate pad templates based on the configured video and audio stream types in the settings. Multiple streams can be multiplexed into a single MXF container.
## Constructors ### MXFSinkBlock(MXFSinkSettings) Initializes a new instance of thesettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the MXF sink configuration settings.
```csharp
public MXFSinkSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (MXFSinkSettings):
#### Remarks
The settings determine which video and audio stream types are supported and how
the MXF container is structured. Changes to settings after building the block
will not take effect.
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the MXF sink block and configures input pads based on stream type settings.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built; otherwise, false.
#### Remarks
This method initializes the underlying GStreamer MXF muxer element and creates appropriate input pads based on the configured video and audio stream types. Each input pad is matched to a specific pad template that corresponds to the desired codec format.
Pad template mapping:
The method will skip any input pads that don't have a corresponding template for the configured stream type. Subtitle inputs are currently not processed.
### CleanUp() Cleans up. ```csharp public void CleanUp() ``` ### CreateNewInput(MediaBlockPadMediaType) Creates a new input pad for the specified media type to support multi-stream recording. ```csharp public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType) ``` #### Parameters Parameters: - mediaType (MediaBlockPadMediaType): The type of media stream (video, audio, or subtitle) for the new input. #### Returns Parameters: - (MediaBlockPad): A newThis method enables dynamic creation of inputs for multi-track MXF files. Each input corresponds to a separate stream in the output file. The actual pad template used depends on the stream type configured in the settings.
Multiple inputs of the same type can be created for multi-track scenarios (e.g., multiple audio tracks for different languages).
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for the MXF file.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The configured output filename path.
#### Remarks
This method implements the IMediaBlockSink interface requirement and returns
the filename specified in the settings.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad of the specified media type.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first null if none exists.
#### Remarks
This method returns the first input pad that matches the requested media type.
If multiple inputs of the same type exist, only the first one is returned.
Use true if MXF writing is supported; otherwise, false.
#### Remarks
Availability depends on the presence of required GStreamer plugins (mxf muxer) and
appropriate codec support. The correct NuGet SDK redistribution package must be
included in your project for this block to function.
### SetFilenameOrURL(string)
Sets the output filename for the MXF file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new output filename path.
#### Remarks
This method updates the filename in the settings. Changes made after the block is built will not take effect until the block is rebuilt.
The filename should include the full path and use the .mxf extension for proper file type identification.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline) Sets the context. ```csharp void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline) ``` #### Parameters Parameters: - pipeline (MediaBlocksPipeline): The pipeline. ## See Also --- # Class NDISinkBlock Link: api/VisioForge.Core.MediaBlocks.Sinks.NDISinkBlock.html # Class NDISinkBlock # Class NDISinkBlock **Namespace**: VisioForge.Core.MediaBlocks.Sinks **Assembly**: VisioForge.Core.dll NDI (Network Device Interface) sink block for broadcasting video over IP networks. ```csharp public class NDISinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockInternals2, IMediaBlockDynamicInputs ``` #### Inheritance #### Implements #### Inherited Members #### Extension Methods ## RemarksThe NDI sink block enables high-quality, low-latency video transmission over standard Ethernet networks using NewTek's NDI protocol. NDI has become the de facto standard for IP video production, allowing multiple video systems to identify and communicate with one another over IP, and to encode, transmit, and receive high-quality video with minimal latency.
Key Features:
Typical Use Cases:
Technical Requirements:
Platform Notes: The implementation differs between platforms. On Windows, it may use direct NDI SDK integration, while on other platforms it uses GStreamer's NDI plugin. The NDI_RUNTIME_DIR_V5 or NDI_RUNTIME_DIR_V6 environment variable must be set.
## Constructors ### NDISinkBlock(NDISinkSettings) Initializes a new instance of thetrue if successfull, false otherwise.
### CleanUp()
Cleans up resources and stops NDI transmission.
```csharp
public void CleanUp()
```
#### Remarks
This method stops the NDI sender, disposes of buffer sinks (on Windows),
or the GStreamer element (on other platforms), and resets the build state.
The NDI source will disappear from the network after cleanup.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. NDI supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Returns null as the NDI sink uses either platform-specific implementations
or direct GStreamer elements without a wrapper.
### GetElement()
Gets the native GStreamer element for direct GStreamer API access.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Returns null as the NDI sink implementation varies by platform
and may not expose a single GStreamer element.
### GetFilenameOrURL()
Gets the NDI source name that identifies this sender on the network.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The NDI source name as configured in the settings.
This name is what other NDI devices will see when discovering sources.
### GetInput(MediaBlockPadMediaType)
Gets an existing input pad that matches the specified media type.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type to search for among existing input pads.
#### Returns
Parameters:
- (MediaBlockPad): The first null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### PostConnect()
Called after all input pads have been connected to perform post-connection setup.
```csharp
public bool PostConnect()
```
#### Returns
Parameters:
- (bool): true if post-connection setup succeeded; false on Windows platforms
where this step is not needed, or if the setup failed on other platforms.
#### Remarks
This method is part of the IMediaBlockInternals2 interface and handles
platform-specific initialization that must occur after pad connections are established.
### SetFilenameOrURL(string)
Sets the NDI source name for network identification.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new NDI source name. This should be descriptive and unique
to help users identify this source among other NDI sources on the network.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the OGG Opus output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the OGG Opus output operations, including encoder, sink, and file handles.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the OGG Opus output block.
Properly disposes of GStreamer elements, encoder, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the OGG Opus content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the OGG Opus output destination.
### IsAvailable()
Determines whether OGG Opus output functionality is available on the current system.
Requires GStreamer OGG muxer, OPUS encoder, and file sink plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OGG Opus output is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the OGG file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where OGG Opus content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this OGG Opus output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this OGG Opus output block.
## See Also
---
# Class OGGSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.OGGSinkBlock.html
# Class OGGSinkBlock
# Class OGGSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Provides a media sink for writing OGG container files with Vorbis audio and Theora video streams.
```csharp
public class OGGSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Create OGG sink for recording
var settings = new OGGSinkSettings
{
Filename = "output.ogg",
EnableMetadata = true
};
var oggSink = new OGGSinkBlock(settings);
// Create inputs for video and audio
var videoInput = oggSink.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInput = oggSink.CreateNewInput(MediaBlockPadMediaType.Audio);
// Connect encoded streams
pipeline.Connect(theoraEncoder.Output, videoInput);
pipeline.Connect(vorbisEncoder.Output, audioInput);The OGGSinkBlock enables recording of audio and video content to OGG files, an open-source container format commonly used with Vorbis audio and Theora video codecs. It supports multiplexing multiple audio and video streams into a single container file.
Key features include:
Common use cases:
The block expects pre-encoded Theora video and Vorbis audio streams. Encoding must be performed by upstream encoder blocks before connecting to this sink.
## Constructors ### OGGSinkBlock(OGGSinkSettings) Initializes a new instance of thesettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the OGG sink configuration settings.
```csharp
public OGGSinkSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (OGGSinkSettings):
#### Remarks
The settings determine the output filename and various OGG container options.
Changes to settings after building the block will not take effect.
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the OGG sink block and configures input pads for video and audio streams.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built; otherwise, false.
#### Remarks
This method initializes the underlying GStreamer OGG muxer element and creates appropriate input pads for each configured stream. The muxer uses specific pad templates for different stream types:
Subtitle inputs are currently not supported by the OGG format and will be skipped. Each successfully created pad is assigned to its corresponding input in the block.
### CleanUp() Cleans up. ```csharp public void CleanUp() ``` ### CreateNewInput(MediaBlockPadMediaType) Creates a new input pad for the specified media type to support multi-stream OGG files. ```csharp public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType) ``` #### Parameters Parameters: - mediaType (MediaBlockPadMediaType): The type of media stream (video or audio) for the new input. #### Returns Parameters: - (MediaBlockPad): A newThis method enables dynamic creation of inputs for multi-stream OGG files. Video inputs expect Theora-encoded streams, while audio inputs expect Vorbis-encoded streams.
Multiple streams of the same type can be created (e.g., multiple audio tracks for different languages or commentary tracks).
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the output filename for the OGG file.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The configured output filename path.
#### Remarks
This method implements the IMediaBlockSink interface requirement and returns
the filename specified in the settings.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad of the specified media type.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The media type to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first null if none exists.
#### Remarks
This method returns the first input pad that matches the requested media type.
If multiple inputs of the same type exist, only the first one is returned.
Use true if OGG muxing is supported; otherwise, false.
#### Remarks
Availability depends on the presence of required GStreamer plugins (oggmux) and
the correct NuGet SDK redistribution package must be included in your project.
### SetFilenameOrURL(string)
Sets the output filename for the OGG file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new output filename path.
#### Remarks
This method updates the filename in the settings. Changes made after the block is built will not take effect until the block is rebuilt.
The filename should include the full path and use the .ogg or .ogv extension for proper file type identification.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline) Sets the context. ```csharp void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline) ``` #### Parameters Parameters: - pipeline (MediaBlocksPipeline): The pipeline. ## See Also --- # Class OGGSpeexOutputBlock Link: api/VisioForge.Core.MediaBlocks.Sinks.OGGSpeexOutputBlock.html # Class OGGSpeexOutputBlock # Class OGGSpeexOutputBlock **Namespace**: VisioForge.Core.MediaBlocks.Sinks **Assembly**: VisioForge.Core.dll OGG Speex output block for creating compressed voice audio files optimized for speech content. This block combines Speex audio encoding with OGG container packaging, providing an efficient solution for voice recording, VoIP applications, and speech archival. Speex is specifically designed for speech compression, offering superior quality at low bitrates compared to general-purpose audio codecs. The OGG container provides an open, patent-free format with excellent streaming capabilities and metadata support. Key features: - Ultra-efficient speech compression (2-44 kbps) - Voice Activity Detection (VAD) for silence suppression - Variable bitrate (VBR) encoding for optimal quality/size ratio - Wideband (16 kHz) and ultra-wideband (32 kHz) support - Acoustic echo cancellation compatibility - Packet loss concealment for streaming applications Common use cases: - Voice recording and dictation systems - Podcast production with speech-only content - VoIP and telecommunication applications - Audio books and spoken word archives - Voice memo and note-taking applications - Language learning materials While Speex has been largely superseded by Opus for new applications, it remains valuable for legacy system compatibility and specific speech-only scenarios where its optimizations provide benefits. Implements thetrue if the output pipeline was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the OGG Speex output.
Disposes the encoder, sink, and releases file handles.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of encoder, muxer, and file resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element. Not applicable for composite blocks.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple elements.
### GetElement()
Gets the underlying GStreamer element. Not applicable for composite blocks.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple elements.
### GetFilenameOrURL()
Gets the current output filename where the OGG Speex audio is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path for the OGG Speex output.
### IsAvailable()
Determines whether OGG Speex output functionality is available on the current system.
Requires the GStreamer Speex plugin and OGG muxer to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OGG Speex encoding is supported; otherwise, false.
### SetFilenameOrURL(string)
Sets a new output filename for the OGG Speex file.
Allows changing the output destination during pipeline operation.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path for OGG Speex output.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this output block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Class OGGVorbisOutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.OGGVorbisOutputBlock.html
# Class OGGVorbisOutputBlock
# Class OGGVorbisOutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
OGG Vorbis output block for creating high-quality compressed audio files using the open-source Vorbis codec.
This block combines Vorbis audio encoding with OGG container packaging, providing an excellent
solution for music distribution, streaming audio, and multimedia content creation. Vorbis offers
superior audio quality compared to MP3 at similar bitrates, making it ideal for applications
where audio fidelity is paramount. The OGG container provides a patent-free, open standard
format with robust streaming capabilities and comprehensive metadata support.
Key features:
- High-quality lossy audio compression (45-500 kbps)
- Superior sound quality at low to medium bitrates
- Variable bitrate (VBR) encoding for optimal quality/size ratio
- Support for sample rates up to 192 kHz
- Multi-channel audio support (mono to 7.1 surround)
- Comprehensive metadata tagging (Vorbis comments)
- Streaming-optimized container format
Common use cases:
- Music distribution and archival
- Game audio assets and soundtracks
- Podcast and audiobook production
- Web audio streaming applications
- Open-source multimedia projects
- Cross-platform audio solutions
Vorbis remains an excellent choice for applications requiring
patent-free, high-quality audio compression with broad platform
support and superior performance at medium bitrates.
Implements the true if the output pipeline was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the OGG Vorbis output.
Disposes the encoder, sink, and releases file handles.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of encoder, muxer, and file resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element. Not applicable for composite blocks.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple elements.
### GetElement()
Gets the underlying GStreamer element. Not applicable for composite blocks.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple elements.
### GetFilenameOrURL()
Gets the current output filename where the OGG Vorbis audio is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path for the OGG Vorbis output.
### IsAvailable()
Determines whether OGG Vorbis output functionality is available on the current system.
Requires the GStreamer Vorbis plugin and OGG muxer to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if OGG Vorbis encoding is supported; otherwise, false.
### SetFilenameOrURL(string)
Sets a new output filename for the OGG Vorbis file.
Allows changing the output destination during pipeline operation.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path for OGG Vorbis output.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this output block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Class RTMPSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.RTMPSinkBlock.html
# Class RTMPSinkBlock
# Class RTMPSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
RTMP (Real-Time Messaging Protocol) sink block for streaming media to RTMP servers.
```csharp
public class RTMPSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The RTMP sink block enables live streaming of audio and video content to RTMP-compatible streaming servers and platforms. RTMP is the de facto standard for live streaming, supported by major platforms like YouTube Live, Facebook Live, Twitch, and custom streaming servers like Wowza, nginx-rtmp, and Adobe Media Server.
Key Features:
Typical Use Cases:
Technical Requirements:
Limitations:
true if the sink was successfully built and configured for streaming;
false if initialization failed, the RTMP URL is invalid, or required
pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer RTMP sink element and configures
it with the provided server URL and settings. It also sets up input pads for
video and audio streams. The sink will attempt to connect to the RTMP server
when the pipeline starts playing.
### CleanUp()
Cleans up resources and disconnects from the RTMP server.
```csharp
public void CleanUp()
```
#### Remarks
This method closes any active RTMP connection, disposes of the underlying
GStreamer element, and resets the build state. The sink can be rebuilt
with new settings after cleanup if needed.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. RTMP supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the RTMP server URL for streaming.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The RTMP URL where the stream should be sent. Must be in the format:
rtmp://server:port/application/streamkey. For example:
rtmp://a.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx
#### Remarks
Changing the URL during an active stream is not supported and will likely
cause connection errors. Stop the pipeline before changing the destination.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the server was successfully initialized and bound to the port;
false if initialization failed due to port conflicts or configuration errors.
### CleanUp()
Performs cleanup of RTSP server resources and resets to uninitialized state.
Stops the server, closes all client connections, releases the network port,
and disposes of all server-related resources. Essential for proper shutdown
and allowing the port to be reused.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Stops the RTSP server, disconnects all clients, releases network ports,
and cleans up server resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources;
false to release only unmanaged resources.
### GetCore()
Gets the core RTSP server element wrapper.
Provides access to the underlying server for advanced configuration
of RTSP-specific features and session management.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapping the RTSP server instance.
### GetElement()
Gets the raw GStreamer element for the RTSP server.
This provides direct access to the GStreamer RTSP server element
for advanced configuration of server properties.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element implementing RTSP server functionality.
### GetFilenameOrURL()
Gets the RTSP server URL that clients can connect to.
Returns the full RTSP URL including protocol, server address, port, and mount point
(e.g., "rtsp://localhost:8554/stream").
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The complete RTSP URL for client connections.
### IsAvailable()
Determines whether RTSP server functionality is available on the current system.
Checks for required GStreamer RTSP server plugins and network capabilities.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if RTSP server is supported with required plugins installed;
false if missing GStreamer RTSP server components or network restrictions.
### SetFilenameOrURL(string)
Sets the filename or URL. Not supported for RTSP server.
RTSP server configuration should be done through the Settings property.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The value (ignored for RTSP server).
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this RTSP server block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SeparateOutputBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.SeparateOutputBlock.html
# Class SeparateOutputBlock
# Class SeparateOutputBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Separate output block for independent recording with custom video and audio encoder configuration.
Provides isolated recording pipeline with bridge source connections allowing independent recording operations from preview pipeline,
enabling simultaneous preview display and background recording with custom encoder blocks and flexible output configuration.
Implements the true if the separate output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the separate output operations, including bridge sources and encoder blocks.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the separate output block.
Properly disposes of bridge sources, encoders, and pipeline connections.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the separate recording is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the separate recording destination.
### SetFilenameOrURL(string)
Updates the output filename or URL for the separate recording destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string filename)
```
#### Parameters
Parameters:
- filename (string): The new file path or URL where the separate recording should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this separate output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this separate output block.
## See Also
---
# Class ShoutcastSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.ShoutcastSinkBlock.html
# Class ShoutcastSinkBlock
# Class ShoutcastSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
Provides a media sink for streaming audio to Shoutcast/Icecast servers.
```csharp
public class ShoutcastSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Create Shoutcast sink for internet radio
var settings = new ShoutcastSinkSettings
{
URL = "http://streaming.server.com:8000/stream",
Password = "hackme",
Mount = "/live.mp3",
StreamName = "My Radio Station",
StreamGenre = "Rock",
StreamDescription = "24/7 Rock Music"
};
var shoutcastSink = new ShoutcastSinkBlock(settings);
// Connect MP3 encoded audio
pipeline.Connect(mp3Encoder.Output, shoutcastSink.Input);The ShoutcastSinkBlock enables live audio streaming to Shoutcast or Icecast servers, supporting internet radio broadcasting and audio distribution. It accepts encoded audio streams and transmits them to the server using the Shoutcast/Icecast protocol.
Key features include:
Common use cases:
The block expects pre-encoded audio (MP3 or Vorbis) on its input. Raw audio must be encoded by an upstream encoder block before streaming.
## Constructors ### ShoutcastSinkBlock(ShoutcastSinkSettings) Initializes a new instance of theThe settings must specify a valid server URL and authentication credentials before building the block. The block name is automatically set to "ShoutcastSink".
The input pad is configured to accept only audio streams, as Shoutcast/Icecast servers are designed for audio broadcasting.
#### Exceptions Parameters: - (ArgumentNullException): Thrown whensettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the Shoutcast sink configuration settings.
```csharp
public ShoutcastSinkSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (ShoutcastSinkSettings):
#### Remarks
The settings include server URL, authentication credentials, mount point, and
stream metadata like name, genre, and description. Changes to settings after
building the block will not take effect.
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the Shoutcast sink block and configures the streaming connection.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built; otherwise, false.
#### Remarks
This method initializes the underlying GStreamer Shoutcast sink element (shout2send) with the configured server settings. The sink accepts encoded audio through its single "sink" pad.
The build process:
The element will attempt to connect to the server when the pipeline starts playing. Connection failures will be reported through the pipeline's error handling mechanism.
### CleanUp() Cleans up. ```csharp public void CleanUp() ``` ### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the Shoutcast/Icecast server URL.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The configured server URL including mount point.
#### Remarks
This method implements the IMediaBlockSink interface requirement and returns the server URL from the settings. The URL typically includes the server address, port, and mount point.
Example: "http://server.com:8000/stream.mp3"
### IsAvailable() Determines whether the Shoutcast sink functionality is available in the current environment. ```csharp public static bool IsAvailable() ``` #### Returns Parameters: - (bool):true if Shoutcast/Icecast streaming is supported; otherwise, false.
#### Remarks
Availability depends on the presence of the required GStreamer plugin (shout2send).
The correct NuGet SDK redistribution package must be included in your project
for this block to function.
### SetFilenameOrURL(string)
Sets the Shoutcast/Icecast server URL.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new server URL including mount point.
#### Remarks
This method updates the URL in the settings. Changes made after the block is built will not take effect until the block is rebuilt.
The URL should include:
// Create SRT MPEG-TS sink for streaming
var settings = new SRTSinkSettings
{
Uri = "srt://192.168.1.100:9000",
Mode = SRTMode.Caller,
Latency = 120, // milliseconds
Passphrase = "secretkey" // Optional encryption
};
var srtSink = new SRTMPEGTSSinkBlock(settings);
// Create inputs for streams
var videoInput = srtSink.CreateNewInput(MediaBlockPadMediaType.Video);
var audioInput = srtSink.CreateNewInput(MediaBlockPadMediaType.Audio);
// Connect encoded streams
pipeline.Connect(h264Encoder.Output, videoInput);
pipeline.Connect(aacEncoder.Output, audioInput);The SRTMPEGTSSinkBlock combines MPEG-TS multiplexing with SRT streaming to enable low-latency, secure, and reliable media transport over unreliable networks. It multiplexes audio and video streams into MPEG-TS format and transmits them using the SRT protocol.
Key features include:
Common use cases:
The block expects pre-encoded streams compatible with MPEG-TS format (H.264/H.265 video, AAC/MP3 audio). It first multiplexes streams into MPEG-TS, then transmits via SRT.
## Constructors ### SRTMPEGTSSinkBlock(SRTSinkSettings) Initializes a new instance of theThe settings must specify a valid SRT URI and connection mode before building the block. The block name is automatically set to "SRTMPEGTSSinkBlock".
This sink combines MPEG-TS multiplexing with SRT transport, making it suitable for professional streaming applications requiring reliability and low latency.
#### Exceptions Parameters: - (ArgumentNullException): Thrown whensettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the SRT MPEG-TS sink block and configures input pads for streaming.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built; otherwise, false.
#### Remarks
This method initializes the underlying GStreamer pipeline that combines MPEG-TS multiplexing with SRT output. The pipeline structure is:
[inputs] -> mpegtsmux -> srtsinkAll input pads use the "sink_%d" template from the MPEG-TS muxer, which accepts various elementary stream formats. The muxer output is then sent to the SRT sink for network transmission.
If the internal element's input is null, the build will fail with an appropriate error message logged to the context.
### CleanUp() Cleans up. ```csharp public void CleanUp() ``` ### CreateNewInput(MediaBlockPadMediaType) Creates a new input pad for the specified media type to support multi-stream MPEG-TS. ```csharp public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType) ``` #### Parameters Parameters: - mediaType (MediaBlockPadMediaType): The type of media stream (video, audio, or subtitle) for the new input. #### Returns Parameters: - (MediaBlockPad): A newThis method enables dynamic creation of inputs for multi-stream MPEG-TS multiplexing. All inputs share the same "sink_%d" pad template, allowing flexible stream configuration.
The MPEG-TS format supports multiple elementary streams, making it suitable for multi-language audio, multiple video angles, or subtitle tracks.
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the SRT streaming URI.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The configured SRT URI as a string.
#### Remarks
This method implements the IMediaBlockSink interface requirement and returns the SRT URI from the settings. The URI typically follows the format:
srt://hostname:port?optionsnull if none exists.
#### Remarks
This method returns the first input pad that matches the requested media type.
If multiple inputs of the same type exist, only the first one is returned.
Use true if SRT streaming with MPEG-TS is supported; otherwise, false.
#### Remarks
Availability depends on the presence of required GStreamer plugins (mpegtsmux, srtsink)
and the correct NuGet SDK redistribution package must be included in your project.
Both MPEG-TS multiplexing and SRT protocol support are required.
### SetFilenameOrURL(string)
Sets the SRT streaming URI.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new SRT URI string.
#### Remarks
This method updates the URI in the settings. Changes made after the block is built will not take effect until the block is rebuilt.
The URI should follow the SRT protocol format:
srt://hostname:port?param1=value1¶m2=value2Common parameters include mode (caller/listener), latency, passphrase, and streamid.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline) Sets the context. ```csharp void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline) ``` #### Parameters Parameters: - pipeline (MediaBlocksPipeline): The pipeline. ## See Also --- # Class SRTSinkBlock Link: api/VisioForge.Core.MediaBlocks.Sinks.SRTSinkBlock.html # Class SRTSinkBlock # Class SRTSinkBlock **Namespace**: VisioForge.Core.MediaBlocks.Sinks **Assembly**: VisioForge.Core.dll Provides a media sink for streaming raw data over SRT (Secure Reliable Transport) protocol. ```csharp public class SRTSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals ``` #### Inheritance #### Implements #### Inherited Members #### Extension Methods ## Examples// Create SRT sink for direct streaming
var settings = new SRTSinkSettings
{
Uri = "srt://streaming.server.com:9000",
Mode = SRTMode.Caller,
Latency = 80, // milliseconds
Passphrase = "mySecureKey",
StreamId = "live/channel1"
};
var srtSink = new SRTSinkBlock(settings);
// Connect a muxed stream
pipeline.Connect(mpegtsMuxer.Output, srtSink.Input);The SRTSinkBlock enables direct streaming of any media data over the SRT protocol, providing low-latency, secure, and reliable transport over unreliable networks. Unlike SRTMPEGTSSinkBlock, this sink transmits raw data without MPEG-TS multiplexing.
Key features include:
Common use cases:
The block accepts any type of data stream through its single input pad. For typical video streaming, the input should be a properly formatted stream (e.g., MPEG-TS) created by an upstream muxer.
## Constructors ### SRTSinkBlock(SRTSinkSettings) Initializes a new instance of theThe settings must specify a valid SRT URI and connection mode before building the block. The block name is automatically set to "SRTSink".
The input pad is configured to accept any media type, providing flexibility for different streaming scenarios.
#### Exceptions Parameters: - (ArgumentNullException): Thrown whensettings is null.
## Properties
### Input
Gets the first input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the SRT sink configuration settings.
```csharp
public SRTSinkSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (SRTSinkSettings):
#### Remarks
The settings include URI, connection mode, latency, encryption, and other SRT-specific
parameters. Changes to settings after building the block will not take effect.
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the SRT sink block and configures the streaming endpoint.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built; otherwise, false.
#### Remarks
This method initializes the underlying GStreamer SRT sink element with the configured settings. The sink accepts any type of data through its single "sink" pad.
The build process:
Failure to get the sink pad will result in an error being logged and the
method returning false.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the SRT streaming URI.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The configured SRT URI as a string.
#### Remarks
This method implements the IMediaBlockSink interface requirement and returns the SRT URI from the settings. The URI format is:
srt://hostname:port?param1=value1¶m2=value2true if SRT streaming is supported; otherwise, false.
#### Remarks
Availability depends on the presence of the required GStreamer SRT plugin (srtsink).
The correct NuGet SDK redistribution package must be included in your project
for this block to function.
### SetFilenameOrURL(string)
Sets the SRT streaming URI.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new SRT URI string.
#### Remarks
This method updates the URI in the settings. Changes made after the block is built will not take effect until the block is rebuilt.
The URI should follow the SRT protocol format with optional parameters:
// Write to memory stream
var memoryStream = new MemoryStream();
var streamSink = new StreamSinkBlock(memoryStream);
// Write to file stream with buffering
var fileStream = new FileStream("output.data", FileMode.Create,
FileAccess.Write, FileShare.None, 4096, useAsync: true);
var streamSink = new StreamSinkBlock(fileStream);
// Write to network stream
var tcpClient = new TcpClient("server.com", 8080);
var networkStream = tcpClient.GetStream();
var streamSink = new StreamSinkBlock(networkStream);
// Connect to pipeline
pipeline.Connect(encoder.Output, streamSink.Input);The StreamSinkBlock enables writing media data to any .NET Stream implementation, providing flexible output options for custom storage, network transmission, or in-memory processing. It bridges the GStreamer pipeline with .NET I/O abstractions.
Key features include:
Common use cases:
Important: The provided stream must remain valid and writable throughout the pipeline's lifetime. The stream is not disposed by this block - the caller is responsible for proper stream lifecycle management.
## Constructors ### StreamSinkBlock(Stream) Initializes a new instance of theThe provided stream must support writing and remain valid throughout the pipeline's lifetime. The stream will not be disposed by this block - the caller retains ownership and must handle proper disposal.
The input pad is configured to accept any media type, allowing flexible use with different data formats. The block name is automatically set to "StreamSink".
#### Exceptions Parameters: - (ArgumentNullException): Thrown whenstream is null.
- (ArgumentException): Thrown when stream is not writable.
## Fields
### TAG
The tag.
```csharp
protected const string TAG = "StreamSinkBlock"
```
#### Field Value
Parameters:
- (string):
## Properties
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the stream sink block and configures the stream output.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built; otherwise, false.
#### Remarks
This method initializes the underlying custom GStreamer sink element that writes data to the provided .NET Stream. The sink implements efficient data transfer from GStreamer buffers to the stream.
The build process:
Data written to the stream is buffered internally by GStreamer and flushed according to the pipeline's data flow. The stream should support asynchronous writes for optimal performance.
### CleanUp() Cleans up. ```csharp public void CleanUp() ``` ### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### GetFilenameOrURL()
Gets the filename or URL for this stream sink.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): Always returns null as stream sinks do not have associated filenames.
#### Remarks
This method implements the IMediaBlockSink interface requirement. Since
StreamSinkBlock writes to an arbitrary stream rather than a file, it
returns null to indicate no filename is applicable.
### IsAvailable()
Determines whether the stream sink functionality is available in the current environment.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if stream output is supported; otherwise, false.
#### Remarks
Availability depends on the presence of required GStreamer components for custom
sink implementations. The correct NuGet SDK redistribution package must be
included in your project for this block to function.
### SetFilenameOrURL(string)
Sets the filename or URL for this stream sink.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The filename value (ignored).
#### Remarks
This method implements the IMediaBlockSink interface requirement but has no
effect for StreamSinkBlock, as the output destination is determined by the
stream provided in the constructor. The stream cannot be changed after
construction.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class WAVSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.WAVSinkBlock.html
# Class WAVSinkBlock
# Class WAVSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
WAV sink block for writing uncompressed audio data to WAV (Waveform Audio File Format) files.
```csharp
public class WAVSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The WAV sink block creates standard WAV files containing uncompressed PCM audio data. WAV is the de facto standard for high-quality audio storage on Windows systems and is widely supported across all platforms. It provides perfect audio fidelity at the cost of larger file sizes compared to compressed formats.
Key Features:
Typical Use Cases:
Technical Specifications:
Limitations: Standard WAV files are limited to 4GB due to the 32-bit file size field in the RIFF header. For larger files, consider using RF64/WAV64 format or splitting into multiple files. The lack of compression means significantly larger file sizes compared to formats like MP3 or AAC.
## Constructors ### WAVSinkBlock(string) Initializes a new instance of thetrue if the sink was successfully built and the audio input pad was configured;
false if initialization failed or the file couldn't be opened for writing.
#### Remarks
This method creates the underlying GStreamer WAV encoder and file writer elements.
It configures a single audio input pad that accepts PCM audio data in various
formats (different sample rates, bit depths, and channel configurations).
### CleanUp()
Cleans up resources and finalizes the WAV file.
```csharp
public void CleanUp()
```
#### Remarks
This method ensures the WAV file is properly finalized with correct headers,
including the accurate file size and data chunk size. It then disposes of
the underlying GStreamer elements.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output filename for the WAV file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The file path where the WAV file should be written.
The directory must exist. Use the .wav extension.
#### Remarks
This method only updates the filename property. The actual file location
cannot be changed once the pipeline is running and writing has begun.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the WebM output block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the WebM output operations, including encoders, sink, and file handles.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of video and audio streams.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the WebM output block.
Properly disposes of GStreamer elements, encoders, and file writing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple internal elements.
### GetFilenameOrURL()
Gets the current output filename or URL where the WebM content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path or URL string for the WebM output destination.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video, Audio, or Subtitle) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable(IVPXEncoderSettings)
Determines whether WebM output functionality is available on the current system with the specified encoder settings.
Requires GStreamer WebM muxer and VP8/VP9 video encoder with Vorbis audio encoder plugins to be installed and functional.
```csharp
public static bool IsAvailable(IVPXEncoderSettings videoEncoderSettings)
```
#### Parameters
Parameters:
- videoEncoderSettings (IVPXEncoderSettings): The VP8/VP9 video encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if WebM output with the specified encoders is supported; otherwise, false.
### SetFilenameOrURL(string)
Updates the output filename or URL for the WebM file destination, allowing dynamic output redirection.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path or URL where WebM content should be written.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this WebM output block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this WebM output block.
## See Also
---
# Class WebMSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.WebMSinkBlock.html
# Class WebMSinkBlock
# Class WebMSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
WebM sink block for creating WebM container files with VP8/VP9 video and Vorbis/Opus audio.
```csharp
public class WebMSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The WebM sink block creates WebM files, an open-source multimedia container format designed specifically for the web. WebM is based on a subset of the Matroska (MKV) container and is optimized for streaming over the internet. It's particularly popular for HTML5 video delivery due to its royalty-free codecs and broad browser support.
Key Features:
Typical Use Cases:
Technical Specifications:
Browser Compatibility: WebM is natively supported in most modern browsers without plugins. For maximum compatibility, consider providing fallback formats like MP4.
## Constructors ### WebMSinkBlock(WebMSinkSettings) Initializes a new instance of thetrue if the sink was successfully built and all requested input pads were created;
false if initialization failed or required pads couldn't be allocated.
#### Remarks
This method creates the underlying GStreamer WebM muxer element and configures
input pads for each media stream. The muxer expects VP8/VP9 video and/or
Vorbis/Opus audio streams.
### CleanUp()
Cleans up resources and finalizes the WebM file.
```csharp
public void CleanUp()
```
#### Remarks
This method disposes of the underlying GStreamer WebM muxer element and
ensures the WebM file is properly finalized with correct headers and indexes.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. WebM supports:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the output filename for the WebM file.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The file path where the WebM file should be written.
The directory must exist. Use the .webm extension for proper file association.
#### Remarks
This method only updates the settings. The actual file location cannot be
changed once the pipeline is running.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the output pipeline was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the WMV output.
Disposes the ASF sink, video encoder, and audio encoder.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type.
Enables dynamic addition of video and audio streams to the WMV output.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video or Audio) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
Ensures proper cleanup of encoders, muxer, and file resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element. Not applicable for composite blocks.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite output blocks with multiple elements.
### GetElement()
Gets the underlying GStreamer element. Not applicable for composite blocks.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite output blocks with multiple elements.
### GetFilenameOrURL()
Gets the current output filename where the WMV content is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path for the WMV output.
### GetInput(MediaBlockPadMediaType)
Gets an existing input pad for the specified media type.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video or Audio) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable()
Determines whether WMV output functionality is available on the current system.
Requires the GStreamer ASF muxer and Windows Media encoders to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if WMV encoding is supported; otherwise, false.
### SetFilenameOrURL(string)
Sets a new output filename for the WMV file.
Allows changing the output destination during pipeline operation.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path for WMV output.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this output block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.Sinks
Link: api/VisioForge.Core.MediaBlocks.Sinks.html
# Namespace VisioForge.Core.MediaBlocks.Sinks
# Namespace VisioForge.Core.MediaBlocks.Sinks
### Classes
Parameters:
- (): ASF (Advanced Systems Format) sink block for writing media streams to ASF/WMV/WMA container files.
- (): AVI multimedia container output block for creating AVI video files with integrated encoding and file writing capabilities.
Provides comprehensive AVI file creation with configurable video and audio encoders, supporting H.264/AAC and H.264/MP3 combinations
for professional video production, archival storage, and multimedia content creation with industry-standard AVI container format.
Implements the true if the YouTube Live streaming block was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the YouTube Live streaming operations, including encoders, sink, and network connections.
```csharp
public void CleanUp()
```
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for the specified media type, enabling dynamic addition of video and audio streams for live streaming.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video or Audio) for the new input pad.
#### Returns
Parameters:
- (MediaBlockPad): A new MediaBlockPad configured for the specified media type.
### Dispose(bool)
Releases unmanaged and managed resources used by the YouTube Live streaming block.
Properly disposes of GStreamer elements, encoders, and network streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite streaming blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite streaming blocks with multiple internal elements.
### GetInput(MediaBlockPadMediaType)
Retrieves an existing input pad for the specified media type from the current collection.
```csharp
public MediaBlockPad GetInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media (Video or Audio) to search for.
#### Returns
Parameters:
- (MediaBlockPad): The first matching MediaBlockPad for the specified media type, or null if not found.
### IsAvailable(IH264EncoderSettings, IAACEncoderSettings)
Determines whether YouTube Live streaming functionality is available on the current system.
Requires GStreamer RTMP streaming plugins and network connectivity for YouTube platform access.
```csharp
public static bool IsAvailable(IH264EncoderSettings h264settings, IAACEncoderSettings aacSettings)
```
#### Parameters
Parameters:
- h264settings (IH264EncoderSettings): The H.264 video encoder settings to validate for availability.
- aacSettings (IAACEncoderSettings): The AAC audio encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if YouTube Live streaming is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this YouTube Live streaming block, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this YouTube Live streaming block.
## See Also
---
# Class YouTubeSinkBlock
Link: api/VisioForge.Core.MediaBlocks.Sinks.YouTubeSinkBlock.html
# Class YouTubeSinkBlock
# Class YouTubeSinkBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sinks
**Assembly**: VisioForge.Core.dll
YouTube sink block for live streaming directly to YouTube Live platform.
```csharp
public class YouTubeSinkBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockDynamicInputs
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Remarks
The YouTube sink block provides specialized streaming capabilities optimized for YouTube's live streaming service. It handles the specific requirements of YouTube Live, including proper RTMP formatting, recommended encoding settings, and stream key management. This sink simplifies the process of broadcasting to YouTube without manually configuring generic RTMP parameters.
Key Features:
Typical Use Cases:
Technical Requirements:
Setup Requirements: To use this sink, you need to enable live streaming in your YouTube account and obtain a stream key from YouTube Studio. The sink will automatically construct the proper RTMP URL using YouTube's primary ingestion endpoint.
## Constructors ### YouTubeSinkBlock(YouTubeSinkSettings) Initializes a new instance of thetrue if the sink was successfully built and configured for YouTube streaming;
false if initialization failed or the stream key is invalid.
#### Remarks
This method creates the underlying YouTube RTMP sink and configures it with
YouTube's primary ingestion server. It sets up input pads for H.264 video
and AAC audio streams according to YouTube's requirements.
### CleanUp()
Cleans up resources and disconnects from YouTube Live servers.
```csharp
public void CleanUp()
```
#### Remarks
This method properly terminates the stream to YouTube, disposes of the
underlying RTMP connection, and resets the build state. YouTube will
mark the stream as ended after disconnection.
### CreateNewInput(MediaBlockPadMediaType)
Creates a new input pad for connecting a media stream of the specified type.
```csharp
public MediaBlockPad CreateNewInput(MediaBlockPadMediaType mediaType)
```
#### Parameters
Parameters:
- mediaType (MediaBlockPadMediaType): The type of media stream to accept. YouTube Live requires:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element for advanced pipeline integration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if no matching input pad exists.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetFilenameOrURL(string)
Sets the YouTube stream key (not implemented).
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The stream key value (not used).
#### Exceptions
Parameters:
- (NotImplementedException): This method is not implemented. Configure the stream key through the
settings object passed to the constructor instead.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this media block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The true if the Allied Vision camera source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the Allied Vision camera operations, including camera connection and video buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the Allied Vision camera source.
Properly closes camera connection and disposes of GStreamer elements and camera resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The Allied Vision camera source GStreamer element.
### IsAvailable()
Determines whether Allied Vision camera support is available on the current system.
Requires Allied Vision Vimba SDK and compatible camera drivers to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Allied Vision camera support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this Allied Vision camera source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this Allied Vision camera source.
## See Also
---
# Class AnimatedGIFSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.AnimatedGIFSourceBlock.html
# Class AnimatedGIFSourceBlock
# Class AnimatedGIFSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Animated GIF source block for playing animated GIF files as video streams.
Provides seamless playback of animated GIF images with frame timing preservation for visual effects,
animated overlays, and dynamic content in video productions with automatic looping and frame interpolation support.
Implements the true if the animated GIF source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the animated GIF operations, including decoder and animation buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the animated GIF source.
Properly stops animation playback and disposes of GStreamer elements and image buffers.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The AnimatedGIFSource element providing access to GIF decoding operations.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The animated GIF source GStreamer element.
### GetPad(MediaBlockPadDirection, MediaBlockPadMediaType)
Gets a specific media block pad by direction and media type.
```csharp
public MediaBlockPad GetPad(MediaBlockPadDirection direction, MediaBlockPadMediaType type)
```
#### Parameters
Parameters:
- direction (MediaBlockPadDirection): The direction of the pad (input or output).
- type (MediaBlockPadMediaType): The media type of the pad (video, audio, or auto).
#### Returns
Parameters:
- (MediaBlockPad): The matching MediaBlockPad if found; otherwise, null.
### GetPads()
Gets all media block pads available on this animated GIF source.
```csharp
public MediaBlockPad[] GetPads()
```
#### Returns
Parameters:
- (MediaBlockPad [ ]): An array containing the single video output pad for animated GIF frames.
### IsAvailable()
Determines whether animated GIF support is available on the current system.
Requires GStreamer GIF decoder plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if animated GIF support is available; otherwise, false.
### Stop()
Stops the animated GIF playback and halts frame generation.
```csharp
public override bool Stop()
```
#### Returns
Parameters:
- (bool): true if the animation was successfully stopped; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this animated GIF source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this animated GIF source.
## See Also
---
# Class BasicFileSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.BasicFileSourceBlock.html
# Class BasicFileSourceBlock
# Class BasicFileSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Basic file source block for raw file data access without automatic parsing or decoding capabilities.
Provides direct file reading functionality for custom format handling, raw data processing, or manual stream parsing
with optional type detection for applications requiring low-level control over file data interpretation and processing.
Implements the true, adds automatic file type detection; otherwise provides raw data without format identification.
## Properties
### AddTypeFind
Gets or sets a value indicating whether to add automatic type detection for file format identification.
```csharp
public bool AddTypeFind { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Filename
Gets or sets the file path for the source file to be read as raw data.
```csharp
public string Filename { get; set; }
```
#### Property Value
Parameters:
- (string):
### Input
Gets the primary input pad (none for source blocks that read from files).
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets all input pads available on this block (none for source blocks).
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the primary output pad for the raw file data stream.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets all output pads available on this block (single output for file data).
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the media block type identifier for basic file source operations.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds and initializes the basic file source within the pipeline context.
Opens the specified file, configures reading parameters, and establishes output for downstream processing.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the basic file source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the basic file source operations, including file handles and data buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the basic file source.
Properly closes file handles and disposes of GStreamer elements and file reading resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BasicFileSource wrapper element for advanced configuration options.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The basic file source GStreamer element.
### IsAvailable()
Determines whether basic file source functionality is available on the current system.
Requires GStreamer file source plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if basic file source support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this basic file source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this basic file source.
## See Also
---
# Class BaslerSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.BaslerSourceBlock.html
# Class BaslerSourceBlock
# Class BaslerSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Basler industrial camera source block for professional video capture with Pylon SDK integration.
Provides high-performance video acquisition from Basler cameras with advanced imaging features for machine vision,
industrial automation, medical imaging, and scientific applications using GigE Vision, USB3 Vision, and Camera Link standards.
Implements the true if the Basler camera source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the Basler camera operations, including camera connection and video buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the Basler camera source.
Properly closes camera connection and disposes of GStreamer elements and camera resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The Basler camera source GStreamer element.
### IsAvailable()
Determines whether Basler camera support is available on the current system.
Requires Basler Pylon SDK and compatible camera drivers to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Basler camera support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this Basler camera source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this Basler camera source.
## See Also
---
# Class CDGSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.CDGSourceBlock.html
# Class CDGSourceBlock
# Class CDGSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
CDG (Compact Disc plus Graphics) karaoke source block for synchronized audio and graphics playback with integrated decoders.
Provides karaoke and multimedia presentation functionality by combining CDG graphics files with audio tracks for synchronized
visual displays, subtitle rendering, and interactive entertainment applications with professional karaoke system integration.
Implements the true if the CDG source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the CDG karaoke operations, including file handles and media buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the CDG karaoke source.
Properly closes file handles, disposes of GStreamer elements, and cleans up temporary ZIP extraction files.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The CDG source GStreamer element.
### IsAvailable()
Determines whether CDG karaoke source functionality is available on the current system.
Requires GStreamer CDG decoder and audio decoder plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if CDG source support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this CDG source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this CDG karaoke source.
## See Also
---
# Class DemuxerSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.DemuxerSourceBlock.html
# Class DemuxerSourceBlock
# Class DemuxerSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Demuxer source block for container format parsing without automatic decoding capabilities.
Provides raw stream extraction from multimedia containers (MP4, AVI, MKV, WebM) with separate video, audio, and subtitle outputs
for advanced processing pipelines requiring manual decoder selection and stream manipulation in professional media workflows.
Implements the true if the demuxer source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the demuxer operations, including container file handles and stream buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the demuxer source.
Properly closes container file and disposes of GStreamer elements and stream processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The demuxer source GStreamer element.
### IsAvailable(DemuxerSourceSettings)
Determines whether demuxer functionality is available for the specified container format.
Requires GStreamer demuxer plugins for the target container format to be installed and functional.
```csharp
public static bool IsAvailable(DemuxerSourceSettings settings)
```
#### Parameters
Parameters:
- settings (DemuxerSourceSettings): The demuxer settings containing the container file to be analyzed for format compatibility.
#### Returns
Parameters:
- (bool): true if demuxer support is available for the specified format; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this demuxer source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this demuxer source.
## See Also
---
# Class DVBSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.DVBSourceBlock.html
# Class DVBSourceBlock
# Class DVBSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
DVB (Digital Video Broadcasting) source block for professional television and satellite signal reception.
Provides digital television tuning and streaming capabilities for DVB-T, DVB-C, DVB-S, and DVB-S2 standards
with advanced signal processing for broadcast television, surveillance, and professional streaming applications.
Implements the true if the DVB source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the DVB operations, including tuner connection and signal buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the DVB source.
Properly closes tuner connection and disposes of GStreamer elements and signal processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The DVB source GStreamer element.
### IsAvailable()
Determines whether DVB digital television support is available on the current system.
Requires compatible DVB hardware and drivers to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if DVB support is available; otherwise, false.
### Tune()
Initiates the DVB tuning process to lock onto the specified frequency and acquire digital television signal.
```csharp
public void Tune()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this DVB source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this DVB source.
### TuningDone
Occurs when DVB tuning operation completes successfully and signal is locked.
```csharp
public event DVBTuningDoneHandler TuningDone
```
#### Event Type
Parameters:
- (DVBTuningDoneHandler):
### TuningFail
Occurs when DVB tuning operation fails due to signal loss or hardware issues.
```csharp
public event DVBTuningDoneHandler TuningFail
```
#### Event Type
Parameters:
- (DVBTuningDoneHandler):
### TuningStart
Occurs when DVB tuning operation starts for frequency scanning and signal acquisition.
```csharp
public event DVBTuningDoneHandler TuningStart
```
#### Event Type
Parameters:
- (DVBTuningDoneHandler):
## See Also
---
# Class FallbackSwitchSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.FallbackSwitchSourceBlock.html
# Class FallbackSwitchSourceBlock
# Class FallbackSwitchSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Fallback switch source block that wraps any live source with automatic failover capability.
Uses GStreamer's fallbacksrc element to provide seamless switching between main source and
fallback content (static text, image, or media block) when the primary source fails.
Implements the true if the GenICam source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the GenICam operations, including camera handles and image buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the GenICam source.
Properly closes camera connection and disposes of GStreamer elements and acquisition resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GenICam source GStreamer element.
### IsAvailable()
Determines whether GenICam support is available on the current system.
Requires GenICam-compatible camera drivers and GStreamer GenICam plugins to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if GenICam support is available; otherwise, false.
### Stop()
Stops the GenICam camera acquisition and releases camera resources.
```csharp
public override bool Stop()
```
#### Returns
Parameters:
- (bool): true if the camera was successfully stopped; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this GenICam source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this GenICam source.
## See Also
---
# Class HTTPMJPEGSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.HTTPMJPEGSourceBlock.html
# Class HTTPMJPEGSourceBlock
# Class HTTPMJPEGSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
HTTP/HTTPS MJPEG (Motion JPEG) source block for IP camera streaming and web-based video capture.
Provides real-time MJPEG stream reception from web cameras, IP surveillance systems, and HTTP video sources
with integrated JPEG decoding and frame rate control for security monitoring and live video streaming applications.
Implements the true if the HTTP MJPEG source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the HTTP MJPEG operations, including network connection and video buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the HTTP MJPEG source.
Properly closes network connection and disposes of GStreamer elements and video processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The HTTP source GStreamer element.
### IsAvailable()
Determines whether HTTP MJPEG support is available on the current system.
Requires GStreamer HTTP source and JPEG decoder plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if HTTP MJPEG support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this HTTP MJPEG source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this HTTP MJPEG source.
## See Also
---
# Class HTTPSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.HTTPSourceBlock.html
# Class HTTPSourceBlock
# Class HTTPSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
HTTP/HTTPS source block for web-based content streaming and network media access.
Provides versatile HTTP stream reception from web servers, CDNs, and online media sources with authentication support
for live streaming, progressive download, and web-based multimedia content delivery in modern streaming applications.
Implements the true if the HTTP source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the HTTP operations, including network connection and stream buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the HTTP source.
Properly closes network connection and disposes of GStreamer elements and stream processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The HTTP source GStreamer element.
### IsAvailable()
Determines whether HTTP source support is available on the current system.
Requires GStreamer HTTP source plugins and network connectivity to be available and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if HTTP source support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this HTTP source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this HTTP source.
## See Also
---
# Class ImageSequenceSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.ImageSequenceSourceBlock.html
# Class ImageSequenceSourceBlock
# Class ImageSequenceSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Image sequence source block for generating video streams from image sequences in a folder.
Provides image sequence playback functionality using GStreamer's imagesequencesrc element,
supporting various image formats with configurable frame rates and looping options for slideshow creation,
timelapse playback, and video sequence processing in video productions.
Implements the true if the image sequence source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the image sequence operations, including element disposal and buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the image sequence source.
Properly closes image resources and disposes of GStreamer elements and video generation components.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The ImageSequenceSource wrapper element for advanced configuration options.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The image sequence source GStreamer element.
### IsAvailable(ImageSequenceSourceSettings)
Determines whether image sequence support is available for the specified settings.
Checks for required imagesequencesrc element and format support based on the image types.
```csharp
public static bool IsAvailable(ImageSequenceSourceSettings settings)
```
#### Parameters
Parameters:
- settings (ImageSequenceSourceSettings): The image sequence settings to check for compatibility and element availability.
#### Returns
Parameters:
- (bool): true if image sequence support is available for the specified settings; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this image sequence source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this image sequence source.
## See Also
---
# Class ImageVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.ImageVideoSourceBlock.html
# Class ImageVideoSourceBlock
# Class ImageVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Image video source block for generating video streams from still images or animated GIFs.
Provides flexible image-to-video conversion with support for static images as video backgrounds, slideshow creation,
and animated GIF playback for titles, logos, overlays, and placeholder content in video productions.
Implements the true if the image video source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the image video operations, including image decoders and video buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the image video source.
Properly closes image resources and disposes of GStreamer elements and video generation components.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The active source element (either normal or animated GIF source).
### IsAvailable(ImageVideoSourceSettings)
Determines whether image video support is available for the specified settings.
Checks for required image decoders and format support based on the image type.
```csharp
public static bool IsAvailable(ImageVideoSourceSettings settings)
```
#### Parameters
Parameters:
- settings (ImageVideoSourceSettings): The image settings to check for compatibility and codec availability.
#### Returns
Parameters:
- (bool): true if image video support is available for the specified format; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this image video source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this image video source.
## See Also
---
# Class ImageVideoSourceCairoBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.ImageVideoSourceCairoBlock.html
# Class ImageVideoSourceCairoBlock
# Class ImageVideoSourceCairoBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Image video source block with Cairo-based rendering for dynamic updates.
Implements the true render video.
- renderAudio (bool): if set to true render audio.
- renderSubtitle (bool): if set to true render subtitle.
- renderMetadata (bool): if set to true render metadata.
### MPEGTSDemuxBlock(MediaFileInfo, bool, bool, bool, bool)
Initializes a new instance of the true render video.
- renderAudio (bool): if set to true render audio.
- renderSubtitle (bool): if set to true render subtitle.
- renderMetadata (bool): if set to true render metadata.
## Properties
### AudioOutput
Gets the first audio output for backward compatibility.
```csharp
public MediaBlockPad AudioOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### AudioOutputs
Gets the audio outputs for multiple streams.
```csharp
public Listtrue if successfull, false otherwise.
### CleanUp()
Cleans up.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class NDISourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.NDISourceBlock.html
# Class NDISourceBlock
# Class NDISourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
NDI (Network Device Interface) source block for professional IP-based video streaming.
Provides low-latency, high-quality video and audio streaming over IP networks for broadcast production,
live events, and multi-camera setups with automatic source discovery and synchronization capabilities.
Implements the true if the NDI source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the NDI operations, including network connections and stream buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the NDI source.
Properly closes network connections and disposes of GStreamer elements and streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The NDI source GStreamer element.
### IsAvailable()
Determines whether NDI support is available on the current system.
Requires NDI runtime and GStreamer NDI plugins to be installed and licensed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NDI support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this NDI source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this NDI source.
## See Also
---
# Class PlayBinSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.PlayBinSourceBlock.html
# Class PlayBinSourceBlock
# Class PlayBinSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
PlayBin source block for universal media playback with automatic format detection and decoding.
Provides comprehensive media source support using GStreamer's PlayBin element for files, network streams, and URIs
with automatic codec selection, stream demuxing, and synchronized audio/video/subtitle playback for media player applications.
Implements the true if the PlayBin source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the PlayBin operations, including media handles and decoder buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the PlayBin source.
Properly closes media source and disposes of GStreamer elements and decoding resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for PlayBin blocks as they use native GStreamer elements directly.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The PlayBin GStreamer element.
### IsAvailable()
Determines whether PlayBin support is available on the current system.
PlayBin is a core GStreamer element and should always be available with proper GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if PlayBin support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this PlayBin source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this PlayBin source.
## See Also
---
# Class PulseAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.PulseAudioSourceBlock.html
# Class PulseAudioSourceBlock
# Class PulseAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
PulseAudio source block for audio capture using the pulsesrc GStreamer element.
Provides audio capture from PulseAudio sound server on Linux systems for recording,
streaming, and real-time audio processing applications.
Implements the true if the PulseAudio source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the audio capture operations, including device handles and audio buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the PulseAudio source.
Properly closes audio device handles and disposes of GStreamer elements and capture resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The PulseAudio source GStreamer element.
### GetMute()
Gets the current mute state of the audio capture device.
```csharp
public bool GetMute()
```
#### Returns
Parameters:
- (bool): true if the audio capture is muted; false if unmuted.
### GetVolume()
Gets the current capture volume level of the audio device.
```csharp
public double GetVolume()
```
#### Returns
Parameters:
- (double): The volume level as a double in the range 0.0 (silence) to 1.0 (maximum volume).
### IsAvailable()
Determines whether PulseAudio capture support is available on the current system.
Requires PulseAudio GStreamer plugin to be available and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if PulseAudio capture support is available; otherwise, false.
### IsSupported()
Determines whether volume and mute control is supported by the current audio capture device.
```csharp
public bool IsSupported()
```
#### Returns
Parameters:
- (bool): true if volume/mute control is supported; otherwise, false.
### SetInterface(IAudioVolumeMute)
Sets the audio volume/mute interface for internal use by the framework.
```csharp
public void SetInterface(IAudioVolumeMute intf)
```
#### Parameters
Parameters:
- intf (IAudioVolumeMute): The IAudioVolumeMute interface implementation.
### SetMute(bool)
Sets the mute state of the audio capture device.
```csharp
public void SetMute(bool mute)
```
#### Parameters
Parameters:
- mute (bool): If set to true, mutes the audio capture; otherwise, unmutes it.
### SetVolume(double)
Sets the capture volume level for the audio device.
```csharp
public void SetVolume(double volume)
```
#### Parameters
Parameters:
- volume (double): The volume level in the range 0.0 (silence) to 1.0 (maximum volume).
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this PulseAudio source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this PulseAudio source.
## See Also
---
# Class PushAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.PushAudioSourceBlock.html
# Class PushAudioSourceBlock
# Class PushAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Push audio source block for programmatic audio data injection into the pipeline.
Provides real-time audio streaming from application-generated or externally-sourced audio data for custom audio sources,
audio synthesis, live audio processing, and integration with external audio APIs or hardware devices.
Implements the true if the push audio source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the push audio operations, including injection buffers and audio converters.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the push audio source.
Properly stops audio injection and disposes of GStreamer elements and audio buffers.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The push audio source GStreamer element.
### IsAvailable()
Determines whether push audio support is available on the current system.
Requires GStreamer appsrc plugin to be installed for audio data injection.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if push audio support is available; otherwise, false.
### PushData(AudioFrame)
Pushes an audio frame into the pipeline for real-time processing.
```csharp
public void PushData(AudioFrame frame)
```
#### Parameters
Parameters:
- frame (AudioFrame): The AudioFrame containing audio samples with format information to inject into the pipeline.
### PushData(byte[], int)
Pushes raw audio data bytes into the pipeline for real-time processing.
```csharp
public void PushData(byte[] data, int dataSize)
```
#### Parameters
Parameters:
- data (byte [ ]): The byte array containing raw audio samples in the configured format.
- dataSize (int): The actual size of valid audio data in bytes within the array.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this push audio source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this push audio source.
## See Also
---
# Class PushSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.PushSourceBlock.html
# Class PushSourceBlock
# Class PushSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Push source block for generic programmatic data injection into the pipeline.
Provides flexible real-time streaming from application-generated data including video frames, audio samples, or raw data
for custom media sources, live processing pipelines, and integration with external data sources or hardware devices.
Implements the true if successfull, false otherwise.
### CleanUp()
Cleans up.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The push source GStreamer element.
### IsAvailable()
Determines whether push source support is available on the current system.
Requires GStreamer appsrc plugin to be installed for data injection.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if push source support is available; otherwise, false.
### PushData(byte[], int, TimeSpan?, TimeSpan?)
Pushes the data.
```csharp
public void PushData(byte[] data, int dataSize, TimeSpan? pts = null, TimeSpan? duration = null)
```
#### Parameters
Parameters:
- data (byte [ ]): The data.
- dataSize (int): Size of the data.
- pts (TimeSpan ?): The PTS.
- duration (TimeSpan ?): The duration.
### PushFrame(AudioFrame)
Pushes the frame.
```csharp
public void PushFrame(AudioFrame frame)
```
#### Parameters
Parameters:
- frame (AudioFrame): The frame.
### PushFrame(VideoFrameX)
Pushes the frame.
```csharp
public void PushFrame(VideoFrameX frame)
```
#### Parameters
Parameters:
- frame (VideoFrameX): The frame.
### SendEOS()
Sends the End-of-Stream.
```csharp
public bool SendEOS()
```
#### Returns
Parameters:
- (bool): true if successful, false otherwise.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class PushVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.PushVideoSourceBlock.html
# Class PushVideoSourceBlock
# Class PushVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Push video source block for programmatic video frame injection into the pipeline.
Provides real-time video streaming from application-generated or externally-sourced video frames for custom video sources,
frame processing pipelines, video synthesis, and integration with external video APIs or capture devices.
Implements the true if the push video source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the push video operations, including frame buffers and video converters.
```csharp
public void CleanUp()
```
### ClearQueue()
Clears all pending video frames from the internal buffer queue.
```csharp
public void ClearQueue()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the push video source.
Properly stops frame injection and disposes of GStreamer elements and video buffers.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The push video source GStreamer element.
### IsAvailable()
Determines whether push video support is available on the current system.
Requires GStreamer appsrc plugin to be installed for video frame injection.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if push video support is available; otherwise, false.
### PushFrame(VideoFrameX)
Pushes a video frame into the pipeline for real-time processing.
```csharp
public void PushFrame(VideoFrameX frame)
```
#### Parameters
Parameters:
- frame (VideoFrameX): The VideoFrameX containing pixel data with format and timing information to inject into the pipeline.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this push video source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this push video source.
## See Also
---
# Class QTDemuxBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.QTDemuxBlock.html
# Class QTDemuxBlock
# Class QTDemuxBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
QuickTime/MP4/MOV demultiplexer block for extracting individual streams from container files.
This block parses QuickTime-based container formats (MP4, MOV, M4A, 3GP) and separates
them into individual video, audio, subtitle, and metadata streams. Supports advanced
features including fragmented MP4, multiple tracks, chapter information, and embedded
metadata. Essential for playback applications, transcoding workflows, stream analysis,
and any scenario requiring access to individual streams within QuickTime containers.
Implements the true extract and output video streams.
- renderAudio (bool): if set to true extract and output audio streams.
- renderSubtitle (bool): if set to true extract and output subtitle streams.
- renderMetadata (bool): if set to true extract and output metadata streams.
## Properties
### AudioOutput
Gets the audio output pad for extracted audio streams.
Only available when audio rendering is enabled.
```csharp
public MediaBlockPad AudioOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### MetadataOutput
Gets the metadata output pad for extracted metadata streams.
Only available when metadata rendering is enabled.
```csharp
public MediaBlockPad MetadataOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### SubtitleOutput
Gets the subtitle output pad for extracted subtitle streams.
Only available when subtitle rendering is enabled.
```csharp
public MediaBlockPad SubtitleOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
### VideoOutput
Gets the video output pad for extracted video streams.
Only available when video rendering is enabled.
```csharp
public MediaBlockPad VideoOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
## Methods
### Build()
Constructs and initializes the QuickTime demux and associated queue elements.
This method creates the demux element, sets up dynamic pad handlers for each stream type,
creates queue elements for enabled streams, and establishes output pad connections.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the demux was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this QuickTime demux block.
This method disposes of the demux element and all queue elements, then resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper. Returns null as the demux element
is accessed directly without a wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this implementation.
### GetElement()
Gets the underlying GStreamer element that performs the QuickTime demuxing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the QT demux.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this QuickTime demux block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class RTMPSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.RTMPSourceBlock.html
# Class RTMPSourceBlock
# Class RTMPSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
RTMP (Real Time Messaging Protocol) source block for streaming from RTMP servers.
Outputs demuxed compressed video and audio streams without decoding, suitable for direct recording,
transcoding, or connection to separate decoder blocks. Provides efficient streaming from media servers,
CDNs, and live streaming platforms.
Implements the true if the RTMP source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the RTMP operations, including network connections and decoder resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the RTMP source.
Properly closes network connections and disposes of GStreamer elements and streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The RTMP source GStreamer element.
### GetVideoStreamInfo()
Gets the detailed video stream information extracted from the RTMP source.
```csharp
public VideoStreamInfo GetVideoStreamInfo()
```
#### Returns
Parameters:
- (VideoStreamInfo): A VideoStreamInfo object containing codec, resolution, frame rate, and format details of the video stream.
### IsAvailable()
Determines whether RTMP support is available on the current system.
Requires GStreamer RTMP plugins and codec libraries to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if RTMP support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this RTMP source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this RTMP source.
## See Also
---
# Class RTSPRAWSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.RTSPRAWSourceBlock.html
# Class RTSPRAWSourceBlock
# Class RTSPRAWSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
RTSP RAW source block for real-time streaming protocol reception without automatic decoding capabilities.
Provides raw RTSP stream access from IP cameras, surveillance systems, and streaming servers with manual decoder control
for advanced processing pipelines requiring custom codec handling in security, broadcasting, and professional video applications.
This implementation ensures H264 streams start from keyframes and synchronizes audio playback accordingly.
Implements the true if the RTSP RAW source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the RTSP RAW operations, including network connection and stream buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the RTSP RAW source.
Properly closes RTSP connection and disposes of GStreamer elements and streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The RTSPRAWSource wrapper element for advanced RTSP configuration options.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The RTSP RAW source GStreamer element.
### IsAvailable()
Determines whether RTSP RAW support is available on the current system.
Requires GStreamer RTSP source plugins and network connectivity to be available and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if RTSP RAW support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this RTSP RAW source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this RTSP RAW source.
## See Also
---
# Class RTSPSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.RTSPSourceBlock.html
# Class RTSPSourceBlock
# Class RTSPSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
RTSP (Real Time Streaming Protocol) source block with integrated decoders for IP camera and streaming server access.
Provides low-latency video and audio streaming from network cameras, surveillance systems, and media servers with automatic
codec detection, RTP/RTCP transport, and synchronized playback for security, broadcast, and live streaming applications.
Supports configurable low latency mode for real-time applications by minimizing buffering and dropping late frames.
Implements the true if the RTSP source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the RTSP operations, including network connections and decoder resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the RTSP source.
Properly closes network connections and disposes of GStreamer elements and streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The RTSP source GStreamer element.
### GetVideoStreamInfo()
Gets the detailed video stream information extracted from the RTSP source.
```csharp
public VideoStreamInfo GetVideoStreamInfo()
```
#### Returns
Parameters:
- (VideoStreamInfo): A VideoStreamInfo object containing codec, resolution, frame rate, and format details of the video stream.
### IsAvailable()
Determines whether RTSP support is available on the current system.
Requires GStreamer RTSP plugins and codec libraries to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if RTSP support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this RTSP source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this RTSP source.
### OnAudioRAWFrame
Event raised when raw compressed audio frames are received from the RTSP stream before decoding.
Requires RTSPSourceSettings.EnableRAWVideoAudioEvents to be set to true for activation.
```csharp
public event EventHandlertrue if successfull, false otherwise.
### CleanUp()
Cleans up.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The screen capture source GStreamer element.
### IsAvailable(ScreenCaptureSourceType)
Determines whether screen capture support is available for the specified source type on the current system.
Requires platform-specific screen capture APIs and drivers to be available and functional.
```csharp
public static bool IsAvailable(ScreenCaptureSourceType sourceType)
```
#### Parameters
Parameters:
- sourceType (ScreenCaptureSourceType): The type of screen capture source to check (D3D11, XDisplay, macOS, etc.).
#### Returns
Parameters:
- (bool): true if screen capture support is available for the specified type; otherwise, false.
### UpdateLiveSettings(int, int, bool)
Updates the live settings.
```csharp
public void UpdateLiveSettings(int x, int y, bool cursor)
```
#### Parameters
Parameters:
- x (int): The x.
- y (int): The y.
- cursor (bool): if set to true capture cursor.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class SourceMediaBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.SourceMediaBlock.html
# Class SourceMediaBlock
# Class SourceMediaBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Abstract base class for all media source blocks in the MediaBlocks pipeline framework.
This foundational class provides the essential infrastructure for blocks that originate media data
from various sources including file systems, capture devices, network streams, and synthetic generators.
Source blocks represent the entry points of media processing pipelines, responsible for acquiring
raw or encoded media data and making it available to downstream processing blocks.
Key responsibilities:
- Defining the common interface for all media source implementations
- Providing base functionality for source lifecycle management
- Establishing contracts for subtitle availability and source control
- Serving as the starting point for media processing chains
Common derived implementations:
- File sources (MP4, AVI, MKV, WebM, etc.)
- Device sources (cameras, microphones, capture cards)
- Network sources (RTSP, RTMP, HTTP streams)
- Synthetic sources (test patterns, tone generators)
- Screen capture sources (desktop, window, region)
- Industrial camera sources (GenICam, machine vision)
Source blocks typically have no input pads and one or more output pads
depending on the media streams they provide (video, audio, subtitles).
They are responsible for format detection, stream initialization, and
maintaining synchronization between multiple output streams.
Implements the true if one or more subtitle streams are available and can be extracted; false if no subtitles are present or the source doesn't support subtitle extraction.
#### Remarks
Override this method in derived classes that implement subtitle extraction capabilities.
The base implementation returns false, indicating no subtitle support by default.
Sources that support subtitles should also implement the corresponding subtitle output pad.
### Stop()
Stops the media source from generating or reading data and releases associated resources.
This method provides a controlled shutdown mechanism for source blocks, ensuring proper
cleanup of system resources, device handles, network connections, and file descriptors.
```csharp
public virtual bool Stop()
```
#### Returns
Parameters:
- (bool): true if the source was successfully stopped and all resources were released; false if an error occurred during shutdown.
#### Remarks
Override this method in derived classes to implement source-specific stopping logic:
- File sources: Close file handles and release memory buffers
- Device sources: Stop hardware devices and release exclusive access
- Network sources: Close connections and cleanup network resources
- Thread sources: Signal and wait for worker threads to terminate
The base implementation returns true, allowing simple sources to use default behavior.
Complex sources should ensure all resources are properly released to prevent leaks.
This method may be called multiple times and should be idempotent.
## See Also
---
# Class SRTRAWSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.SRTRAWSourceBlock.html
# Class SRTRAWSourceBlock
# Class SRTRAWSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
SRT (Secure Reliable Transport) RAW source block for low-latency streaming reception without automatic decoding.
Provides reliable UDP-based stream transport with error recovery and encryption for live broadcasting, remote production,
and professional streaming applications requiring low-latency, high-quality video transmission over unreliable networks.
Implements the true if the SRT RAW source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the SRT operations, including secure connection and stream buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the SRT RAW source.
Properly closes SRT connection and disposes of GStreamer elements and streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The SRT source GStreamer element.
### IsAvailable()
Determines whether SRT support is available on the current system.
Requires GStreamer SRT source plugins and SRT libraries to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if SRT support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this SRT RAW source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this SRT RAW source.
## See Also
---
# Class SRTSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.SRTSourceBlock.html
# Class SRTSourceBlock
# Class SRTSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
SRT (Secure Reliable Transport) source block with integrated decoding capabilities for complete media playback.
Provides secure, low-latency streaming reception with automatic video, audio, and subtitle decoding for live broadcasting,
remote production, and professional streaming applications requiring high-quality, reliable transmission over unreliable networks.
Implements the true, enables video stream decoding and output.
- renderAudio (bool): If set to true, enables audio stream decoding and output.
- renderSubtitle (bool): If set to true, enables subtitle stream decoding and output.
## Properties
### AudioOutput
Gets the audio output pad that provides decoded SRT audio stream to downstream blocks.
```csharp
public MediaBlockPad AudioOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### DisableAudioConverter
Gets or sets a value indicating whether to disable audio converter for direct audio output.
```csharp
public bool DisableAudioConverter { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Input
Gets the primary input pad (none for source blocks that receive network streams).
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets all input pads available on this block (none for source blocks).
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the primary output pad (video output for SRT stream).
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets all output pads available on this block (dynamic based on enabled streams).
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the SRT configuration settings that control network parameters and decoding options.
```csharp
public SRTSourceSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (SRTSourceSettings):
### SubtitleOutput
Gets the subtitle output pad that provides decoded SRT subtitle stream to downstream blocks.
```csharp
public MediaBlockPad SubtitleOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Type
Gets the media block type identifier for SRT source operations with decoding.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
### VideoOutput
Gets the video output pad that provides decoded SRT video stream to downstream blocks.
```csharp
public MediaBlockPad VideoOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
## Methods
### Build()
Builds and initializes the SRT source with decoding within the pipeline context.
Establishes secure SRT connection, configures automatic decoding, and prepares decoded outputs for downstream processing.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the SRT source with decoding was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the SRT operations, including secure connection, decoders, and media buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the SRT source with decoding.
Properly closes SRT connection and disposes of GStreamer elements, decoders, and streaming resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The DecodeBinElement wrapper element for advanced decoding configuration options.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The decode bin GStreamer element.
### IsAvailable()
Determines whether SRT support with decoding is available on the current system.
Requires GStreamer SRT source plugins, decode bin, and SRT libraries to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if SRT support with decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this SRT source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this SRT source.
## See Also
---
# Class StreamSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.StreamSourceBlock.html
# Class StreamSourceBlock
# Class StreamSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Stream source block for reading media data from .NET Stream objects.
Provides flexible media playback from memory streams, file streams, or network streams without integrated decoders,
enabling custom data sources, in-memory media processing, and streaming from non-standard sources for advanced pipeline scenarios.
Implements the true if the stream source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the stream source operations, including the stream and data buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the stream source.
Properly closes the stream (if owned) and disposes of GStreamer elements and buffering resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The stream source GStreamer element.
### IsAvailable()
Determines whether stream source support is available on the current system.
Requires GStreamer appsrc plugin to be installed for stream data injection.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if stream source support is available; otherwise, false.
### SendEOS()
Sends an End-of-Stream (EOS) signal to indicate that all data has been read from the stream.
```csharp
public bool SendEOS()
```
#### Returns
Parameters:
- (bool): true if the EOS signal was successfully sent; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this stream source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this stream source.
## See Also
---
# Class StreamSourceBlockWithDecoder
Link: api/VisioForge.Core.MediaBlocks.Sources.StreamSourceBlockWithDecoder.html
# Class StreamSourceBlockWithDecoder
# Class StreamSourceBlockWithDecoder
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Composite media source block that combines stream reading with automatic decoding for complete media playback.
This high-level block encapsulates the complexity of reading from .NET Stream objects, automatically detecting
media formats, demuxing container formats, and decoding compressed streams into raw video and audio data.
Provides a simplified API for applications that need to play media from memory without manual pipeline construction.
Key features:
- Automatic format detection for all supported container formats
- Integrated demuxing of multi-stream containers (MP4, MKV, AVI, etc.)
- Hardware-accelerated decoding when available
- Support for any .NET Stream implementation (MemoryStream, FileStream, NetworkStream)
- Seamless handling of variable bitrate and adaptive streams
- Automatic audio/video synchronization
- Zero-copy streaming from memory buffers when possible
Common use cases:
- Playing media from memory buffers or byte arrays
- Streaming from encrypted or compressed archives
- Processing media from network streams without temporary files
- Embedding media playback in memory-constrained environments
- Custom stream implementations for DRM or proprietary formats
The block internally manages a StreamSourceBlock for reading and a DecodeBinBlock
for automatic format detection and decoding, presenting a simple interface with
separate video and audio outputs ready for rendering or further processing.
Implements the true if the subtitle source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the subtitle operations, including file handles and text buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the subtitle source.
Properly closes subtitle file and disposes of GStreamer elements and text processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The subtitle source GStreamer element.
### IsAvailable(SubtitleSourceSettings)
Determines whether subtitle support is available for the specified subtitle format.
Requires GStreamer subtitle parsing plugins for the target subtitle format to be installed and functional.
```csharp
public static bool IsAvailable(SubtitleSourceSettings settings)
```
#### Parameters
Parameters:
- settings (SubtitleSourceSettings): The subtitle settings containing the subtitle file to be analyzed for format compatibility.
#### Returns
Parameters:
- (bool): true if subtitle support is available for the specified format; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this subtitle source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this subtitle source.
## See Also
---
# Class SystemAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.SystemAudioSourceBlock.html
# Class SystemAudioSourceBlock
# Class SystemAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
System audio source block for native audio capture device access across platforms.
Provides unified audio recording from microphones, line-in devices, and system audio using platform-specific APIs
(WASAPI, CoreAudio, ALSA, PulseAudio) for voice recording, audio streaming, and real-time audio processing applications.
Implements the true if the system audio source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the audio capture operations, including device handles and audio buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the system audio source.
Properly closes audio device handles and disposes of GStreamer elements and capture resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetDevicesAsync(AudioCaptureDeviceAPI?)
Gets the list of available audio capture devices asynchronously.
Enumerates all connected microphones, line-in devices, and system audio sources on the current system.
```csharp
public static Tasktrue if the audio capture is muted; false if unmuted.
### GetVolume()
Gets the current capture volume level of the audio device.
```csharp
public double GetVolume()
```
#### Returns
Parameters:
- (double): The volume level as a double in the range 0.0 (silence) to 1.0 (maximum volume).
### IsAvailable(AudioCaptureDeviceAPI)
Determines whether audio capture support is available for the specified API on the current system.
Requires platform-specific audio capture APIs and drivers to be available and functional.
```csharp
public static bool IsAvailable(AudioCaptureDeviceAPI api)
```
#### Parameters
Parameters:
- api (AudioCaptureDeviceAPI): The audio capture API to check (WASAPI, CoreAudio, ALSA, PulseAudio, etc.).
#### Returns
Parameters:
- (bool): true if audio capture support is available for the specified API; otherwise, false.
### IsSupported()
Determines whether volume and mute control is supported by the current audio capture device.
```csharp
public bool IsSupported()
```
#### Returns
Parameters:
- (bool): true if volume/mute control is supported; otherwise, false.
### SetInterface(IAudioVolumeMute)
Sets the audio volume/mute interface for internal use by the framework.
```csharp
public void SetInterface(IAudioVolumeMute intf)
```
#### Parameters
Parameters:
- intf (IAudioVolumeMute): The IAudioVolumeMute interface implementation.
### SetMute(bool)
Sets the mute state of the audio capture device.
```csharp
public void SetMute(bool mute)
```
#### Parameters
Parameters:
- mute (bool): If set to true, mutes the audio capture; otherwise, unmutes it.
### SetVolume(double)
Sets the capture volume level for the audio device.
```csharp
public void SetVolume(double volume)
```
#### Parameters
Parameters:
- volume (double): The volume level in the range 0.0 (silence) to 1.0 (maximum volume).
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this system audio source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this system audio source.
## See Also
---
# Class SystemVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.SystemVideoSourceBlock.html
# Class SystemVideoSourceBlock
# Class SystemVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
System video source block for native camera and video capture device access across platforms.
Provides unified video capture from webcams, built-in cameras, and professional capture devices using platform-specific APIs
(DirectShow, Media Foundation, V4L2, AVFoundation) for live streaming, video recording, and real-time video processing applications.
Implements the true if the system video source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the video capture operations, including device handles and capture buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the system video source.
Properly closes video device handles and disposes of GStreamer elements and capture resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetDevicesAsync()
Gets the list of available video capture devices asynchronously.
Enumerates all connected cameras, webcams, and capture devices on the current system with their capabilities.
```csharp
public static Tasktrue if video capture support is available for the specified API; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this system video source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this system video source.
## See Also
---
# Class TextOverlaySourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.TextOverlaySourceBlock.html
# Class TextOverlaySourceBlock
# Class TextOverlaySourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Text overlay source block that generates video with text overlay for fallback scenarios.
Implements the true extract and output video streams.
- renderAudio (bool): if set to true extract and output audio streams.
- renderSubtitle (bool): if set to true extract and output subtitle streams.
- renderMetadata (bool): if set to true extract and output metadata streams.
### UniversalDemuxBlock(MediaFileInfo, bool, bool, bool, bool)
Initializes a new instance of the true extract and output video streams.
- renderAudio (bool): if set to true extract and output audio streams.
- renderSubtitle (bool): if set to true extract and output subtitle streams.
- renderMetadata (bool): if set to true extract and output metadata streams.
## Properties
### AudioOutputs
Gets all audio output pads for extracted audio streams.
The number of pads matches the number of audio streams in the container.
```csharp
public MediaBlockPad[] AudioOutputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### MetadataOutputs
Gets all metadata output pads for extracted metadata streams.
```csharp
public MediaBlockPad[] MetadataOutputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### SubtitleOutputs
Gets all subtitle output pads for extracted subtitle streams.
The number of pads matches the number of subtitle streams in the container.
```csharp
public MediaBlockPad[] SubtitleOutputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
### VideoOutputs
Gets all video output pads for extracted video streams.
The number of pads matches the number of video streams in the container.
```csharp
public MediaBlockPad[] VideoOutputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
## Methods
### Build()
Constructs and initializes the universal demux and all associated queue elements.
This method creates the demux element, sets up dynamic pad handlers for each stream type,
creates queue or null sink elements based on rendering options, and establishes output connections.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the demux was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this universal demux block.
This method disposes of the demux element, all queue elements, null renderers,
and clears all collections before resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetAudioOutput()
Gets the first audio output pad if available.
Convenience method for accessing the primary audio stream.
```csharp
public MediaBlockPad GetAudioOutput()
```
#### Returns
Parameters:
- (MediaBlockPad): The first audio output pad or null if no audio streams.
### GetCore()
Gets the core BaseElement wrapper. Returns null as the demux element
is accessed directly without a wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this implementation.
### GetElement()
Gets the underlying GStreamer element that performs the universal demuxing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the universal demux.
### GetMetadataOutput()
Gets the first metadata output pad if available.
Convenience method for accessing the primary metadata stream.
```csharp
public MediaBlockPad GetMetadataOutput()
```
#### Returns
Parameters:
- (MediaBlockPad): The first metadata output pad or null if no metadata streams.
### GetSubtitleOutput()
Gets the first subtitle output pad if available.
Convenience method for accessing the primary subtitle stream.
```csharp
public MediaBlockPad GetSubtitleOutput()
```
#### Returns
Parameters:
- (MediaBlockPad): The first subtitle output pad or null if no subtitle streams.
### GetVideoOutput()
Gets the first video output pad if available.
Convenience method for accessing the primary video stream.
```csharp
public MediaBlockPad GetVideoOutput()
```
#### Returns
Parameters:
- (MediaBlockPad): The first video output pad or null if no video streams.
### IsAvailable(IUniversalDemuxSettings)
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
Checks for required demuxer plugins based on the specified settings.
```csharp
public static bool IsAvailable(IUniversalDemuxSettings settings)
```
#### Parameters
Parameters:
- settings (IUniversalDemuxSettings): The demuxer settings to check availability for.
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this universal demux block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class UniversalSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.UniversalSourceBlock.html
# Class UniversalSourceBlock
# Class UniversalSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Universal source block with integrated decoders for comprehensive media file and stream playback.
Provides automatic format detection, demuxing, and decoding for virtually any media format including local files,
network streams, and URIs with support for video, audio, and subtitle tracks for complete media player functionality.
Implements the true if the universal source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the universal source operations, including decoders and stream buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the universal source.
Properly closes media files/streams and disposes of GStreamer elements and decoding resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The universal source GStreamer element.
### IsAvailable()
Determines whether universal source support is available on the current system.
Requires GStreamer decoding plugins and format parsers to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if universal source support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this universal source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this universal source.
## See Also
---
# Class UniversalSourceBlockMini
Link: api/VisioForge.Core.MediaBlocks.Sources.UniversalSourceBlockMini.html
# Class UniversalSourceBlockMini
# Class UniversalSourceBlockMini
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Lightweight universal media source block with integrated format detection and decoding capabilities.
This mini version of UniversalSourceBlock provides a streamlined implementation optimized for common
media playback scenarios, offering automatic format detection, demuxing, and decoding in a single block.
Designed for applications requiring simple media playback without the complexity of manual pipeline construction.
Key features:
- Automatic format detection for 100+ container and codec combinations
- Integrated demuxing and decoding with hardware acceleration support
- Dynamic pad creation based on available streams (video/audio/subtitle)
- Support for local files, HTTP/HTTPS URLs, and custom URI schemes
- Optimized memory usage for embedded and mobile applications
- Selective stream rendering (video-only, audio-only, or both)
- Built-in buffering and synchronization management
Supported sources:
- Local files: All major formats (MP4, AVI, MKV, MOV, WebM, etc.)
- Network streams: HTTP, HTTPS, RTSP, RTMP, HLS, DASH
- Device URIs: Custom schemes for platform-specific sources
- Memory streams: Via custom URI protocols
Common use cases:
- Media player applications with basic playback needs
- Video preview and thumbnail generation
- Audio-only playback for music applications
- Embedded systems with limited resources
- Quick media format validation and analysis
The "Mini" designation indicates this block uses simplified internal processing
compared to the full UniversalSourceBlock, trading some advanced features for
reduced complexity and resource usage while maintaining compatibility with most
common media formats and use cases.
Implements the true if the source was successfully built and opened; false if initialization failed due to invalid URI or missing codecs.
### CleanUp()
Performs cleanup of all resources associated with the universal source.
Releases GStreamer elements and handles platform-specific resource cleanup.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core wrapper element for internal pipeline operations.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null as UniversalSource manages elements internally.
### GetElement()
Gets the underlying GStreamer element for advanced configuration and pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing the source operations.
### IsAvailable()
Determines whether the universal source functionality is available on the current platform.
Requires appropriate GStreamer plugins and codecs to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if universal source is available with necessary plugins; false if required components are missing.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this source block.
Called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that will manage this source.
## See Also
---
# Class UniversalSourceBlockV2
Link: api/VisioForge.Core.MediaBlocks.Sources.UniversalSourceBlockV2.html
# Class UniversalSourceBlockV2
# Class UniversalSourceBlockV2
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Universal source block that automatically creates the necessary pipeline based on file content.
```csharp
public class UniversalSourceBlockV2 : SourceMediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Constructors
### UniversalSourceBlockV2(UniversalSourceSettingsV2)
Initializes a new instance of the true if the decoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this VAAPI H.264 decoder block.
This method disposes of the GStreamer elements and releases VA-API resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer VAAPI H.264 decoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer VAAPI H.264 decoder.
### GetElement()
Gets the underlying GStreamer element that performs VAAPI H.264 hardware decoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the VAAPI H.264 decoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this VAAPI H.264 decoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VAAPIHEVCDecoderBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VAAPIHEVCDecoderBlock.html
# Class VAAPIHEVCDecoderBlock
# Class VAAPIHEVCDecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
VAAPI HEVC/H.265 hardware decoder block for Linux systems using Video Acceleration API.
This block provides GPU-accelerated HEVC (High Efficiency Video Coding) decoding through
VA-API, enabling efficient playback of H.265 content with minimal CPU usage. Supports
Intel Gen7+ GPUs, AMD GCN+, and NVIDIA GPUs with appropriate drivers. Features include
support for HEVC Main, Main 10 (10-bit), Main 12, Main 4:2:2 10, Main 4:4:4, and
Main Still Picture profiles, HDR support (HDR10, HLG), resolutions up to 8K,
and efficient decoding of modern streaming and UHD Blu-ray content. Essential for
4K/8K video players, streaming applications, video editors, and any Linux application
requiring efficient HEVC decoding for next-generation video content.
Implements the true if the decoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this VAAPI HEVC decoder block.
This method disposes of the GStreamer elements and releases VA-API resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer VAAPI HEVC decoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer VAAPI HEVC decoder.
### GetElement()
Gets the underlying GStreamer element that performs VAAPI HEVC hardware decoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the VAAPI HEVC decoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this VAAPI HEVC decoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VAAPIJPEGDecoderBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VAAPIJPEGDecoderBlock.html
# Class VAAPIJPEGDecoderBlock
# Class VAAPIJPEGDecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
VAAPI JPEG hardware decoder block for Linux systems using Video Acceleration API.
This block provides GPU-accelerated JPEG image decoding through VA-API, significantly
improving performance for applications that process large volumes of JPEG images.
Supports Intel, AMD, and NVIDIA GPUs with VA-API drivers. Features include hardware
acceleration for baseline and progressive JPEG formats, support for various color
spaces (YUV 4:2:0, 4:2:2, 4:4:4), high-resolution image decoding up to GPU limits,
and efficient batch processing of JPEG streams. Essential for photo viewers,
image galleries, video editors processing JPEG sequences, digital signage systems,
and any Linux application requiring fast JPEG decoding with minimal CPU usage.
Implements the true if the decoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this VAAPI JPEG decoder block.
This method disposes of the GStreamer elements and releases VA-API resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer VAAPI JPEG decoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer VAAPI JPEG decoder.
### GetElement()
Gets the underlying GStreamer element that performs VAAPI JPEG hardware decoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the VAAPI JPEG decoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this VAAPI JPEG decoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VAAPIVC1DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VAAPIVC1DecoderBlock.html
# Class VAAPIVC1DecoderBlock
# Class VAAPIVC1DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
VAAPI VC-1 hardware decoder block for Linux systems using Video Acceleration API.
This block provides GPU-accelerated VC-1 video decoding through VA-API, enabling efficient
playback of Windows Media Video (WMV) and VC-1 encoded content. VC-1 is Microsoft's
video codec standard used in WMV9, WMV HD, Blu-ray discs, and Xbox content. Supports
Intel, AMD, and NVIDIA GPUs with appropriate VA-API drivers. Features include support
for VC-1 Simple, Main, and Advanced profiles, interlaced and progressive content,
resolutions up to 1080p, and efficient decoding of WMV files and Blu-ray VC-1 streams.
Essential for media players handling Windows Media content, Blu-ray playback applications,
video converters, and any Linux application requiring VC-1/WMV9 decoding capability.
Implements the true if the decoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this VAAPI VC-1 decoder block.
This method disposes of the GStreamer elements and releases VA-API resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer VAAPI VC-1 decoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer VAAPI VC-1 decoder.
### GetElement()
Gets the underlying GStreamer element that performs VAAPI VC-1 hardware decoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the VAAPI VC-1 decoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this VAAPI VC-1 decoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoMixerSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VideoMixerSourceBlock.html
# Class VideoMixerSourceBlock
# Class VideoMixerSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Video mixer source block for combining multiple video sources into a single composite output.
Provides real-time video mixing with positioning, scaling, alpha blending, and chroma key support for creating
picture-in-picture effects, video walls, live production, and multi-stream compositing using CPU, OpenGL, or D3D11 acceleration.
Implements the true if the mixer source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the video mixer operations, including sources and compositing resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the video mixer source.
Properly disposes of all video sources, the mixer, and associated rendering resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks that manage multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always null for composite blocks that contain multiple managed sources.
### Input_Get(Guid)
Gets a specific input stream configuration by its unique identifier.
```csharp
public VideoMixerStream Input_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The GUID identifier of the input stream to retrieve.
#### Returns
Parameters:
- (VideoMixerStream): The VideoMixerStream containing position, size, and effects for the specified input.
### Input_List()
Gets the configuration of all input streams in the video mixer.
```csharp
public VideoMixerStream[] Input_List()
```
#### Returns
Parameters:
- (VideoMixerStream [ ]): An array of VideoMixerStream objects containing position, size, and effects for each input.
### Input_Move(Guid, Rect, TimeSpan, double?, double?)
Animates an input stream to a new position and size with optional alpha fade.
```csharp
public void Input_Move(Guid id, Rect rect, TimeSpan duration, double? startAlpha, double? endAlpha)
```
#### Parameters
Parameters:
- id (Guid): The GUID identifier of the input stream to move.
- rect (Rect): The target rectangle defining new position and size.
- duration (TimeSpan): The duration of the animation transition.
- startAlpha (double ?): The starting alpha transparency value (0.0-1.0) for fade effects.
- endAlpha (double ?): The ending alpha transparency value (0.0-1.0) for fade effects.
### Input_SetChromaKeyEnabled(Guid, bool)
Enables or disables chroma key (green screen) effect for a specific input stream.
```csharp
public void Input_SetChromaKeyEnabled(Guid id, bool enabled)
```
#### Parameters
Parameters:
- id (Guid): The GUID identifier of the input stream to modify.
- enabled (bool): If set to true, enables chroma key; otherwise, disables it.
### Input_Update(VideoMixerStream)
Updates the configuration of a specific input stream including position, size, and effects.
```csharp
public void Input_Update(VideoMixerStream stream)
```
#### Parameters
Parameters:
- stream (VideoMixerStream): The VideoMixerStream containing updated configuration for the input.
### Input_UpdateChromaKeySettings(Guid, ChromaKeySettingsX)
Updates the chroma key (green screen) settings for a specific input stream.
```csharp
public void Input_UpdateChromaKeySettings(Guid id, ChromaKeySettingsX settings)
```
#### Parameters
Parameters:
- id (Guid): The GUID identifier of the input stream to update.
- settings (ChromaKeySettingsX): The new chroma key settings including color range and tolerance values.
### IsAvailable()
Determines whether video mixer support is available on the current system.
Requires GStreamer compositor or GL video mixer plugins depending on the selected rendering mode.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if video mixer support is available; otherwise, false.
### SetSettings(VideoMixerBaseSettings)
Updates the video mixer configuration settings including output resolution and rendering mode.
```csharp
public void SetSettings(VideoMixerBaseSettings settings)
```
#### Parameters
Parameters:
- settings (VideoMixerBaseSettings): The new video mixer base settings to apply to the mixer.
### StartFadeIn(Guid, TimeSpan)
Starts a fade-in animation for a specific input stream from transparent to opaque.
```csharp
public void StartFadeIn(Guid id, TimeSpan duration)
```
#### Parameters
Parameters:
- id (Guid): The GUID identifier of the input stream to fade in.
- duration (TimeSpan): The duration of the fade-in animation.
### StartFadeOut(Guid, TimeSpan)
Starts a fade-out animation for a specific input stream from opaque to transparent.
```csharp
public void StartFadeOut(Guid id, TimeSpan duration)
```
#### Parameters
Parameters:
- id (Guid): The GUID identifier of the input stream to fade out.
- duration (TimeSpan): The duration of the fade-out animation.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this video mixer source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this video mixer source.
## See Also
---
# Class VirtualAudioSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VirtualAudioSourceBlock.html
# Class VirtualAudioSourceBlock
# Class VirtualAudioSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
Virtual audio source block for synthetic audio generation and testing purposes.
Provides programmable audio waveform generation including sine waves, square waves, white noise, and silence
for audio testing, calibration, signal processing development, and placeholder audio in multimedia applications.
Implements the true if the virtual audio source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the virtual audio operations, including waveform generators and audio buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the virtual audio source.
Properly stops audio generation and disposes of GStreamer elements and audio processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The virtual audio source GStreamer element.
### IsAvailable()
Determines whether virtual audio support is available on the current system.
Requires GStreamer audio test source plugins to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if virtual audio support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this virtual audio source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this virtual audio source.
## See Also
---
# Class VirtualVideoSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VirtualVideoSourceBlock.html
# Class VirtualVideoSourceBlock
# Class VirtualVideoSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
A virtual video source block that generates synthetic video frames for testing and development purposes.
This block creates a test video stream with customizable dimensions, frame rate, and patterns,
useful for pipeline testing without requiring actual video files or capture devices.
Implements the true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper. Not used for this block type.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null as this block doesn't use a BaseElement wrapper.
### GetElement()
Gets the underlying GStreamer element that generates the virtual video.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element from the virtual video source.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this block, providing access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class VNCSourceBlock
Link: api/VisioForge.Core.MediaBlocks.Sources.VNCSourceBlock.html
# Class VNCSourceBlock
# Class VNCSourceBlock
**Namespace**: VisioForge.Core.MediaBlocks.Sources
**Assembly**: VisioForge.Core.dll
VNC (Virtual Network Computing) source block for remote desktop access and screen sharing.
Provides real-time screen capture from remote computers via RFB (Remote Framebuffer) protocol for remote assistance,
system administration, and collaborative workflows with support for various VNC server implementations and authentication methods.
Implements the true if the VNC source was successfully built and configured; otherwise, false.
### CleanUp()
Cleans up all resources associated with the VNC operations, including network connection and video buffers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and managed resources used by the VNC source.
Properly closes VNC connection and disposes of GStreamer elements and video processing resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration and monitoring.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null for composite source blocks with multiple internal elements.
### GetElement()
Gets the native GStreamer element for direct GStreamer pipeline integration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The VNC source GStreamer element.
### IsAvailable()
Determines whether VNC support is available on the current system.
Requires GStreamer VNC source plugins and RFB protocol support to be installed and functional.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if VNC support is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this VNC source, providing access to the parent pipeline and logging context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocks pipeline containing this VNC source.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.Sources
Link: api/VisioForge.Core.MediaBlocks.Sources.html
# Namespace VisioForge.Core.MediaBlocks.Sources
# Namespace VisioForge.Core.MediaBlocks.Sources
### Classes
Parameters:
- (): Allied Vision industrial camera source block for professional video capture with GenICam-compatible cameras.
Provides high-performance video acquisition from Allied Vision cameras with advanced imaging features for machine vision,
industrial automation, scientific imaging, and quality control applications using GigE Vision and USB3 Vision standards.
Implements the true if the block was successfully built and configured; false if initialization failed.
### CallBarcodeDetected(BarcodeDetectorEventArgs)
Raises the OnBarcodeDetected event with the specified barcode detection results.
This method is called internally when the detector identifies barcodes in a frame.
```csharp
public void CallBarcodeDetected(BarcodeDetectorEventArgs args)
```
#### Parameters
Parameters:
- args (BarcodeDetectorEventArgs): The true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the barcode detector element.
### GetElement()
Gets the underlying GStreamer element for direct access to native properties.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer barcode detector element.
### IsAvailable()
Determines whether the barcode detector functionality is available in the current environment.
This checks if the required GStreamer barcode detection plugins are installed and accessible.
The appropriate VisioForge SDK redistribution package must be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if barcode detection plugins are available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
This internal method establishes the connection to the parent pipeline and provides access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
### OnBarcodeDetected
Occurs when one or more barcodes are detected in a video frame.
The event provides decoded barcode data, type, position, and confidence information.
This event is raised asynchronously as barcodes are detected in the video stream.
```csharp
public event EventHandlertrue if successful, false otherwise.
### Dispose(bool)
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): True if disposing, false if finalizing.
### GetInputCaps()
Gets the input caps string for RGB format.
```csharp
public string GetInputCaps()
```
#### Returns
Parameters:
- (string): The input caps string.
### GetOutputCaps()
Gets the output caps string for YV12 format.
```csharp
public string GetOutputCaps()
```
#### Returns
Parameters:
- (string): The output caps string.
### IMediaBlockInternals.Build()
Builds the media block by creating and initializing the underlying GStreamer elements.
```csharp
bool IMediaBlockInternals.Build()
```
#### Returns
Parameters:
- (bool): True if the block was successfully built; false if construction failed.
### IMediaBlockInternals.CleanUp()
Performs cleanup of resources and resets the converter to uninitialized state.
```csharp
void IMediaBlockInternals.CleanUp()
```
### IMediaBlockInternals.GetCore()
Retrieves the core BaseElement wrapper for this colorspace converter.
```csharp
BaseElement IMediaBlockInternals.GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapping the colorspace converter.
### IMediaBlockInternals.GetElement()
Retrieves the primary GStreamer element for this colorspace converter.
```csharp
Element IMediaBlockInternals.GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element performing colorspace conversion.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this colorspace converter block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media blocks pipeline that manages this converter.
---
# Class CustomMediaBlock
Link: api/VisioForge.Core.MediaBlocks.Special.CustomMediaBlock.html
# Class CustomMediaBlock
# Class CustomMediaBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
A flexible media block that allows integration of any GStreamer element or bin into the MediaBlocks pipeline.
This block serves as a bridge between the MediaBlocks abstraction and raw GStreamer elements,
enabling use of specialized or custom GStreamer components not wrapped by standard blocks.
Key features:
- Support for any GStreamer element by name or bin description
- Dynamic pad configuration with automatic or manual pad handling
- Property setting through key-value parameters
- Support for elements with dynamic pads (pad-added event)
- Optional caps filtering on output pads
- Property introspection for debugging
Common use cases:
- Integrating third-party GStreamer plugins
- Using experimental or platform-specific elements
- Creating complex processing chains with bin descriptions
- Prototyping new functionality before creating dedicated blocks
- Accessing GStreamer elements not yet wrapped in MediaBlocks
Technical details:
- Can create elements from factory names or parse bin descriptions
- Supports multiple input and output pads with configurable media types
- Handles dynamic pad creation for elements like demuxers
- Provides property mapping for various data types (int, float, string, enum)
- Uses identity elements for dynamic pad connection management
Implements the true if the element was successfully created and configured; false if initialization failed.
### CleanUp()
Performs cleanup of the custom element and associated resources.
Removes event handlers, disposes of the GStreamer element and identity helpers.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core element wrapper. Returns null as custom blocks don't use BaseElement wrappers.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for custom blocks.
### GetElement()
Gets the underlying GStreamer element created from the configuration.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element or bin.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this custom block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
### OnElementAdded
Occurs after the GStreamer element has been created and added to the pipeline.
This event allows for additional configuration or property setting on the raw element.
```csharp
public event EventHandlertrue if successful, false otherwise.
### CreateSample(Buffer, Caps)
Creates a new sample with the specified buffer and caps.
This is a helper method for creating samples to push.
```csharp
public static Sample CreateSample(Buffer buffer, Caps caps)
```
#### Parameters
Parameters:
- buffer (Buffer): The buffer for the sample.
- caps (Caps): The caps for the sample.
#### Returns
Parameters:
- (Sample): A new sample instance.
### CreateSample(Buffer, string)
Creates a new sample with the specified buffer using the output caps string.
This is a helper method for creating samples to push.
```csharp
public static Sample CreateSample(Buffer buffer, string capsString)
```
#### Parameters
Parameters:
- buffer (Buffer): The buffer for the sample.
- capsString (string): The caps string for the sample.
#### Returns
Parameters:
- (Sample): A new sample instance.
### Dispose(bool)
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): True if disposing, false if finalizing.
### PushBuffer(Buffer)
Pushes a new buffer to the output with the current output caps.
```csharp
public void PushBuffer(Buffer buffer)
```
#### Parameters
Parameters:
- buffer (Buffer): The buffer to push to output.
### PushSample(Sample)
Pushes a new sample to the output.
```csharp
public void PushSample(Sample sample)
```
#### Parameters
Parameters:
- sample (Sample): The sample to push to output.
### IMediaBlockInternals.Build()
Builds the media block by creating and initializing the underlying GStreamer elements.
```csharp
bool IMediaBlockInternals.Build()
```
#### Returns
Parameters:
- (bool): True if the block was successfully built; false if construction failed.
### IMediaBlockInternals.CleanUp()
Performs cleanup of resources and resets the transform to uninitialized state.
```csharp
void IMediaBlockInternals.CleanUp()
```
### IMediaBlockInternals.GetCore()
Retrieves the core BaseElement wrapper for this custom transform.
```csharp
BaseElement IMediaBlockInternals.GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapping the custom transform.
### IMediaBlockInternals.GetElement()
Retrieves the primary GStreamer element for this custom transform.
```csharp
Element IMediaBlockInternals.GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element performing custom transformation.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this custom transform block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media blocks pipeline that manages this transform.
### OnSampleReceived
This event occurs when a new sample is received on the input.
```csharp
public event EventHandlertrue if the encoder was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the custom encoder.
Disposes the encoder element and video converter.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element. Not applicable for custom encoder blocks.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always null as custom encoders don't use BaseElement wrappers.
### GetElement()
Gets the underlying custom GStreamer encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element instance representing the custom video encoder.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this custom encoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Class DataMatrixDecoder
Link: api/VisioForge.Core.MediaBlocks.Special.DataMatrixDecoder.html
# Class DataMatrixDecoder
# Class DataMatrixDecoder
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Provides asynchronous DataMatrix decoding capabilities for video frames using the LibDMTX library.
This class processes video frames to detect and decode DataMatrix 2D barcodes with configurable
frame skipping and processing synchronization to optimize CPU usage.
```csharp
public class DataMatrixDecoder : IDisposable
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
The decoder supports:
- Asynchronous frame processing to avoid blocking the video pipeline
- Frame skipping to reduce CPU load (analyze every Nth frame)
- Automatic frame dropping if processing is still in progress
- Multiple DataMatrix detection in a single frame
- Configurable timeout for decode operations
## Constructors
### DataMatrixDecoder()
Initializes a new instance of the true, operates in passthrough mode; otherwise acts as a sink.
- videoFormat (VideoFormatX): The pixel format for frame processing (default: RGBA).
## Properties
### DecodeTimeoutMs
Gets or sets the timeout in milliseconds for each decode operation.
Default is 500ms. Set to -1 for no timeout.
```csharp
public int DecodeTimeoutMs { get; set; }
```
#### Property Value
Parameters:
- (int):
### EnableDebugLogging
Gets or sets a value indicating whether to enable debug logging for the decoder.
```csharp
public bool EnableDebugLogging { get; set; }
```
#### Property Value
Parameters:
- (bool):
### ExpectedSize
Gets or sets the expected DataMatrix size for optimization.
Default is SymbolShapeAuto for automatic detection.
```csharp
public CodeSize ExpectedSize { get; set; }
```
#### Property Value
Parameters:
- (CodeSize):
### FrameSkip
Gets or sets the number of frames to skip between processing.
Default is 0 (process every frame). Higher values reduce CPU usage.
For example, setting to 2 will process every 3rd frame.
```csharp
public int FrameSkip { get; set; }
```
#### Property Value
Parameters:
- (int):
### Input
Gets the primary input pad for receiving video frames to analyze for DataMatrix codes.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the array of input pads. This block has a single video input.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### MaxCodes
Gets or sets the maximum number of DataMatrix codes to detect per frame.
Default is 1. Set to -1 for unlimited.
```csharp
public int MaxCodes { get; set; }
```
#### Property Value
Parameters:
- (int):
### Output
Gets the primary output pad that passes through video frames after DataMatrix detection.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the array of output pads. Contains one pad in passthrough mode, empty in sink mode.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Passthrough
Gets or sets a value indicating whether the block operates in passthrough mode.
When true, video frames are passed through after analysis.
When false, the block acts as a sink and consumes the frames.
```csharp
public bool Passthrough { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Type
Gets the media block type identifier for this DataMatrix decoder block.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
### VideoFormat
Gets or sets the pixel format used for frame capture and processing.
Default is RGBA for best compatibility with LibDMTX.
```csharp
public VideoFormatX VideoFormat { get; set; }
```
#### Property Value
Parameters:
- (VideoFormatX):
## Methods
### Build()
Builds and initializes the DataMatrix decoder block within the media pipeline.
Creates the video sample grabber, configures the decoder, and establishes pad connections.
This method is called automatically when the pipeline is being constructed.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the block was successfully built and configured; false if initialization failed.
### CleanUp()
Performs cleanup of internal resources and elements.
Releases the decoder, sample grabber, and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the sample grabber element.
### GetElement()
Gets the underlying GStreamer element for direct access to native properties.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer sample grabber element.
### IsAvailable()
Determines whether the DataMatrix decoder functionality is available in the current environment.
This checks if LibDMTX is properly loaded and the video sample grabber is available.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if DataMatrix decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this block.
This internal method establishes the connection to the parent pipeline and provides access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
### OnDataMatrixDetected
Occurs when one or more DataMatrix codes are detected in a video frame.
The event provides decoded text, symbol information, position, and metadata.
This event is raised asynchronously as DataMatrix codes are detected in the video stream.
```csharp
public event EventHandlertrue if successful, false otherwise.
### Dispose(bool)
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): True if disposing, false if finalizing.
### ProcessBuffer(Buffer, Caps)
Virtual method for processing buffer data. Override this method to implement custom buffer processing.
This method performs in-place processing - the buffer is modified directly.
```csharp
protected virtual FlowReturn ProcessBuffer(Buffer buffer, Caps caps)
```
#### Parameters
Parameters:
- buffer (Buffer): The buffer to process in-place
- caps (Caps): The negotiated caps for this buffer
#### Returns
Parameters:
- (FlowReturn): FlowReturn indicating success or failure
### IMediaBlockInternals.Build()
Builds the media block by creating and initializing the underlying GStreamer elements.
```csharp
bool IMediaBlockInternals.Build()
```
#### Returns
Parameters:
- (bool): True if the block was successfully built; false if construction failed.
### IMediaBlockInternals.CleanUp()
Performs cleanup of resources and resets the processor to uninitialized state.
```csharp
void IMediaBlockInternals.CleanUp()
```
### IMediaBlockInternals.GetCore()
Retrieves the core BaseElement wrapper for this data processor.
```csharp
BaseElement IMediaBlockInternals.GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapping the data processor.
### IMediaBlockInternals.GetElement()
Retrieves the primary GStreamer element for this data processor.
```csharp
Element IMediaBlockInternals.GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element performing data processing.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this data processor block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media blocks pipeline that manages this processor.
### OnBuffer
Gets or sets the event handler for buffer processing.
This event is fired for each buffer if ProcessBuffer is not overridden.
```csharp
public event EventHandlertrue if the grabber was successfully initialized; false if setup failed.
### CleanUp()
Performs cleanup of the data grabber resources.
Releases the GStreamer element and removes frame interception callbacks.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the data grabber element.
### GetElement()
Gets the underlying GStreamer element for direct property access.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer data grabber element.
### IsAvailable()
Determines whether the data sample grabber functionality is available in the current environment.
This checks if the required GStreamer components for data interception are installed.
The appropriate VisioForge SDK redistribution package must be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if data grabbing functionality is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this data grabber block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
### OnDataFrame
Occurs when a new data frame passes through the grabber.
The event provides access to the raw frame data, format information, and timing metadata.
This event is raised from the streaming thread and handlers should process data quickly.
```csharp
public event EventHandlertrue if the block was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of the debug timestamp element and associated resources.
Releases the GStreamer element and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core element wrapper. Returns null as this is a specialized debug element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this debug block.
### GetElement()
Gets the underlying GStreamer debug timestamp element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element that performs timestamp logging.
### IsAvailable()
Determines whether the debug timestamp functionality is available in the current environment.
This block is always available when the platform supports it (not iOS).
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): Always returns true on supported platforms.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this debug block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class DecodeBinBlock
Link: api/VisioForge.Core.MediaBlocks.Special.DecodeBinBlock.html
# Class DecodeBinBlock
# Class DecodeBinBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
An intelligent decoding block that automatically detects and decodes various media formats into raw streams.
DecodeBin analyzes incoming media data, identifies the format and codecs, and constructs an appropriate
decoding pipeline to produce raw video, audio, and subtitle outputs.
Key features:
- Automatic format detection and codec selection
- Support for virtually any media format GStreamer can decode
- Dynamic pad creation for discovered streams
- Separate outputs for video, audio, and subtitle streams
- Built-in format conversion for consistent output
- Configurable stream selection (video/audio/subtitle)
Common use cases:
- Decoding media files with unknown or variable formats
- Processing network streams with dynamic content
- Building flexible media players that handle any format
- Extracting raw streams from container formats
- Media analysis and transcoding pipelines
- Multi-stream processing applications
Technical details:
- Uses GStreamer's decodebin element for intelligent decoding
- Automatically constructs decoder chains based on stream caps
- Includes queue elements for each stream to handle threading
- Video output includes format conversion to standard formats
- Audio output can optionally include format conversion
- Handles dynamic stream addition during playback
Implements the true, decodes and outputs video streams. Default is true.
- renderAudio (bool): if set to true, decodes and outputs audio streams. Default is true.
- renderSubtitle (bool): if set to true, decodes and outputs subtitle streams. Default is false.
## Properties
### AudioOutput
Gets the audio output pad providing decoded raw audio samples.
```csharp
public MediaBlockPad AudioOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### DisableAudioConverter
Gets or sets a value indicating whether to disable automatic audio format conversion.
When true, audio is passed through without format conversion, preserving the decoded format.
```csharp
public bool DisableAudioConverter { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Input
Gets the input pad for receiving encoded media data.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the array of input pads. This block has a single input for encoded media.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the primary output pad, prioritizing video, then audio, then subtitle.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets all configured output pads based on enabled stream types.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### SubtitleOutput
Gets the subtitle output pad providing decoded subtitle data.
```csharp
public MediaBlockPad SubtitleOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Type
Gets the media block type identifier for this decode bin.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
### VideoOutput
Gets the video output pad providing decoded raw video frames.
```csharp
public MediaBlockPad VideoOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
## Methods
### Build()
Builds and initializes the decode bin within the media pipeline.
Sets up the decodebin element, creates queues and converters for each stream type,
and configures dynamic pad handling for stream discovery.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the decode bin was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all decode bin resources including queues and converters.
Releases all GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the decode bin.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the decodebin element.
### GetElement()
Gets the underlying GStreamer decodebin element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer decodebin element.
### IsAvailable()
Determines whether the decode bin functionality is available in the current environment.
This checks if the required GStreamer decodebin element is installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if decodebin is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this decode bin block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class DecryptorBlock
Link: api/VisioForge.Core.MediaBlocks.Special.DecryptorBlock.html
# Class DecryptorBlock
# Class DecryptorBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
A specialized media block that decrypts AES-encrypted media streams in real-time.
This block processes encrypted media data and outputs the decrypted content, enabling
secure media distribution and playback of protected content.
Key features:
- AES decryption with configurable key sizes (128, 192, 256 bits)
- Support for various AES modes (ECB, CBC, CFB, OFB, CTR, GCM)
- Real-time stream decryption with minimal latency
- Transparent passthrough design
- Compatible with any media type (video, audio, data)
- Configurable initialization vectors and padding
Common use cases:
- Playback of DRM-protected content
- Secure media streaming applications
- Decrypting downloaded encrypted media files
- Building secure media distribution systems
- Implementing custom content protection schemes
- Compliance with content security requirements
Technical details:
- Uses hardware-accelerated AES when available
- Maintains stream timing and metadata
- Zero-copy operation where possible
- Thread-safe decryption processing
- Compatible with standard AES implementations
- Supports streaming and file-based media
Implements the true if the decryptor was successfully initialized; false if setup failed.
### CleanUp()
Performs cleanup of the AES decryptor resources.
Releases the GStreamer element and clears sensitive key material.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the AES decryptor.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the AES decryptor element.
### GetElement()
Gets the underlying GStreamer AES decryptor element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing AES decryption.
### IsAvailable()
Determines whether the AES decryption functionality is available in the current environment.
This checks if the required GStreamer AES decryption plugins are installed.
The appropriate VisioForge SDK redistribution package must be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if AES decryption is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this decryptor block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class DecryptorPlayerBlock
Link: api/VisioForge.Core.MediaBlocks.Special.DecryptorPlayerBlock.html
# Class DecryptorPlayerBlock
# Class DecryptorPlayerBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Provides a complete media playback solution for encrypted files by combining decryption, demuxing, and decoding.
```csharp
public class DecryptorPlayerBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Check if decryption is available
if (!DecryptorPlayerBlock.IsAvailable())
{
throw new NotSupportedException("Decryption support not available");
}
// Create a decryptor player for an encrypted video file
var decryptorPlayer = new DecryptorPlayerBlock(
pipeline,
"/path/to/encrypted/video.enc",
"your-encryption-key",
"initialization-vector",
renderVideo: true,
renderAudio: true,
renderSubtitle: false);
// Connect outputs to renderers
pipeline.Connect(decryptorPlayer.VideoOutput, videoRenderer.Input);
pipeline.Connect(decryptorPlayer.AudioOutput, audioRenderer.Input);
// Start playback
await pipeline.StartAsync();
The
This block is particularly useful for:
The block internally manages a pipeline consisting of:
Platform Requirements:
Requires the decryption plugin to be available in your GStreamer installation.
Use
true.
- renderAudio (bool): Whether to enable audio stream output. Default is true.
- renderSubtitle (bool): Whether to enable subtitle stream output. Default is false.
#### Remarks
The constructor automatically creates and connects the internal pipeline components. If any connection fails, error messages are logged to the pipeline context.
The encryption parameters must match those used when the file was encrypted. Incorrect parameters will result in playback failure or corrupted output.
#### Exceptions Parameters: - (ArgumentNullException): Thrown whenpipeline, filename, key, or iv is null.
## Properties
### AudioOutput
Gets the audio output pad that provides decoded audio samples.
```csharp
public MediaBlockPad AudioOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
#### Remarks
This pad is only available when renderAudio was set to true during construction.
Connect this to an audio renderer or further processing blocks.
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### SubtitleOutput
Gets the subtitle output pad that provides decoded subtitle data.
```csharp
public MediaBlockPad SubtitleOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
#### Remarks
This pad is only available when renderSubtitle was set to true during construction.
Connect this to a subtitle renderer or overlay block.
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
### VideoOutput
Gets the video output pad that provides decoded video frames.
```csharp
public MediaBlockPad VideoOutput { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
#### Remarks
This pad is only available when renderVideo was set to true during construction.
Connect this to a video renderer or further processing blocks.
## Methods
### Build()
Builds the internal components of the decryptor player block.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if all components were successfully built; otherwise, false.
#### Remarks
This method is called automatically by the pipeline during initialization. It builds all internal components (source, decryptor, queue, and decoder) in sequence.
The method is idempotent - calling it multiple times has no effect after the first successful build.
If any component fails to build, the entire operation fails and returns false.
This method disposes of all internal blocks in reverse order of their creation: DecodeBin, BasicFileSource, Queue, and Decryptor.
After cleanup, the block cannot be used again and must be recreated if needed. This method is called automatically during disposal.
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core wrapper element for this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null as this is a composite block without a single core element.
#### Remarks
Composite blocks that manage multiple internal elements typically return null
as they don't have a single representative core element.
### GetElement()
Gets the primary GStreamer element of this block.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The file source element, which is the entry point of the internal pipeline.
#### Remarks
For composite blocks like this, the returned element is typically the first element
in the internal chain, which in this case is the file source.
### IsAvailable()
Determines whether the decryption functionality required by this block is available.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if decryption support is available; otherwise, false.
#### Remarks
This method checks for the availability of the underlying decryption plugin in the GStreamer installation.
Always call this method before attempting to create instances of
Availability depends on:
true if the encryptor was successfully initialized; false if setup failed.
### CleanUp()
Performs cleanup of the AES encryptor resources.
Releases the GStreamer element and clears sensitive key material from memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the AES encryptor.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the AES encryptor element.
### GetElement()
Gets the underlying GStreamer AES encryptor element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing AES encryption.
### IsAvailable()
Determines whether the AES encryption functionality is available in the current environment.
This checks if the required GStreamer AES encryption plugins are installed.
The appropriate VisioForge SDK redistribution package must be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if AES encryption is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this encryptor block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class FrameDoublerBlock
Link: api/VisioForge.Core.MediaBlocks.Special.FrameDoublerBlock.html
# Class FrameDoublerBlock
# Class FrameDoublerBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
A media block that doubles the frame rate of video streams by duplicating frames.
For example, converts 30fps video to 60fps by duplicating each frame with adjusted timestamps.
```csharp
public class FrameDoublerBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Constructors
### FrameDoublerBlock()
Initializes a new instance of the true if successful, false otherwise.
### Dispose(bool)
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): True if disposing, false if finalizing.
### GetFrameRateMultiplier()
Gets the frame rate multiplier applied by this block.
```csharp
public double GetFrameRateMultiplier()
```
#### Returns
Parameters:
- (double): The frame rate multiplier (typically 2.0 for doubling).
### GetInputCaps()
Gets the input caps string for the specified frame rate.
```csharp
public string GetInputCaps()
```
#### Returns
Parameters:
- (string): The input caps string.
### GetOutputCaps()
Gets the output caps string for the doubled frame rate.
```csharp
public string GetOutputCaps()
```
#### Returns
Parameters:
- (string): The output caps string.
### IMediaBlockInternals.Build()
Builds the media block by creating and initializing the underlying GStreamer elements.
```csharp
bool IMediaBlockInternals.Build()
```
#### Returns
Parameters:
- (bool): True if the block was successfully built; false if construction failed.
### IMediaBlockInternals.CleanUp()
Performs cleanup of resources and resets the block to uninitialized state.
```csharp
void IMediaBlockInternals.CleanUp()
```
### IMediaBlockInternals.GetCore()
Retrieves the core BaseElement wrapper for this frame doubler.
```csharp
BaseElement IMediaBlockInternals.GetCore()
```
#### Returns
Parameters:
- (BaseElement): The base element wrapping the frame doubler.
### IMediaBlockInternals.GetElement()
Retrieves the primary GStreamer element for this frame doubler.
```csharp
Element IMediaBlockInternals.GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element performing frame doubling.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this frame doubler block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media blocks pipeline that manages this block.
---
# Class LiveSyncBlock
Link: api/VisioForge.Core.MediaBlocks.Special.LiveSyncBlock.html
# Class LiveSyncBlock
# Class LiveSyncBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Live stream synchronization block that ensures frames are delivered on time for real-time streaming.
The LiveSync block synchronizes live streams by managing frame timing, dropping late frames,
and duplicating frames when needed to maintain consistent playback. This is essential for
live streaming scenarios where maintaining real-time delivery is critical.
Key features:
- Real-time frame synchronization for live streams
- Automatic dropping of late frames to prevent backlog
- Frame duplication when frames arrive too late
- Maintains consistent playback timing
- Low-latency operation for live streaming
- Suitable for live camera feeds, RTSP streams, and other real-time sources
Common use cases:
- Live camera streaming to ensure real-time delivery
- RTSP stream synchronization for IP cameras
- Live broadcasting to maintain consistent frame timing
- Real-time video conferencing applications
- Live sports or event streaming
- Any scenario requiring strict real-time frame delivery
Technical details:
- Monitors frame timestamps and delivery timing
- Drops frames that arrive too late to maintain real-time playback
- Duplicates previous frame if current frame hasn't arrived yet
- Operates with minimal latency for live scenarios
- Handles format changes and events properly
- Configurable latency and timeout parameters
Implements the true if the livesync block was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of the livesync resources.
Releases the GStreamer element and clears buffered data.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the livesync.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the livesync element.
### GetElement()
Gets the underlying GStreamer livesync element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer livesync element.
### IsAvailable()
Determines whether the livesync functionality is available in the current environment.
This requires the livesync GStreamer element to be available.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if livesync element is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this livesync block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class MultiQueueBlock
Link: api/VisioForge.Core.MediaBlocks.Special.MultiQueueBlock.html
# Class MultiQueueBlock
# Class MultiQueueBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
A specialized buffering block that provides multiple synchronized queues for handling multiple media streams.
MultiQueue is designed to manage multiple data streams with intelligent buffering and synchronization,
ensuring smooth playback and preventing starvation in multi-stream scenarios.
Key features:
- Multiple independent queues with shared buffering logic
- Automatic synchronization between streams
- Dynamic buffer size management
- Prevention of pipeline stalls in multi-stream scenarios
- Thread decoupling for each stream
- Configurable number of input/output pairs
Common use cases:
- Handling multiple streams from demuxers (video + audio + subtitle)
- Synchronizing streams with different data rates
- Buffering before muxing multiple streams
- Load balancing in parallel processing pipelines
- Preventing thread blocking in complex pipelines
- Managing streams with varying latencies
Technical details:
- Each queue runs in its own thread for isolation
- Implements intelligent buffering strategies
- Shares memory limits across all queues
- Handles format changes dynamically
- Provides backpressure when buffers are full
- More efficient than multiple separate Queue blocks
Implements the true if the multiqueue was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of the multiqueue resources.
Releases the GStreamer element and all associated queue structures.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the multiqueue.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the multiqueue element.
### GetElement()
Gets the underlying GStreamer multiqueue element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer multiqueue element.
### IsAvailable()
Determines whether the multiqueue functionality is available in the current environment.
This checks if the required GStreamer multiqueue element is installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if multiqueue is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this multiqueue block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class NullRendererBlock
Link: api/VisioForge.Core.MediaBlocks.Special.NullRendererBlock.html
# Class NullRendererBlock
# Class NullRendererBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Provides a sink element that consumes media data without producing any output, useful for testing and analysis.
```csharp
public class NullRendererBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals, IMediaBlockRenderer
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Example 1: Discard video while keeping audio
var nullRenderer = new NullRendererBlock(MediaBlockPadMediaType.Video)
{
IsSync = true // Keep synchronized with audio
};
pipeline.Connect(demuxer.VideoOutput, nullRenderer.Input);
pipeline.Connect(demuxer.AudioOutput, audioRenderer.Input);
// Example 2: Benchmark decoding performance
var nullRenderer = new NullRendererBlock(MediaBlockPadMediaType.Video)
{
IsSync = false // Process as fast as possible
};
pipeline.Connect(decoder.Output, nullRenderer.Input);
// Example 3: Test pipeline without rendering
var videoNull = new NullRendererBlock(MediaBlockPadMediaType.Video);
var audioNull = new NullRendererBlock(MediaBlockPadMediaType.Audio);
pipeline.Connect(source.VideoOutput, videoNull.Input);
pipeline.Connect(source.AudioOutput, audioNull.Input);
The
Common use cases include:
The block supports synchronization control through the
true: Maintains timing synchronization (default for playback)false: Processes data as fast as possible (ideal for transcoding)
This block implements
The media type determines what kind of data the null renderer will accept. Common types include:
The renderer is created with synchronization enabled by default.
Adjust
Synchronization behavior:
true: Respects timestamps and maintains real-time playback speed.
Use for playback applications where timing matters.false: Processes data without timing constraints.
Use for transcoding, analysis, or performance testing.When multiple streams are present (e.g., audio and video), synchronization ensures they remain aligned. For single-stream processing or when timing doesn't matter, disabling sync can significantly improve processing speed.
### Output Gets the output. ```csharp public override MediaBlockPad Output { get; } ``` #### Property Value Parameters: - (MediaBlockPad): ### Outputs Gets the outputs. ```csharp public override MediaBlockPad[] Outputs { get; } ``` #### Property Value Parameters: - (MediaBlockPad [ ]): ### Type Gets the type. ```csharp public override MediaBlockType Type { get; } ``` #### Property Value Parameters: - (MediaBlockType): ## Methods ### Build() Builds and initializes the null renderer element within the pipeline. ```csharp public override bool Build() ``` #### Returns Parameters: - (bool):true if the element was successfully built and initialized; otherwise, false.
#### Remarks
This method performs the following operations:
The method is idempotent and can be safely called multiple times. Errors during initialization are logged to the pipeline context.
### CleanUp() Performs cleanup of the null renderer resources. ```csharp public void CleanUp() ``` #### RemarksThis method safely disposes of the underlying GStreamer element and resets the build state. It handles exceptions during disposal to prevent cascading failures during pipeline shutdown.
The cleanup process includes:
This method is called automatically during disposal and should not be called directly by user code.
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The true if the null renderer is available; otherwise, false.
#### Remarks
The null renderer is a core GStreamer element and should be available in all
standard GStreamer installations. If this returns false, it indicates
a problem with the GStreamer installation or initialization.
Always verify availability before creating instances, especially in environments where GStreamer installation might be incomplete or customized.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline) Sets the context. ```csharp void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline) ``` #### Parameters Parameters: - pipeline (MediaBlocksPipeline): The pipeline. ## See Also --- # Class ParseBinBlock Link: api/VisioForge.Core.MediaBlocks.Special.ParseBinBlock.html # Class ParseBinBlock # Class ParseBinBlock **Namespace**: VisioForge.Core.MediaBlocks.Special **Assembly**: VisioForge.Core.dll Provides automatic parsing and demuxing of media streams without decoding, exposing elementary streams. ```csharp public class ParseBinBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals ``` #### Inheritance #### Implements #### Inherited Members #### Extension Methods ## Examples// Example 1: Extract streams for remuxing
var parseBin = new ParseBinBlock();
var muxer = new MP4MuxerBlock();
// Connect source to parser
pipeline.Connect(fileSource.Output, parseBin.Input);
// After pipeline starts, connect discovered streams
// (In practice, handle the OnPadAdded event)
pipeline.Connect(parseBin.Outputs[0], muxer.VideoInput);
pipeline.Connect(parseBin.Outputs[1], muxer.AudioInput);
// Example 2: Stream analysis without decoding
var parseBin = new ParseBinBlock();
pipeline.Connect(source.Output, parseBin.Input);
// Connect to analysis blocks that work with encoded data
pipeline.Connect(parseBin.Outputs[0], h264Analyzer.Input);
The
Key features and use cases:
The block dynamically creates output pads as streams are discovered:
Dynamic Pad Behavior: Output pads are created dynamically as the input stream is analyzed. Connect to the appropriate output pads after the pipeline starts and streams are discovered.
## Constructors ### ParseBinBlock() Initializes a new instance of theCreates a parse bin with:
Additional output pads may be created dynamically as streams are discovered. The actual number and types of output streams depend on the input media.
## Properties ### Input Gets the input. ```csharp public override MediaBlockPad Input { get; } ``` #### Property Value Parameters: - (MediaBlockPad): ### Inputs Gets the inputs. ```csharp public override MediaBlockPad[] Inputs { get; } ``` #### Property Value Parameters: - (MediaBlockPad [ ]): ### Output Gets the output. ```csharp public override MediaBlockPad Output { get; } ``` #### Property Value Parameters: - (MediaBlockPad): ### Outputs Gets the outputs. ```csharp public override MediaBlockPad[] Outputs { get; } ``` #### Property Value Parameters: - (MediaBlockPad [ ]): ### Type Gets the type. ```csharp public override MediaBlockType Type { get; } ``` #### Property Value Parameters: - (MediaBlockType): ## Methods ### Build() Builds and initializes the parsebin element within the pipeline. ```csharp public override bool Build() ``` #### Returns Parameters: - (bool):true if the element was successfully built and initialized; otherwise, false.
#### Remarks
This method performs the following operations:
Output pads are not configured during build as they are created dynamically when streams are discovered during pipeline operation.
### CleanUp() Performs cleanup of the parsebin resources. ```csharp public void CleanUp() ``` #### RemarksThis method unregisters event handlers and clears references to the parsebin element. Note that the element disposal is commented out, which may be intentional to avoid issues with GStreamer's internal reference counting during pipeline teardown.
The cleanup process includes:
true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The true if parsebin is available; otherwise, false.
#### Remarks
ParseBin requires GStreamer base plugins to be installed. This method verifies that the necessary components are available in your GStreamer installation.
If this returns false, ensure that:
true if the queue was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of the queue resources.
Releases the GStreamer element and clears buffered data.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the queue.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the queue element.
### GetElement()
Gets the underlying GStreamer queue element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer queue element.
### IsAvailable()
Determines whether the queue functionality is available in the current environment.
This is a core GStreamer element and should always be available.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if queue element is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this queue block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class SourceSwitchBlock
Link: api/VisioForge.Core.MediaBlocks.Special.SourceSwitchBlock.html
# Class SourceSwitchBlock
# Class SourceSwitchBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Provides dynamic switching between multiple input sources, allowing seamless source changes during pipeline operation.
```csharp
public class SourceSwitchBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Example 1: Switch between multiple cameras
var switchSettings = new SourceSwitchSettings { PadsCount = 3 };
var sourceSwitch = new SourceSwitchBlock(switchSettings);
// Connect three camera sources
pipeline.Connect(camera1.Output, sourceSwitch.Inputs[0]);
pipeline.Connect(camera2.Output, sourceSwitch.Inputs[1]);
pipeline.Connect(camera3.Output, sourceSwitch.Inputs[2]);
// Connect output to renderer
pipeline.Connect(sourceSwitch.Output, videoRenderer.Input);
// Switch to camera 2 during runtime
sourceSwitch.Switch(1);
// Example 2: Implement source failover
var switchSettings = new SourceSwitchSettings { PadsCount = 2 };
var sourceSwitch = new SourceSwitchBlock(switchSettings);
pipeline.Connect(primarySource.Output, sourceSwitch.Inputs[0]);
pipeline.Connect(backupSource.Output, sourceSwitch.Inputs[1]);
// Monitor primary source and switch to backup if needed
if (primarySourceFailed)
{
sourceSwitch.Switch(1); // Switch to backup
}
The
Key features and use cases:
The block supports:
Important: All input sources should have compatible formats (resolution, framerate, etc.) for optimal switching performance. Format differences may cause brief interruptions during switches.
## Constructors ### SourceSwitchBlock(SourceSwitchSettings) Initializes a new instance of the
The number of input pads is determined by
After construction, connect all input sources before starting the pipeline. The first input (index 0) is selected by default.
#### Exceptions Parameters: - (ArgumentNullException): Thrown whensettings is null.
- (ArgumentException): Thrown when settings contains invalid configuration.
## Properties
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Settings
Gets or sets the configuration settings for the source switch.
```csharp
public SourceSwitchSettings Settings { get; set; }
```
#### Property Value
Parameters:
- (SourceSwitchSettings):
#### Remarks
These settings must be configured before building the block and cannot be
changed after initialization.
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds and initializes the source switch element within the pipeline.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the element was successfully built and initialized; otherwise, false.
#### Remarks
This method performs the following operations:
The method creates request pads for inputs, allowing dynamic pad management. All pads are configured for automatic media type negotiation.
### CleanUp() Performs cleanup of the source switch resources. ```csharp public void CleanUp() ``` #### RemarksThis method disposes of the underlying GStreamer element and resets the build state. It ensures proper cleanup of all dynamically created pads and internal resources.
After cleanup, the block cannot be used again and must be recreated if needed. This method is called automatically during disposal.
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The true if source switching is available; otherwise, false.
#### Remarks
The source switch requires specific GStreamer plugins to be installed. This method verifies that all necessary components are available.
If this returns false, ensure that:
// Switch to the second input (index 1)
sourceSwitch.Switch(1);
// Implement a rotation between sources
int currentSource = 0;
void RotateSources()
{
currentSource = (currentSource + 1) % sourceSwitch.Settings.PadsCount;
sourceSwitch.Switch(currentSource);
}This method performs a seamless switch to the specified input source. The switch happens immediately and should not cause frame drops or audio glitches when sources have compatible formats.
Valid indices range from 0 to (PadsCount - 1). Attempting to switch to an invalid index logs an error and returns without switching.
Thread Safety: This method can be called from any thread and is safe to use during active pipeline operation.
#### Exceptions Parameters: - (InvalidOperationException): Thrown when the element is not initialized. - (ArgumentOutOfRangeException): Thrown whenswitchIndex is out of range.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class SRTPDecryptorBlock
Link: api/VisioForge.Core.MediaBlocks.Special.SRTPDecryptorBlock.html
# Class SRTPDecryptorBlock
# Class SRTPDecryptorBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
A specialized media block that decrypts SRTP (Secure Real-time Transport Protocol) streams in real-time.
This block processes encrypted SRTP packets and outputs decrypted RTP packets, enabling
secure media reception and playback of protected content.
Key features:
- SRTP decryption per RFC 3711 with configurable cipher suites
- Support for AES-128-ICM and AES-256-ICM decryption
- HMAC-SHA1 authentication verification with 80-bit or 32-bit tags
- Real-time SRTP stream decryption with minimal latency
- Transparent passthrough design for RTP/RTCP packets
- Compatible with standard SRTP implementations
- Separate decryption contexts for RTP and RTCP
- Replay attack protection
Common use cases:
- Receiving secure VoIP and video conferencing streams
- Decrypting real-time media broadcasts
- Building secure streaming client applications with WebRTC
- Implementing SIP/RTP security (SIPS/SRTP) receivers
- Compliance with security regulations for real-time communications
- Decrypting encrypted live video feeds and IP camera streams
Technical details:
- Uses AES decryption in Counter Mode (ICM/CTR) for low latency
- Verifies message authentication and detects tampering
- Maintains RTP timing and sequence numbers
- Zero-copy operation where possible
- Thread-safe decryption processing
- Compatible with standard SRTP key exchange mechanisms (SDES, DTLS-SRTP)
- Supports streaming and file-based media
Implements the true if the decryptor was successfully initialized; false if setup failed.
### CleanUp()
Performs cleanup of the SRTP decryptor resources.
Releases the GStreamer element and clears sensitive key material.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the SRTP decryptor.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the SRTP decryptor element.
### GetElement()
Gets the underlying GStreamer SRTP decryptor element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing SRTP decryption.
### IsAvailable()
Determines whether the SRTP decryption functionality is available in the current environment.
This checks if the required GStreamer SRTP decryption plugins are installed.
The appropriate VisioForge SDK redistribution package must be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if SRTP decryption is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this SRTP decryptor block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class SRTPEncryptorBlock
Link: api/VisioForge.Core.MediaBlocks.Special.SRTPEncryptorBlock.html
# Class SRTPEncryptorBlock
# Class SRTPEncryptorBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
A specialized media block that encrypts RTP streams using SRTP (Secure Real-time Transport Protocol) in real-time.
This block processes unencrypted RTP packets and outputs SRTP encrypted packets, enabling
secure media streaming and transmission for content protection.
Key features:
- SRTP encryption per RFC 3711 with configurable cipher suites
- Support for AES-128-ICM and AES-256-ICM encryption
- HMAC-SHA1 authentication with 80-bit or 32-bit tags
- Real-time RTP stream encryption with minimal latency
- Transparent passthrough design for RTP/RTCP packets
- Compatible with standard SRTP implementations
- Separate encryption contexts for RTP and RTCP
Common use cases:
- Securing VoIP and video conferencing streams
- Protecting real-time media broadcasts
- Building secure streaming applications with WebRTC
- Implementing SIP/RTP security (SIPS/SRTP)
- Compliance with security regulations for real-time communications
- Encrypting live video feeds and IP camera streams
Technical details:
- Uses AES encryption in Counter Mode (ICM/CTR) for low latency
- Provides message authentication and replay protection
- Preserves RTP timing and sequence numbers
- Zero-copy operation where possible
- Thread-safe encryption processing
- Compatible with standard SRTP key exchange mechanisms (SDES, DTLS-SRTP)
- Pairs with SRTPDecryptorBlock for round-trip encryption
Implements the true if the encryptor was successfully initialized; false if setup failed.
### CleanUp()
Performs cleanup of the SRTP encryptor resources.
Releases the GStreamer element and clears sensitive key material from memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for the SRTP encryptor.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance wrapping the SRTP encryptor element.
### GetElement()
Gets the underlying GStreamer SRTP encryptor element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing SRTP encryption.
### IsAvailable()
Determines whether the SRTP encryption functionality is available in the current environment.
This checks if the required GStreamer SRTP encryption plugins are installed.
The appropriate VisioForge SDK redistribution package must be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if SRTP encryption is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this SRTP encryptor block.
This internal method establishes the connection to the parent pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class SuperMediaBlock
Link: api/VisioForge.Core.MediaBlocks.Special.SuperMediaBlock.html
# Class SuperMediaBlock
# Class SuperMediaBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Provides a container for combining multiple media blocks into a single reusable unit.
```csharp
public class SuperMediaBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Derived
#### Implements
#### Inherited Members
#### Extension Methods
## Examples
// Example 1: Create a reusable video enhancement chain
public class VideoEnhancementBlock : SuperMediaBlock
{
public VideoEnhancementBlock() : base(autoConnectBlocks: true)
{
// Add blocks in processing order
Blocks.Add(new DeinterlaceBlock());
Blocks.Add(new ColorCorrectionBlock());
Blocks.Add(new SharpenBlock());
Blocks.Add(new NoiseReductionBlock());
}
}
// Use it like any other block
var enhancer = new VideoEnhancementBlock();
enhancer.Configure(pipeline);
pipeline.Connect(source.Output, enhancer.Input);
pipeline.Connect(enhancer.Output, renderer.Input);
// Example 2: Manual connection for complex routing
var superBlock = new SuperMediaBlock(autoConnectBlocks: false);
var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var effect1 = new BlurEffectBlock();
var effect2 = new EdgeDetectionBlock();
var mixer = new VideoMixerBlock();
superBlock.Blocks.AddRange(new[] { tee, effect1, effect2, mixer });
// Configure before connecting
superBlock.Configure(pipeline);
// Manual internal connections
pipeline.Connect(tee.Outputs[0], effect1.Input);
pipeline.Connect(tee.Outputs[1], effect2.Input);
pipeline.Connect(effect1.Output, mixer.Inputs[0]);
pipeline.Connect(effect2.Output, mixer.Inputs[1]);
The
Key features and benefits:
The super block exposes:
Auto-connect Mode: When enabled (default), blocks are automatically
connected in the order they are added. When disabled, you must manually connect
the internal blocks before calling
true to automatically connect blocks in sequence during configuration;
false if blocks will be manually connected.
Default is true.
#### Remarks
When autoConnectBlocks is true:
When autoConnectBlocks is false:
Add blocks to this collection in the order they should be connected (when using auto-connect mode). The first block's inputs become the super block's inputs, and the last block's outputs become the super block's outputs.
Blocks should be added before calling
true as super blocks have no build operations.
#### Remarks
Unlike regular media blocks, super blocks don't create GStreamer elements. This method simply sets the build flag. The actual building of contained blocks is handled by the pipeline when they are connected.
The method is idempotent - multiple calls have no effect after the first.
### CleanUp() Performs cleanup of all contained blocks and resources. ```csharp public void CleanUp() ``` #### Remarks
This method disposes of all blocks in the
After cleanup, the super block cannot be used again. A new instance must be created if the same functionality is needed.
This method is called automatically during disposal and should not be called directly by user code.
### Configure(MediaBlocksPipeline) Configures the super block by setting up the pipeline context and optionally connecting internal blocks. ```csharp public void Configure(MediaBlocksPipeline pipeline) ``` #### Parameters Parameters: - pipeline (MediaBlocksPipeline): The media pipeline that will contain this super block. #### RemarksThis method must be called before using the super block in a pipeline. It performs the following operations:
When auto-connect is enabled, blocks are connected using their primary Output and Input pads. For complex routing, disable auto-connect and manually establish connections after calling this method.
Important: Add all blocks to the
pipeline is null.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core wrapper element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null as super blocks don't have a single core element.
#### Remarks
Super blocks are containers for other blocks and don't have their own
GStreamer element. To access specific elements, query the contained blocks.
### GetElement()
Gets the underlying GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Always returns null as super blocks don't have a single GStreamer element.
#### Remarks
Super blocks are logical containers only. To access GStreamer elements,
query the individual blocks within the true as super blocks have no specific dependencies.
#### Remarks
Super blocks are a framework-level feature and don't depend on specific GStreamer plugins or external components. However, the availability of the contained blocks should be checked separately.
When using super blocks, ensure all contained blocks are available by
calling their respective IsAvailable methods.
// Example 1: Display video while recording
var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var displayQueue = new QueueBlock();
var recordQueue = new QueueBlock();
pipeline.Connect(decoder.Output, tee.Input);
pipeline.Connect(tee.Outputs[0], displayQueue.Input);
pipeline.Connect(tee.Outputs[1], recordQueue.Input);
pipeline.Connect(displayQueue.Output, videoRenderer.Input);
pipeline.Connect(recordQueue.Output, encoder.Input);
// Example 2: Apply multiple effects
var tee = new TeeBlock(3, MediaBlockPadMediaType.Video);
pipeline.Connect(source.Output, tee.Input);
pipeline.Connect(tee.Outputs[0], blurEffect.Input);
pipeline.Connect(tee.Outputs[1], edgeDetection.Input);
pipeline.Connect(tee.Outputs[2], colorCorrection.Input);
// Example 3: Dynamic output addition
var tee = new TeeBlock(1, MediaBlockPadMediaType.Audio);
pipeline.Connect(audioSource.Output, tee.Input);
// Later, add a new output dynamically
var newOutput = tee.AddNewPadLive();
pipeline.Connect(newOutput, newAudioProcessor.Input);
The
Key characteristics:
Common use cases:
Performance Note: While the tee itself has minimal overhead, connecting slow consumers can affect the entire pipeline. Consider using queue blocks after each tee output to decouple processing speeds.
## Constructors ### TeeBlock(int, MediaBlockPadMediaType) Initializes a new instance of the
Creates a tee block with the specified number of output pads. Additional
outputs can be added later using
The media type determines what kind of data can flow through the tee:
While you must specify at least one output during construction, unused outputs don't consume resources until connected.
#### Exceptions Parameters: - (ArgumentException): Thrown whennumOfOutputs is less than 1.
## Properties
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### MediaType
Gets the media type that this tee block handles.
```csharp
public MediaBlockPadMediaType MediaType { get; }
```
#### Property Value
Parameters:
- (MediaBlockPadMediaType):
#### Remarks
All pads (input and outputs) of a tee block must have the same media type.
This is set during construction and cannot be changed.
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### AddNewPadLive()
Dynamically adds a new output pad to the tee while the pipeline is running.
```csharp
public MediaBlockPad AddNewPadLive()
```
#### Returns
Parameters:
- (MediaBlockPad): The newly created null if creation failed.
#### Examples
// Add a new output while streaming
var newOutput = tee.AddNewPadLive();
if (newOutput != null)
{
var recorder = new FileRecorderBlock("output.mp4");
pipeline.Connect(newOutput, recorder.Input);
}This method allows adding outputs to a tee block during active pipeline operation without interrupting the media flow. This is useful for:
The new pad inherits the media type of the tee block and can be immediately connected to downstream elements.
Thread Safety: This method is thread-safe and can be called while the pipeline is in PLAYING state.
### Build() Builds and initializes the tee element within the pipeline. ```csharp public override bool Build() ``` #### Returns Parameters: - (bool):true if the element was successfully built and initialized; otherwise, false.
#### Remarks
This method performs the following operations:
The method configures static pads for all outputs specified during construction. Additional dynamic pads can be added later if needed.
### CleanUp() Performs cleanup of the tee element and resources. ```csharp public void CleanUp() ``` #### RemarksThis method disposes of the underlying GStreamer tee element and resets the build state. All output connections are implicitly broken during cleanup.
After cleanup, the block cannot be used again and must be recreated if needed. This method is called automatically during disposal.
### Dispose(bool) Releases unmanaged and - optionally - managed resources. ```csharp protected override void Dispose(bool disposing) ``` #### Parameters Parameters: - disposing (bool):true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer wrapper element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The null if all outputs are connected.
#### Examples
// Dynamically connect available outputs
var freePad = tee.GetFreeOutputPad();
if (freePad != null)
{
pipeline.Connect(freePad, newConsumer.Input);
}
else
{
// All outputs used, add a new one
var newPad = tee.AddNewPadLive();
pipeline.Connect(newPad, newConsumer.Input);
}This method is useful for dynamically connecting outputs without tracking which pads are in use. It scans outputs in order and returns the first unconnected pad found.
If all outputs are connected, consider using
true if the tee element is available; otherwise, false.
#### Remarks
The tee is a core GStreamer element and should be available in all
standard installations. If this returns false, it indicates
a serious problem with the GStreamer installation.
Always verify availability before creating instances, especially in environments with custom or minimal GStreamer installations.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline) Sets the context. ```csharp void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline) ``` #### Parameters Parameters: - pipeline (MediaBlocksPipeline): The pipeline. ## See Also --- # Enum UniversalDecoderBlock.DecoderStrategy Link: api/VisioForge.Core.MediaBlocks.Special.UniversalDecoderBlock.DecoderStrategy.html # Enum UniversalDecoderBlock.DecoderStrategy # Enum UniversalDecoderBlock.DecoderStrategy **Namespace**: VisioForge.Core.MediaBlocks.Special **Assembly**: VisioForge.Core.dll Decoder selection strategy. ```csharp public enum UniversalDecoderBlock.DecoderStrategy ``` ## Fields Parameters: - PreferHardware (): Prefer hardware decoders when available. - ForceSoftware (): Always use software decoders. - Auto (): Automatic selection based on performance. --- # Class UniversalDecoderBlock Link: api/VisioForge.Core.MediaBlocks.Special.UniversalDecoderBlock.html # Class UniversalDecoderBlock # Class UniversalDecoderBlock **Namespace**: VisioForge.Core.MediaBlocks.Special **Assembly**: VisioForge.Core.dll A universal decoder block that replaces decodebin with controlled decoder management. This block automatically selects appropriate decoders for input streams and provides explicit control over memory management to avoid the uncontrolled memory leaks of decodebin. ```csharp public class UniversalDecoderBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals ``` #### Inheritance #### Implements #### Inherited Members #### Extension Methods ## Constructors ### UniversalDecoderBlock(MediaBlockPadMediaType) Initializes a new instance of thetrue if the block was successfully built; otherwise, false.
### CreateAsync(Uri, bool, bool, bool)
Creates a UniversalDemuxDecoderBlock from a URI.
```csharp
public static Tasktrue to release both managed and unmanaged resources; false to release only unmanaged resources.
### IMediaBlockInternals.Build()
Constructs and initializes the underlying GStreamer elements for this MediaBlock.
This method creates the necessary GStreamer components, configures their properties,
and prepares the block for integration into the pipeline. Must be called before the block can process media.
```csharp
bool IMediaBlockInternals.Build()
```
#### Returns
Parameters:
- (bool): True if the block was successfully built and all required elements were created; false if construction failed.
### IMediaBlockInternals.CleanUp()
Releases all resources and performs cleanup operations for this MediaBlock.
This method disposes of GStreamer elements, releases memory, and ensures proper
shutdown of the block. Called automatically during pipeline teardown.
```csharp
void IMediaBlockInternals.CleanUp()
```
### IMediaBlockInternals.GetCore()
Retrieves the core BaseElement wrapper that provides additional functionality
around the GStreamer element. This wrapper adds VisioForge-specific features
and simplifies common operations on the underlying GStreamer element.
```csharp
BaseElement IMediaBlockInternals.GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer element.
### IMediaBlockInternals.GetElement()
Retrieves the primary GStreamer element that represents this MediaBlock in the pipeline.
This element is the main component that performs the actual media processing
and is connected to other elements in the GStreamer pipeline.
```csharp
Element IMediaBlockInternals.GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance, or null if the block hasn't been built yet.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this MediaBlock with a pipeline and initializes its internal context.
This method is called automatically when the block is added to a pipeline,
providing access to shared resources and pipeline-wide configuration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
---
# Class UniversalTransformBlock
Link: api/VisioForge.Core.MediaBlocks.Special.UniversalTransformBlock.html
# Class UniversalTransformBlock
# Class UniversalTransformBlock
**Namespace**: VisioForge.Core.MediaBlocks.Special
**Assembly**: VisioForge.Core.dll
Universal transform block that allows arbitrary video transformations with configurable caps.
Supports 1:N frame transformations through a virtual method that must be overridden.
```csharp
public abstract class UniversalTransformBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
#### Extension Methods
## Constructors
### UniversalTransformBlock(string, string)
Initializes a new instance of the UniversalTransformBlock.
```csharp
protected UniversalTransformBlock(string inputCaps, string outputCaps)
```
#### Parameters
Parameters:
- inputCaps (string): GStreamer caps string for input (e.g., "video/x-raw,format=RGB,width=1920,height=1080,framerate=30/1")
- outputCaps (string): GStreamer caps string for output (e.g., "video/x-raw,format=NV12,width=1280,height=720,framerate=60/1")
## Properties
### Input
Gets the input pad.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the collection of input pads.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output pad.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the collection of output pads.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Type
Gets the media block type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Builds the media block element.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool):
### CreateBuffer(byte[], ulong, ulong, ulong)
Helper method to create a buffer with specific data.
```csharp
protected static Buffer CreateBuffer(byte[] data, ulong pts = 0, ulong dts = 0, ulong duration = 0)
```
#### Parameters
Parameters:
- data (byte [ ]):
- pts (ulong):
- dts (ulong):
- duration (ulong):
#### Returns
Parameters:
- (Buffer):
### Dispose(bool)
Destroys the media block element.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool):
### GetVideoInfo(Caps, out string, out int, out int, out int, out int)
Helper method to get video format info from caps.
```csharp
protected static bool GetVideoInfo(Caps caps, out string format, out int width, out int height, out int frameRateNum, out int frameRateDen)
```
#### Parameters
Parameters:
- caps (Caps):
- format (string):
- width (int):
- height (int):
- frameRateNum (int):
- frameRateDen (int):
#### Returns
Parameters:
- (bool):
### OnTransformFrame(Buffer, Caps, Caps)
Abstract method that must be overridden to provide frame transformation logic.
```csharp
protected abstract ListSupported profiles: Main, High, Professional
Performance: Hardware decoders can achieve 8K@60fps or higher depending on GPU capabilities
Use cases: Video playback, transcoding, streaming, video editing, next-gen codec support
Implements thetrue if the decoder was successfully built; otherwise, false.
### CleanUp()
Performs cleanup of internal resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Handles proper disposal of the decoder resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): True if disposing managed resources.
### GetCore()
Gets the core BaseElement wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement instance.
### GetElement()
Gets the element associated with this block.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element for the AV1 decoder.
### IsAvailable(AV1DecoderType)
Checks if the specified AV1 decoder type is available on the system.
```csharp
public static bool IsAvailable(AV1DecoderType decoderType = AV1DecoderType.Auto)
```
#### Parameters
Parameters:
- decoderType (AV1DecoderType): The type of decoder to check.
#### Returns
Parameters:
- (bool): true if the decoder is available; otherwise, false.
### SyncStateWithParent()
Synchronizes the decoder state with its parent element.
```csharp
public void SyncStateWithParent()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline.
## See Also
---
# Class H264DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.H264DecoderBlock.html
# Class H264DecoderBlock
# Class H264DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
H.264/AVC video decoder block that converts compressed H.264 bitstreams into raw video frames.
This block supports multiple decoder implementations including software (FFmpeg, OpenH264),
hardware-accelerated (NVIDIA NVDEC, VAAPI on Linux, DXVA on Windows), and can automatically
select the best available decoder for optimal performance. Essential for decoding H.264 content
from files, streams, and live sources in media processing pipelines.
Supported profiles: Baseline, Main, High, High 10, High 4:2:2, High 4:4:4
Performance: Hardware decoders can achieve 4K@60fps or higher depending on GPU capabilities
Use cases: Video playback, transcoding, streaming, video editing, surveillance systems
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core H.264 decoder element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer H.264 decoder element.
### IsAvailable(H264DecoderType)
Determines whether the specified H.264 decoder implementation is available on the current system.
This method checks for the presence of required libraries, drivers, and hardware support
for the requested decoder type. Ensure the appropriate NuGet SDK redistribution packages
are included in your project for the decoder types you intend to use.
```csharp
public static bool IsAvailable(H264DecoderType decoder)
```
#### Parameters
Parameters:
- decoder (H264DecoderType): The specific H.264 decoder type to check for availability (FFmpeg, OpenH264, NVDEC, VAAPI, etc.).
#### Returns
Parameters:
- (bool): true if the specified decoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Class HEVCDecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.HEVCDecoderBlock.html
# Class HEVCDecoderBlock
# Class HEVCDecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
H.265/HEVC video decoder block that converts compressed HEVC bitstreams into raw video frames.
This block supports multiple decoder implementations including software (FFmpeg),
hardware-accelerated (NVIDIA NVDEC, Intel QSV, AMD AMF, VAAPI on Linux, DXVA on Windows), and can automatically
select the best available decoder for optimal performance. Essential for decoding HEVC content
from files, streams, and live sources in media processing pipelines.
Supported profiles: Main, Main 10, Main Still Picture
Performance: Hardware decoders can achieve 4K@60fps or higher depending on GPU capabilities
Use cases: Video playback, transcoding, streaming, video editing, surveillance systems
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core HEVC decoder element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer HEVC decoder element.
### IsAvailable(HEVCDecoderType)
Determines whether the specified HEVC decoder implementation is available on the current system.
This method checks for the presence of required libraries, drivers, and hardware support
for the requested decoder type. Ensure the appropriate NuGet SDK redistribution packages
are included in your project for the decoder types you intend to use.
```csharp
public static bool IsAvailable(HEVCDecoderType decoder)
```
#### Parameters
Parameters:
- decoder (HEVCDecoderType): The specific HEVC decoder type to check for availability (FFmpeg, NVDEC, QSV, AMF, VAAPI, etc.).
#### Returns
Parameters:
- (bool): true if the specified decoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Class JPEGDecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.JPEGDecoderBlock.html
# Class JPEGDecoderBlock
# Class JPEGDecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
JPEG image decoder block that converts compressed JPEG/MJPEG streams into raw video frames.
This software-based decoder handles both still JPEG images and Motion JPEG (MJPEG) video streams,
supporting baseline and progressive JPEG encoding. Commonly used for IP cameras, webcams,
and applications requiring frame-by-frame image decoding.
Supported formats: JPEG baseline, JPEG progressive, MJPEG streams
Performance: Software-based decoding suitable for moderate frame rates and resolutions
Use cases: IP camera streams, webcam capture, image sequence processing, MJPEG playback
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core JPEG decoder element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer JPEG decoder element.
### IsAvailable()
Determines whether the JPEG decoder is available on the current system.
This method checks for the presence of required libraries and dependencies.
Ensure the appropriate NuGet SDK redistribution packages are included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the JPEG decoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Class NVAV1DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVAV1DecoderBlock.html
# Class NVAV1DecoderBlock
# Class NVAV1DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated AV1 video decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode AV1
video streams with minimal CPU usage. AV1 is an open, royalty-free video coding format
designed for video transmissions over the Internet, offering superior compression efficiency
compared to H.264 and VP9, with support for up to 8K resolution and HDR content.
Hardware requirements: NVIDIA GPU with AV1 NVDEC support (RTX 30xx series or newer)
Supported profiles: Main Profile (8-bit and 10-bit 4:2:0), supports HDR10/HDR10+
Performance: Can decode 4K@120fps or 8K@60fps depending on GPU model, multiple streams supported
Use cases: Streaming services (Netflix, YouTube), next-gen video content, HDR/8K delivery
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA AV1 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA AV1 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware AV1 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware with AV1 support, NVDEC capability, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA AV1 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVH264DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVH264DecoderBlock.html
# Class NVH264DecoderBlock
# Class NVH264DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated H.264/AVC decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode H.264 video streams
with minimal CPU usage. Supports all H.264 profiles and levels supported by the GPU hardware,
providing exceptional performance for high-resolution and high-framerate content.
Hardware requirements: NVIDIA GPU with NVDEC support (GTX 10xx series or newer, Quadro, Tesla)
Supported profiles: All profiles supported by GPU including Baseline, Main, High, High 10, High 4:2:2, High 4:4:4
Performance: Can decode multiple 4K@60fps streams simultaneously depending on GPU model
Use cases: High-performance video playback, multi-stream surveillance, real-time transcoding, video walls
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA H.264 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA H.264 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware H.264 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware, NVDEC support, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA H.264 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVH265DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVH265DecoderBlock.html
# Class NVH265DecoderBlock
# Class NVH265DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated H.265/HEVC decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode H.265/HEVC video streams
with minimal CPU usage. Supports Main, Main 10, Main 12, and other HEVC profiles supported by the GPU,
enabling efficient playback of modern high-efficiency video content including HDR formats.
Hardware requirements: NVIDIA GPU with HEVC NVDEC support (GTX 960/10xx series or newer, Quadro, Tesla)
Supported profiles: Main, Main 10 (10-bit), Main 12 (12-bit), Main 4:4:4, Range Extensions
Performance: Can decode 8K@30fps or multiple 4K@60fps streams depending on GPU model
Use cases: 4K/8K video playback, HDR content, streaming services, professional video production
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA H.265/HEVC hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA H.265/HEVC decoder element.
### IsAvailable()
Determines whether NVIDIA hardware H.265/HEVC decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware with HEVC support, NVDEC capability, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA H.265/HEVC hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVJPEGDecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVJPEGDecoderBlock.html
# Class NVJPEGDecoderBlock
# Class NVJPEGDecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated JPEG decoder block using NVJPEG technology.
This block leverages NVIDIA GPU hardware to decode JPEG images and MJPEG streams with exceptional
performance, offloading the CPU-intensive decoding process to the GPU. Ideal for high-throughput
image processing, multi-camera surveillance systems, and real-time MJPEG video decoding.
Hardware requirements: NVIDIA GPU with compute capability 3.5 or higher
Supported formats: Baseline JPEG, Progressive JPEG, MJPEG streams
Performance: Can decode thousands of images per second depending on GPU and image size
Use cases: High-speed image processing, multi-stream surveillance, medical imaging, machine vision
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVJPEG hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVJPEG element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA JPEG hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVJPEG element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA JPEG decoder element.
### IsAvailable()
Determines whether NVIDIA hardware JPEG decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware, CUDA support, and NVJPEG library.
Ensure the NVIDIA NVJPEG SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA JPEG hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVMPEG1DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVMPEG1DecoderBlock.html
# Class NVMPEG1DecoderBlock
# Class NVMPEG1DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated MPEG-1 video decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode legacy MPEG-1
video streams with minimal CPU usage. Supports standard MPEG-1 video format commonly found in
older video files, VCD content, and legacy broadcast systems.
Hardware requirements: NVIDIA GPU with NVDEC support (most modern NVIDIA GPUs)
Supported formats: MPEG-1 Part 2 video, supports all standard frame rates and resolutions
Performance: Hardware acceleration provides efficient decoding even for older GPUs
Use cases: Legacy video archives, VCD playback, older surveillance footage, broadcast archives
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA MPEG-1 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA MPEG-1 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware MPEG-1 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware, NVDEC support, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA MPEG-1 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVMPEG2DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVMPEG2DecoderBlock.html
# Class NVMPEG2DecoderBlock
# Class NVMPEG2DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated MPEG-2 video decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode MPEG-2
video streams with minimal CPU usage. Supports all MPEG-2 profiles including Main Profile
and 4:2:2 Profile, commonly used in DVD content, broadcast television, and professional video.
Hardware requirements: NVIDIA GPU with NVDEC support (most modern NVIDIA GPUs)
Supported profiles: Main Profile (MP@ML, MP@HL), 4:2:2 Profile, supports interlaced content
Performance: Hardware acceleration enables smooth playback of HD broadcast streams
Use cases: DVD playback, broadcast television, cable/satellite streams, professional video editing
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA MPEG-2 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA MPEG-2 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware MPEG-2 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware, NVDEC support, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA MPEG-2 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVMPEG4DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVMPEG4DecoderBlock.html
# Class NVMPEG4DecoderBlock
# Class NVMPEG4DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated MPEG-4 Part 2 video decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode MPEG-4
Part 2 video streams (including DivX and XviD) with minimal CPU usage. Supports Simple Profile
and Advanced Simple Profile, commonly used in older video files and some streaming applications.
Hardware requirements: NVIDIA GPU with NVDEC support (most modern NVIDIA GPUs)
Supported profiles: Simple Profile, Advanced Simple Profile (ASP), supports B-frames and GMC
Performance: Hardware acceleration provides efficient decoding of SD and HD content
Use cases: Legacy video files, DivX/XviD content, older streaming formats, video archives
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA MPEG-4 Part 2 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA MPEG-4 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware MPEG-4 Part 2 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware, NVDEC support, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA MPEG-4 Part 2 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVVP8DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVVP8DecoderBlock.html
# Class NVVP8DecoderBlock
# Class NVVP8DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated VP8 video decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode VP8
video streams with minimal CPU usage. VP8 is an open-source video codec developed by Google,
commonly used in WebM containers and WebRTC video communications.
Hardware requirements: NVIDIA GPU with VP8 NVDEC support (GTX 10xx series or newer)
Supported features: All VP8 profiles, supports real-time decoding for video conferencing
Performance: Hardware acceleration enables smooth WebRTC calls and WebM playback
Use cases: WebRTC video calls, WebM video playback, YouTube content, video conferencing
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA VP8 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA VP8 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware VP8 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware with VP8 support, NVDEC capability, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA VP8 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class NVVP9DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.NVVP9DecoderBlock.html
# Class NVVP9DecoderBlock
# Class NVVP9DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
NVIDIA hardware-accelerated VP9 video decoder block using NVDEC technology.
This block leverages NVIDIA GPU hardware decoding capabilities to efficiently decode VP9
video streams with minimal CPU usage. VP9 is Google's successor to VP8, offering better
compression efficiency and supporting resolutions up to 8K, HDR content, and 10/12-bit color depths.
Hardware requirements: NVIDIA GPU with VP9 NVDEC support (GTX 10xx series or newer, some GTX 960/950)
Supported profiles: Profile 0 (8-bit 4:2:0), Profile 2 (10/12-bit 4:2:0), supports HDR10
Performance: Can decode 4K@60fps or 8K@30fps depending on GPU model, multiple streams supported
Use cases: YouTube 4K/8K playback, WebM video, streaming services, HDR content delivery
Implements thetrue if the hardware decoder was successfully initialized; false if GPU resources are unavailable.
### CleanUp()
Performs cleanup of GPU resources, releasing NVDEC hardware decoder
and freeing allocated GPU memory.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer NVDEC element for advanced GPU configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core NVIDIA VP9 hardware decoder element instance.
### GetElement()
Gets the native GStreamer NVDEC element for direct hardware manipulation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer NVIDIA VP9 decoder element.
### IsAvailable()
Determines whether NVIDIA hardware VP9 decoding is available on the current system.
This method checks for compatible NVIDIA GPU hardware with VP9 support, NVDEC capability, and required drivers.
Ensure the NVIDIA Video Codec SDK redistribution package is included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if NVIDIA VP9 hardware decoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this hardware decoder block, establishing GPU resource
management and pipeline integration.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that manages GPU resources.
## See Also
---
# Class VP8AlphaDecodeBinBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.VP8AlphaDecodeBinBlock.html
# Class VP8AlphaDecodeBinBlock
# Class VP8AlphaDecodeBinBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
VP8 alpha decode bin block that automatically decodes VP8 video streams with alpha channel.
This block handles VP8 streams encoded with alpha transparency, automatically demultiplexing
and decoding both color and alpha channels to produce RGBA video output. Essential for
WebM video with transparency, overlays, and compositing effects.
Supported features: VP8 with alpha channel in WebM/MKV containers
Use cases: Transparent video overlays, video compositing, WebM with alpha
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core VP8 alpha decode bin element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer VP8 alpha decode bin element.
### IsAvailable()
Determines whether the VP8 alpha decode bin element is available on the current system.
This method checks for the presence of the vp8alphadecodebin GStreamer element.
Ensure the appropriate GStreamer codec alpha plugin is installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the element is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Class VP8DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.VP8DecoderBlock.html
# Class VP8DecoderBlock
# Class VP8DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
VP8 video decoder block that converts compressed VP8 bitstreams into raw video frames.
This block supports multiple decoder implementations including software (VPX, FFmpeg),
hardware-accelerated (NVIDIA NVDEC, VAAPI on Linux, D3D11 on Windows), and can automatically
select the best available decoder for optimal performance. VP8 is an open-source video codec
commonly used in WebM containers and WebRTC video communications.
Supported features: All VP8 profiles, real-time video conferencing support
Performance: Hardware decoders can achieve real-time decoding for HD video calls
Use cases: WebRTC video calls, WebM video playback, YouTube content, video conferencing
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core VP8 decoder element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer VP8 decoder element.
### IsAvailable(VP8DecoderType)
Determines whether the specified VP8 decoder implementation is available on the current system.
This method checks for the presence of required libraries, drivers, and hardware support
for the requested decoder type. Ensure the appropriate NuGet SDK redistribution packages
are included in your project for the decoder types you intend to use.
```csharp
public static bool IsAvailable(VP8DecoderType decoder)
```
#### Parameters
Parameters:
- decoder (VP8DecoderType): The specific VP8 decoder type to check for availability (VPX, FFmpeg, NVDEC, VAAPI, etc.).
#### Returns
Parameters:
- (bool): true if the specified decoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Class VP9AlphaDecodeBinBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.VP9AlphaDecodeBinBlock.html
# Class VP9AlphaDecodeBinBlock
# Class VP9AlphaDecodeBinBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
VP9 alpha decode bin block that automatically decodes VP9 video streams with alpha channel.
This block handles VP9 streams encoded with alpha transparency, automatically demultiplexing
and decoding both color and alpha channels to produce RGBA video output. Essential for
WebM video with transparency, overlays, and compositing effects.
Supported features: VP9 with alpha channel in WebM/MKV containers
Use cases: Transparent video overlays, video compositing, WebM with alpha, 4K transparent video
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core VP9 alpha decode bin element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer VP9 alpha decode bin element.
### IsAvailable()
Determines whether the VP9 alpha decode bin element is available on the current system.
This method checks for the presence of the vp9alphadecodebin GStreamer element.
Ensure the appropriate GStreamer codec alpha plugin is installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the element is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Class VP9DecoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.VP9DecoderBlock.html
# Class VP9DecoderBlock
# Class VP9DecoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoDecoders
**Assembly**: VisioForge.Core.dll
VP9 video decoder block that converts compressed VP9 bitstreams into raw video frames.
This block supports multiple decoder implementations including software (VPX, FFmpeg),
hardware-accelerated (NVIDIA NVDEC, VAAPI on Linux, D3D11 on Windows), and can automatically
select the best available decoder for optimal performance. VP9 is an open-source video codec
developed by Google as the successor to VP8, offering better compression efficiency.
Supported features: All VP9 profiles including 10-bit and 12-bit color depths
Performance: Hardware decoders can achieve 4K@60fps or higher depending on GPU capabilities
Use cases: YouTube 4K/8K content, WebM video playback, modern web video streaming
Implements thetrue if the decoder was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the decoder element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core VP9 decoder element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer VP9 decoder element.
### IsAvailable(VP9DecoderType)
Determines whether the specified VP9 decoder implementation is available on the current system.
This method checks for the presence of required libraries, drivers, and hardware support
for the requested decoder type. Ensure the appropriate NuGet SDK redistribution packages
are included in your project for the decoder types you intend to use.
```csharp
public static bool IsAvailable(VP9DecoderType decoder)
```
#### Parameters
Parameters:
- decoder (VP9DecoderType): The specific VP9 decoder type to check for availability (VPX, FFmpeg, NVDEC, VAAPI, etc.).
#### Returns
Parameters:
- (bool): true if the specified decoder is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this decoder block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this decoder.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.VideoDecoders
Link: api/VisioForge.Core.MediaBlocks.VideoDecoders.html
# Namespace VisioForge.Core.MediaBlocks.VideoDecoders
# Namespace VisioForge.Core.MediaBlocks.VideoDecoders
### Classes
Parameters:
- (): AV1 video decoder block that converts compressed AV1 bitstreams into raw video frames.
This block supports multiple decoder implementations including software (dav1d, av1dec)
and hardware-accelerated (NVIDIA NVDEC, D3D11 DXVA, VAAPI on Linux) decoders.
It can automatically select the best available decoder for optimal performance.
Essential for decoding AV1 content from files, streams, and live sources in media processing pipelines.
Supported profiles: Main, High, Professional
Performance: Hardware decoders can achieve 8K@60fps or higher depending on GPU capabilities
Use cases: Video playback, transcoding, streaming, video editing, next-gen codec support
Implements theSupported profiles: Baseline, Main, High, High 10, High 4:2:2, High 4:4:4
Performance: Hardware decoders can achieve 4K@60fps or higher depending on GPU capabilities
Use cases: Video playback, transcoding, streaming, video editing, surveillance systems
Implements theSupported profiles: Main, Main 10, Main Still Picture
Performance: Hardware decoders can achieve 4K@60fps or higher depending on GPU capabilities
Use cases: Video playback, transcoding, streaming, video editing, surveillance systems
Implements theSupported formats: JPEG baseline, JPEG progressive, MJPEG streams
Performance: Software-based decoding suitable for moderate frame rates and resolutions
Use cases: IP camera streams, webcam capture, image sequence processing, MJPEG playback
Implements theHardware requirements: NVIDIA GPU with AV1 NVDEC support (RTX 30xx series or newer)
Supported profiles: Main Profile (8-bit and 10-bit 4:2:0), supports HDR10/HDR10+
Performance: Can decode 4K@120fps or 8K@60fps depending on GPU model, multiple streams supported
Use cases: Streaming services (Netflix, YouTube), next-gen video content, HDR/8K delivery
Implements theHardware requirements: NVIDIA GPU with NVDEC support (GTX 10xx series or newer, Quadro, Tesla)
Supported profiles: All profiles supported by GPU including Baseline, Main, High, High 10, High 4:2:2, High 4:4:4
Performance: Can decode multiple 4K@60fps streams simultaneously depending on GPU model
Use cases: High-performance video playback, multi-stream surveillance, real-time transcoding, video walls
Implements theHardware requirements: NVIDIA GPU with HEVC NVDEC support (GTX 960/10xx series or newer, Quadro, Tesla)
Supported profiles: Main, Main 10 (10-bit), Main 12 (12-bit), Main 4:4:4, Range Extensions
Performance: Can decode 8K@30fps or multiple 4K@60fps streams depending on GPU model
Use cases: 4K/8K video playback, HDR content, streaming services, professional video production
Implements theHardware requirements: NVIDIA GPU with compute capability 3.5 or higher
Supported formats: Baseline JPEG, Progressive JPEG, MJPEG streams
Performance: Can decode thousands of images per second depending on GPU and image size
Use cases: High-speed image processing, multi-stream surveillance, medical imaging, machine vision
Implements theHardware requirements: NVIDIA GPU with NVDEC support (most modern NVIDIA GPUs)
Supported formats: MPEG-1 Part 2 video, supports all standard frame rates and resolutions
Performance: Hardware acceleration provides efficient decoding even for older GPUs
Use cases: Legacy video archives, VCD playback, older surveillance footage, broadcast archives
Implements theHardware requirements: NVIDIA GPU with NVDEC support (most modern NVIDIA GPUs)
Supported profiles: Main Profile (MP@ML, MP@HL), 4:2:2 Profile, supports interlaced content
Performance: Hardware acceleration enables smooth playback of HD broadcast streams
Use cases: DVD playback, broadcast television, cable/satellite streams, professional video editing
Implements theHardware requirements: NVIDIA GPU with NVDEC support (most modern NVIDIA GPUs)
Supported profiles: Simple Profile, Advanced Simple Profile (ASP), supports B-frames and GMC
Performance: Hardware acceleration provides efficient decoding of SD and HD content
Use cases: Legacy video files, DivX/XviD content, older streaming formats, video archives
Implements theHardware requirements: NVIDIA GPU with VP8 NVDEC support (GTX 10xx series or newer)
Supported features: All VP8 profiles, supports real-time decoding for video conferencing
Performance: Hardware acceleration enables smooth WebRTC calls and WebM playback
Use cases: WebRTC video calls, WebM video playback, YouTube content, video conferencing
Implements theHardware requirements: NVIDIA GPU with VP9 NVDEC support (GTX 10xx series or newer, some GTX 960/950)
Supported profiles: Profile 0 (8-bit 4:2:0), Profile 2 (10/12-bit 4:2:0), supports HDR10
Performance: Can decode 4K@60fps or 8K@30fps depending on GPU model, multiple streams supported
Use cases: YouTube 4K/8K playback, WebM video, streaming services, HDR content delivery
Implements theSupported features: VP8 with alpha channel in WebM/MKV containers
Use cases: Transparent video overlays, video compositing, WebM with alpha
Implements theSupported features: All VP8 profiles, real-time video conferencing support
Performance: Hardware decoders can achieve real-time decoding for HD video calls
Use cases: WebRTC video calls, WebM video playback, YouTube content, video conferencing
Implements theSupported features: VP9 with alpha channel in WebM/MKV containers
Use cases: Transparent video overlays, video compositing, WebM with alpha, 4K transparent video
Implements theSupported features: All VP9 profiles including 10-bit and 12-bit color depths
Performance: Hardware decoders can achieve 4K@60fps or higher depending on GPU capabilities
Use cases: YouTube 4K/8K content, WebM video playback, modern web video streaming
Implements thetrue if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this AV1 encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer AV1 encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer AV1 encoder.
### GetElement()
Gets the underlying GStreamer element that performs the AV1 video encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the AV1 encoder.
### IsAvailable(IAV1EncoderSettings)
Determines whether AV1 encoding is available with the specified settings.
Checks for required codec libraries and hardware acceleration support.
```csharp
public static bool IsAvailable(IAV1EncoderSettings settings)
```
#### Parameters
Parameters:
- settings (IAV1EncoderSettings): The AV1 encoder settings to validate.
#### Returns
Parameters:
- (bool): true if AV1 encoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this AV1 encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class DVEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.DVEncoderBlock.html
# Class DVEncoderBlock
# Class DVEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
DV (Digital Video) encoder block for professional video production and broadcast applications.
This block provides DV video encoding capabilities for digital camcorder formats, offering
frame-accurate editing, professional broadcast quality, and compatibility with DV equipment.
DV encoding uses intra-frame compression at a fixed bitrate of 25 Mbps (SD-DV) providing
excellent quality for standard definition video production workflows.
Key features:
- Fixed bitrate encoding at 25 Mbps (SD) or 50/100 Mbps (HD)
- Intra-frame compression for frame-accurate editing
- 4:1:1 color sampling (NTSC) or 4:2:0 (PAL)
- Support for DV25, DVCPRO, DVCPRO50, and DVCPRO HD
- Professional broadcast quality
- FireWire (IEEE 1394) compatibility
- Timecode support for professional editing
Common use cases:
- Digital camcorder recording and playback
- Professional video editing workflows
- Broadcast television production
- Video archival in broadcast facilities
- Non-linear editing system integration
- FireWire video capture and output
While DV is considered legacy for new productions, it remains important
for compatibility with existing DV equipment, tape archives, and
professional broadcast workflows requiring frame-accurate editing.
Implements the true if the encoder was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the DV encoder.
Disposes the encoder element and releases encoding resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper for the DV encoder.
### GetElement()
Gets the underlying GStreamer DV encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing DV encoding.
### IsAvailable()
Determines whether DV encoding functionality is available on the current system.
Requires the GStreamer DV encoder plugin to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if DV encoding is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this DV encoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Class GIFEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.GIFEncoderBlock.html
# Class GIFEncoderBlock
# Class GIFEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
GIF (Graphics Interchange Format) encoder block for creating animated GIF images from video streams.
This block provides GIF encoding capabilities for generating animated images suitable for web content,
social media, documentation, and visual demonstrations. Features advanced color quantization,
dithering options, and frame optimization for efficient file sizes while maintaining visual quality.
Key features:
- 256-color palette per frame with advanced quantization
- Temporal dithering for smoother color transitions
- Frame optimization and delta encoding
- Variable frame rates and loop control
- Transparency support for overlay effects
- LZW compression for efficient file sizes
- Interlaced GIF support for progressive loading
Common use cases:
- Social media content and memes
- Product demonstrations and tutorials
- Email marketing animations
- Documentation and help files
- Web banner advertisements
- UI/UX prototypes and mockups
- Screen recordings and demos
Note: GIF format limitations include 256 colors per frame and
larger file sizes compared to modern video formats. Consider
frame rate reduction and resolution optimization for web use.
Implements the true if the encoder was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the GIF encoder.
Disposes the encoder element and file sink if present.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper for the GIF encoder.
### GetElement()
Gets the underlying GStreamer GIF encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing GIF encoding.
### GetFilenameOrURL()
Gets the current output filename where the GIF is being written.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The file path for the GIF output, or null if using stream output.
### IsAvailable()
Determines whether GIF encoding functionality is available on the current system.
Requires the GStreamer GIF encoder plugin to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if GIF encoding is supported; otherwise, false.
### SetFilenameOrURL(string)
Sets a new output filename for the GIF file.
Only applicable when using file output mode.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The new file path for GIF output.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this GIF encoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Class H264EncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.H264EncoderBlock.html
# Class H264EncoderBlock
# Class H264EncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
H.264/AVC encoder block for industry-standard video compression with broad compatibility.
This block provides comprehensive H.264 encoding capabilities with support for multiple
hardware acceleration platforms including NVIDIA NVENC, AMD AMF, Intel QSV, and Apple VideoToolbox.
Features adaptive bitrate control, multiple profile support (Baseline, Main, High), and
optimized encoding for various use cases from streaming to broadcast. Essential for universal
video compatibility across devices, platforms, and streaming services.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this H.264 encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer H.264 encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer H.264 encoder.
### GetDefaultSettings()
Gets the optimal default H.264 encoder settings based on available hardware acceleration.
Automatically selects the best available encoder: hardware-accelerated encoders are preferred
over software implementations for optimal performance.
```csharp
public static IH264EncoderSettings GetDefaultSettings()
```
#### Returns
Parameters:
- (IH264EncoderSettings): The optimal H.264 encoder settings for the current system.
### GetElement()
Gets the underlying GStreamer element that performs the H.264 video encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the H.264 encoder.
### IsAvailable(IH264EncoderSettings)
Determines whether H.264 encoding is available with the specified settings.
Checks for required codec libraries and hardware acceleration support.
```csharp
public static bool IsAvailable(IH264EncoderSettings settings)
```
#### Parameters
Parameters:
- settings (IH264EncoderSettings): The H.264 encoder settings to validate.
#### Returns
Parameters:
- (bool): true if H.264 encoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this H.264 encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class HEVCEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.HEVCEncoderBlock.html
# Class HEVCEncoderBlock
# Class HEVCEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
HEVC/H.265 encoder block for high-efficiency video compression with superior quality-to-bitrate ratio.
This block provides advanced HEVC encoding capabilities offering up to 50% better compression efficiency
compared to H.264 while maintaining equivalent visual quality. Features hardware acceleration support
via NVIDIA NVENC, AMD AMF, and Intel QSV, with advanced encoding options including HDR support,
4K/8K encoding, and sophisticated rate control algorithms. Essential for 4K content delivery,
bandwidth-constrained applications, and next-generation video streaming services.
Implements the true if successful, false otherwise.
### CleanUp()
Cleans up.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetDefaultSettings()
Gets the optimal default HEVC encoder settings based on available hardware acceleration.
Automatically selects the best available hardware encoder. Returns null if no HEVC encoder is available,
as HEVC typically requires hardware acceleration for practical performance.
```csharp
public static IHEVCEncoderSettings GetDefaultSettings()
```
#### Returns
Parameters:
- (IHEVCEncoderSettings): The optimal HEVC encoder settings for the current system, or null if unavailable.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### IsAvailable(IHEVCEncoderSettings)
Determines whether HEVC encoding is available with the specified settings.
Checks for required codec libraries and hardware acceleration support.
```csharp
public static bool IsAvailable(IHEVCEncoderSettings settings)
```
#### Parameters
Parameters:
- settings (IHEVCEncoderSettings): The HEVC encoder settings to validate.
#### Returns
Parameters:
- (bool): true if HEVC encoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class MJPEGEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.MJPEGEncoderBlock.html
# Class MJPEGEncoderBlock
# Class MJPEGEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
Motion JPEG (MJPEG) encoder block for creating frame-by-frame compressed video streams.
This block provides MJPEG encoding capabilities where each video frame is independently
compressed as a JPEG image, offering frame-accurate editing, low latency streaming,
and simplified decoding. Features optional callback mode for real-time frame capture
and analysis without requiring downstream processing.
Key features:
- Independent frame compression (no inter-frame dependencies)
- Variable JPEG quality control (0-100)
- Frame-accurate editing capability
- Low latency encoding and decoding
- Optional callback mode for frame capture
- Hardware acceleration support
- Wide compatibility across platforms
Common use cases:
- IP camera streaming (security/surveillance)
- Video editing and post-production
- Medical imaging systems
- Machine vision applications
- Real-time frame analysis
- Network video recording (NVR)
- Digital signage systems
While MJPEG requires more bandwidth than inter-frame codecs,
it excels in applications requiring frame independence,
editing flexibility, and processing simplicity.
Implements the true if the encoder was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the MJPEG encoder.
Disposes the encoder element and callback components if present.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper for the MJPEG encoder.
### GetElement()
Gets the underlying GStreamer MJPEG encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing MJPEG encoding.
### IsAvailable(IMJPEGEncoderSettings)
Determines whether MJPEG encoding functionality is available on the current system.
Checks for required encoder plugins and hardware acceleration support.
```csharp
public static bool IsAvailable(IMJPEGEncoderSettings settings)
```
#### Parameters
Parameters:
- settings (IMJPEGEncoderSettings): The MJPEG encoder settings to validate for availability.
#### Returns
Parameters:
- (bool): true if MJPEG encoding with specified settings is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this MJPEG encoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
### OnJPEGFrame
Occurs when a JPEG frame is encoded in callback mode.
Provides access to individual JPEG images for real-time processing or analysis.
```csharp
public event EventHandlertrue if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this MPEG-2 encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer MPEG-2 encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer MPEG-2 encoder.
### GetElement()
Gets the underlying GStreamer element that performs the MPEG-2 video encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the MPEG-2 encoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this MPEG-2 encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MPEG4EncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.MPEG4EncoderBlock.html
# Class MPEG4EncoderBlock
# Class MPEG4EncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
MPEG-4 video encoder block for efficient video compression with advanced features and scalability.
This block provides MPEG-4 Part 2 encoding capabilities offering improved compression efficiency
compared to MPEG-2 with support for advanced features like object-based coding, scalability,
and error resilience. Features configurable quality settings, motion estimation algorithms,
and rate control modes. Essential for streaming applications, mobile video, and scenarios
requiring flexible video compression with moderate bandwidth requirements.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this MPEG-4 encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer MPEG-4 encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer MPEG-4 encoder.
### GetElement()
Gets the underlying GStreamer element that performs the MPEG-4 video encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the MPEG-4 encoder.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this MPEG-4 encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class PNGEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.PNGEncoderBlock.html
# Class PNGEncoderBlock
# Class PNGEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
PNG encoder block for efficient PNG image compression with high quality and advanced features.
This block provides PNG encoding capabilities using the rspngenc (Rust PNG encoder) GStreamer element
offering superior compression efficiency and performance compared to traditional PNG encoders.
Features configurable compression levels, filter types, and metadata handling.
Key features:
- Rust-based implementation for optimal performance
- Configurable compression levels (0-9)
- Multiple filter types for optimal compression
- PNG metadata and info chunk handling
- Lossless compression maintaining image quality
- Support for transparency and alpha channels
- Efficient memory usage and processing
Common use cases:
- High-quality image archival and storage
- Lossless video frame extraction
- Scientific and medical image processing
- Web content requiring transparency
- Screenshot and screen capture applications
- Digital photography workflows
- Document scanning and processing
The PNG format provides excellent compression for images with sharp edges,
text, and areas of solid color while preserving perfect image quality.
Consider JPEG for photographic content where slight quality loss is acceptable.
Implements the true if the encoder was successfully built; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this PNG encoder block.
This method disposes of GStreamer elements, releases memory, and ensures proper
shutdown of the block. Called automatically during pipeline teardown.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases all resources used by the PNG encoder block.
This includes disposing of GStreamer elements and clearing internal references.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): True if disposing managed resources; false if called from finalizer.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper for the PNG encoder.
### GetElement()
Gets the underlying GStreamer PNG encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing PNG encoding.
### GetFilenameOrURL()
Gets the output destination filename or URL where the media data will be written.
This could be a local file path, network URL, or device identifier depending on the sink type.
```csharp
public string GetFilenameOrURL()
```
#### Returns
Parameters:
- (string): The filename, URL, or destination identifier as a string.
### IsAvailable()
Checks if the PNG encoder element is available in the current GStreamer installation.
This method verifies that the rspngenc element can be found and instantiated.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the PNG encoder is available and can be used; otherwise, false.
### SetContext(MediaBlocksPipeline)
Associates this PNG encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
public void SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### SetFilenameOrURL(string)
Sets the output destination filename or URL where the media data should be written.
This configures where the sink block will send its processed media data.
```csharp
public void SetFilenameOrURL(string value)
```
#### Parameters
Parameters:
- value (string): The filename, URL, or destination identifier to set.
### SetPipelineContext(BlockPipelineContext)
Sets the media pipeline context for this PNG encoder block.
```csharp
public void SetPipelineContext(BlockPipelineContext ctx)
```
#### Parameters
Parameters:
- ctx (BlockPipelineContext): The pipeline context.
### SyncStateWithParent()
Synchronizes the state of all internal GStreamer elements with their parent pipeline.
This ensures proper state transitions during pipeline start, pause, and stop operations.
```csharp
public void SyncStateWithParent()
```
### UpdateFilename(string)
Updates the output filename for the PNG encoder.
This method allows changing the output destination during operation,
though it requires pipeline restart to take effect.
```csharp
public void UpdateFilename(string filename)
```
#### Parameters
Parameters:
- filename (string): The new output filename for PNG data.
## See Also
---
# Class TheoraEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.TheoraEncoderBlock.html
# Class TheoraEncoderBlock
# Class TheoraEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
Theora encoder block for open-source video compression designed for web streaming and multimedia applications.
This block provides Theora video encoding capabilities, part of the Xiph.Org Foundation's patent-free multimedia
suite. Theora offers competitive compression efficiency with royalty-free licensing, making it ideal for
open-source projects, educational content, and applications requiring unrestricted codec usage.
Key features:
- Patent-free and royalty-free compression
- Variable bitrate (VBR) and constant bitrate (CBR) modes
- Temporal and spatial scalability
- Alpha channel support for transparency
- Adaptive quantization for optimal quality
- Two-pass encoding for efficiency
- Web-friendly streaming capabilities
Common use cases:
- Open-source video platforms and applications
- Educational and academic content distribution
- Web-based video streaming (OGV format)
- Embedded systems with licensing constraints
- Non-commercial video applications
- HTML5 video with OGG container
- Cross-platform multimedia solutions
While newer codecs like VP8/VP9 and AV1 have largely superseded Theora
for new applications, it remains valuable for legacy compatibility and
environments where patent-free codecs are required.
Implements the true if the encoder was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the Theora encoder.
Disposes the encoder element and releases compression resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper for the Theora encoder.
### GetElement()
Gets the underlying GStreamer Theora encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing Theora encoding.
### IsAvailable()
Determines whether Theora encoding functionality is available on the current system.
Requires the GStreamer Theora encoder plugin to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if Theora encoding is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this Theora encoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Class VPXEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.VPXEncoderBlock.html
# Class VPXEncoderBlock
# Class VPXEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
VPX encoder block for VP8/VP9 open-source video compression optimized for web streaming.
This block provides comprehensive VP8 and VP9 encoding capabilities using Google's WebM codec family.
VP9 offers significantly improved compression efficiency over VP8 and comparable quality to H.265
while remaining royalty-free. Features adaptive bitrate control, temporal layering, and optimized
encoding for web delivery. Essential for YouTube, WebRTC, streaming platforms, and applications
requiring high-quality, royalty-free video compression for web distribution.
Implements the true if the encoder was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this VPX encoder block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer VPX encoder element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer VPX encoder.
### GetElement()
Gets the underlying GStreamer element that performs the VP8/VP9 video encoding.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the VPX encoder.
### IsAvailable(IVPXEncoderSettings)
Determines whether VPX encoding is available with the specified settings.
Checks for required VP8/VP9 codec libraries and validates codec selection.
```csharp
public static bool IsAvailable(IVPXEncoderSettings settings)
```
#### Parameters
Parameters:
- settings (IVPXEncoderSettings): The VPX encoder settings to validate.
#### Returns
Parameters:
- (bool): true if VPX encoding is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this VPX encoder block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class WMVEncoderBlock
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.WMVEncoderBlock.html
# Class WMVEncoderBlock
# Class WMVEncoderBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoEncoders
**Assembly**: VisioForge.Core.dll
WMV (Windows Media Video) encoder block for Microsoft's proprietary video compression standard.
This block provides WMV encoding capabilities using the VC-1 codec, offering excellent compression
efficiency and quality optimized for Windows platforms and Microsoft ecosystem applications.
Features advanced rate control, multiple encoding profiles, and seamless integration with
Windows Media Player and Microsoft streaming technologies.
Key features:
- VC-1 codec compression with multiple profiles (Simple, Main, Advanced)
- Variable bitrate (VBR) and constant bitrate (CBR) encoding modes
- Advanced rate control algorithms
- Support for HD content up to 1080p
- Temporal and spatial scalability
- B-frame encoding for improved compression
- Windows Media DRM integration capability
Common use cases:
- Windows Media Player content distribution
- Microsoft Silverlight streaming applications
- Corporate video delivery on Windows networks
- Xbox and Windows device playback
- Legacy Windows media workflows
- ASF container video content
- Microsoft streaming services integration
While WMV has been largely superseded by newer standards like H.264 and H.265,
it remains important for Windows-specific applications and legacy system
compatibility where Microsoft codec support is guaranteed.
Implements the true if the encoder was successfully built; false if initialization failed.
### CleanUp()
Performs cleanup of all resources associated with the WMV encoder.
Disposes the encoder element and releases compression resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapper for advanced configuration.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper for the WMV encoder.
### GetDefaultSettings()
Gets the default WMV encoder settings with standard quality parameters.
Provides a baseline configuration suitable for general-purpose Windows Media video encoding.
```csharp
public static WMVEncoderSettings GetDefaultSettings()
```
#### Returns
Parameters:
- (WMVEncoderSettings): A WMVEncoderSettings instance with default quality and bitrate settings.
### GetElement()
Gets the underlying GStreamer WMV encoder element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The native GStreamer element performing WMV encoding.
### IsAvailable()
Determines whether WMV encoding functionality is available on the current system.
Requires the GStreamer WMV encoder plugin to be installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if WMV encoding is supported; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the media pipeline context for this WMV encoder block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent media pipeline containing this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.VideoEncoders
Link: api/VisioForge.Core.MediaBlocks.VideoEncoders.html
# Namespace VisioForge.Core.MediaBlocks.VideoEncoders
# Namespace VisioForge.Core.MediaBlocks.VideoEncoders
### Classes
Parameters:
- (): AV1 encoder block for next-generation video compression with superior efficiency and quality.
This block provides advanced AV1 (AOMedia Video 1) encoding capabilities offering up to 50% better
compression efficiency compared to H.264 while maintaining equivalent visual quality. Features
hardware acceleration support, adaptive bitrate control, and advanced psychovisual optimization.
Essential for streaming services, video delivery platforms, and applications requiring optimal
bandwidth utilization with future-proof codec technology.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this aging effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer aging filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer aging filter.
### GetElement()
Gets the underlying GStreamer element that performs the aging effect processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the aging filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this aging effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class AlphaCombineBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.AlphaCombineBlock.html
# Class AlphaCombineBlock
# Class AlphaCombineBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Alpha combine block that merges a video stream with a separate alpha channel stream
into a single video stream with transparency information. This block takes two input streams
(one for RGB/YUV color data and one for alpha channel) and combines them into RGBA/YUVA output.
Essential for compositing separate color and alpha streams into transparent video.
Supported features: Combining separate color and alpha streams into RGBA/YUVA
Use cases: Video compositing, merging decoded color and alpha streams, custom alpha processing
Implements thetrue if the block was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core alpha combine element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer alpha combine element.
### IsAvailable()
Determines whether the alpha combine element is available on the current system.
This method checks for the presence of the alphacombine GStreamer element.
Ensure the appropriate GStreamer codec alpha plugin is installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the element is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class AutoDeinterlaceBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.AutoDeinterlaceBlock.html
# Class AutoDeinterlaceBlock
# Class AutoDeinterlaceBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Automatic deinterlacing video processing block that intelligently removes interlacing artifacts.
This block automatically detects interlaced video content and applies appropriate deinterlacing
algorithms to convert it to progressive format. Features adaptive field detection, motion analysis,
and multiple deinterlacing methods including linear, blend, and edge-directed interpolation.
Essential for processing broadcast video, DVD content, and legacy interlaced sources to ensure
smooth playback on modern progressive displays without visual artifacts or field tearing.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this automatic deinterlace block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer automatic deinterlace filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer automatic deinterlace filter.
### GetElement()
Gets the underlying GStreamer element that performs the automatic deinterlacing processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the automatic deinterlace filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this automatic deinterlace block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class Bayer2RGBBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.Bayer2RGBBlock.html
# Class Bayer2RGBBlock
# Class Bayer2RGBBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that converts Bayer pattern raw images to RGB format.
This block performs demosaicing of Bayer pattern images commonly used in
digital cameras and image sensors. Bayer filters arrange color filters in
a specific pattern (RGGB, BGGR, GRBG, or GBRG) over the image sensor pixels.
This block reconstructs full RGB color images from the raw Bayer data.
Commonly used when working with raw camera data or specialized image sensors.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Bayer to RGB conversion block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Bayer to RGB conversion filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Bayer to RGB filter.
### GetElement()
Gets the underlying GStreamer element that performs the Bayer to RGB conversion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Bayer to RGB filter.
### IsAvailable()
Determines whether the Bayer to RGB conversion filter is available on the current system.
This checks if the required GStreamer bayer plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the Bayer to RGB conversion filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Bayer to RGB conversion block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CascadeFaceDetectorBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.CascadeFaceDetectorBlock.html
# Class CascadeFaceDetectorBlock
# Class CascadeFaceDetectorBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.CV.dll
A media block that integrates the Cascade Face Detector into a video processing pipeline.
```csharp
public class CascadeFaceDetectorBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
This block intercepts video frames, processes them using the true if the build was successful; otherwise, false.
### CleanUp()
Releases resources and cleans up the underlying GStreamer element.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Retrieves the underlying GStreamer BaseElement used by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this chroma key block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer chroma key filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer chroma key filter.
### GetElement()
Gets the underlying GStreamer element that performs the chroma key compositing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the chroma key filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetAlpha(double)
Sets the alpha channel transparency value for the composited result.
Controls the overall opacity of the keyed foreground when composited onto the background.
```csharp
public void SetAlpha(double alpha)
```
#### Parameters
Parameters:
- alpha (double): The alpha transparency value (0.0 = fully transparent, 1.0 = fully opaque).
### SetBlackSensitivity(uint)
Sets the black level sensitivity for edge refinement in chroma keying.
Controls how dark pixels near the key color edges are processed, helping to
remove dark fringes and improve edge quality in shadowed areas.
```csharp
public void SetBlackSensitivity(uint blackSensitivity)
```
#### Parameters
Parameters:
- blackSensitivity (uint): The black sensitivity threshold (0 = no dark edge processing, 255 = maximum dark edge removal).
### SetChromaColor(ChromaKeyColor)
Sets the chroma color to be removed from the foreground video.
Updates the target color for the keying operation, allowing switching between
common chroma colors like green, blue, or custom color selections.
```csharp
public void SetChromaColor(ChromaKeyColor color)
```
#### Parameters
Parameters:
- color (ChromaKeyColor): The chroma color preset to key out from the foreground video.
### SetCustomColor(SKColor)
Sets a custom color for chroma keying when using the Custom color option.
Allows precise specification of any RGB color value as the key color, useful for
non-standard backgrounds or specific color matching requirements.
```csharp
public void SetCustomColor(SKColor customColor)
```
#### Parameters
Parameters:
- customColor (SKColor): The custom RGB color to remove from the foreground video.
### SetEdgeSmoothing(double)
Sets the edge smoothing level for chroma keying (deprecated method).
This method provides backward compatibility but offers less precise control than
the separate black and white sensitivity settings.
```csharp
[Obsolete("Use SetBlackSensitivity and SetWhiteSensitivity instead for more precise control.")]
public void SetEdgeSmoothing(double edgeSmoothing)
```
#### Parameters
Parameters:
- edgeSmoothing (double): The edge smoothing intensity (0.0 = no smoothing, 1.0 = maximum smoothing).
### SetNoiseLevel(double)
Sets the noise reduction level for chroma key edge refinement.
Helps clean up rough edges and reduce artifacts caused by compression or sensor noise
in the source video, creating smoother keying results.
```csharp
public void SetNoiseLevel(double noiseLevel)
```
#### Parameters
Parameters:
- noiseLevel (double): The noise reduction intensity (0.0 = no noise reduction, 64.0 = maximum smoothing).
### SetPreferPassthrough(bool)
Sets the prefer passthrough optimization flag for performance enhancement.
When enabled, the filter will pass video through unchanged when the effect is
effectively disabled, reducing processing overhead in bypass scenarios.
```csharp
public void SetPreferPassthrough(bool preferPassthrough)
```
#### Parameters
Parameters:
- preferPassthrough (bool): Whether to enable passthrough optimization for better performance.
### SetSensitivity(double)
Sets the sensitivity threshold for chroma key color detection.
Higher values increase the range of colors considered similar to the key color,
useful for handling uneven lighting or color variations in the background.
```csharp
public void SetSensitivity(double sensitivity)
```
#### Parameters
Parameters:
- sensitivity (double): The sensitivity value in degrees (0.0 = exact match only, 180.0 = maximum tolerance).
### SetWhiteSensitivity(uint)
Sets the white level sensitivity for edge refinement in chroma keying.
Controls how bright pixels near the key color edges are processed, helping to
remove light halos and improve edge quality in highly lit areas.
```csharp
public void SetWhiteSensitivity(uint whiteSensitivity)
```
#### Parameters
Parameters:
- whiteSensitivity (uint): The white sensitivity threshold (0 = no bright edge processing, 255 = maximum bright edge removal).
### UpdateSettings(ChromaKeySettingsX)
Updates the chroma key settings dynamically during runtime.
Allows real-time adjustment of all chroma key parameters including color selection,
sensitivity, edge refinement, and compositing quality without rebuilding the pipeline.
```csharp
public void UpdateSettings(ChromaKeySettingsX settings)
```
#### Parameters
Parameters:
- settings (ChromaKeySettingsX): The new chroma key configuration settings to apply.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this chroma key block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class CodecAlphaDemuxBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.CodecAlphaDemuxBlock.html
# Class CodecAlphaDemuxBlock
# Class CodecAlphaDemuxBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Codec alpha demultiplexer block that separates VP8/VP9 encoded streams with alpha channel
into two separate streams: one containing color data and one containing alpha channel data.
This block is used to extract and separate the alpha channel from encoded VP8/VP9 streams
for independent processing or decoding.
Supported features: VP8/VP9 alpha demuxing from WebM/MKV containers
Use cases: Custom alpha processing, separate color/alpha decoding pipelines
Implements thetrue if the block was successfully built and initialized; false if an error occurred.
### CleanUp()
Performs cleanup of internal resources, disposing of the element
and resetting the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the underlying GStreamer element for advanced configuration and control.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The core codec alpha demux element instance.
### GetElement()
Gets the native GStreamer element for direct manipulation and advanced use cases.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The underlying GStreamer codec alpha demux element.
### IsAvailable()
Determines whether the codec alpha demux element is available on the current system.
This method checks for the presence of the codecalphademux GStreamer element.
Ensure the appropriate GStreamer codec alpha plugin is installed.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the element is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this block, establishing the connection
to the parent pipeline and enabling access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The parent MediaBlocksPipeline that contains this block.
## See Also
---
# Class ColorEffectsBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.ColorEffectsBlock.html
# Class ColorEffectsBlock
# Class ColorEffectsBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Color effects block providing preset-based color manipulation and artistic filtering.
This block applies predefined color effects and artistic filters to video content including
color temperature adjustments, saturation changes, hue shifts, contrast enhancement, and
creative color grading presets. Features various built-in presets for common color effects
such as sepia, black and white, vintage, high contrast, and cinematic color grading.
Essential for video post-production, creative content creation, broadcast enhancement,
and artistic video filtering applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this color effects block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer color effects filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer color effects filter.
### GetElement()
Gets the underlying GStreamer element that performs the color effects processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the color effects filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this color effects block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class DeinterlaceBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.DeinterlaceBlock.html
# Class DeinterlaceBlock
# Class DeinterlaceBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Deinterlace block for converting interlaced video content to progressive format.
This block removes interlacing artifacts from video content captured or transmitted in interlaced format
by applying sophisticated deinterlacing algorithms. Features multiple deinterlacing methods including
field blending, edge-adaptive interpolation, motion-adaptive processing, and temporal filtering.
Essential for processing legacy broadcast content, security camera feeds, and older video formats
to create smooth progressive video suitable for modern displays and streaming applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this deinterlace block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer deinterlace filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer deinterlace filter.
### GetElement()
Gets the underlying GStreamer element that performs the deinterlacing processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the deinterlace filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this deinterlace block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class DiceBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.DiceBlock.html
# Class DiceBlock
# Class DiceBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Dice video effect block that creates a fragmented mosaic appearance by dividing video into rotated squares.
This block applies a unique visual effect that segments the video into many small square tiles, each randomly
rotated in 90-degree increments (0°, 90°, 180°, or 270°). Creates an artistic fragmented appearance
with configurable tile size and rotation parameters. Essential for creative video production, artistic filters,
music videos, and experimental visual effects requiring geometric fragmentation and tile-based distortion.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this dice effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer dice filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer dice filter.
### GetElement()
Gets the underlying GStreamer element that performs the dice fragmentation processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the dice filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this dice effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class DNNFaceDetectorBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.DNNFaceDetectorBlock.html
# Class DNNFaceDetectorBlock
# Class DNNFaceDetectorBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.CV.dll
A media block that integrates the DNN Face Detector into a video processing pipeline.
```csharp
public class DNNFaceDetectorBlock : MediaBlock, IMediaBlock, IDisposable, IMediaBlockInternals
```
#### Inheritance
#### Implements
#### Inherited Members
## Remarks
This block intercepts video frames, processes them using the true if successfull, false otherwise.
### CleanUp()
Cleans up.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
### OnFaceDetected
Event raised when a face is detected in the processed video stream.
```csharp
public event EventHandlertrue if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this edge detection block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer edge filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer edge filter.
### GetElement()
Gets the underlying GStreamer element that performs the edge detection processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the edge filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this edge detection block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class FaceDetectorBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.FaceDetectorBlock.html
# Class FaceDetectorBlock
# Class FaceDetectorBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.CVD.dll
Face detector block.
Implements the true if successfull, false otherwise.
### CleanUp()
Cleans up internal resources, specifically the GStreamer element.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core GStreamer element wrapped by this block.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the GStreamer element instance.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this block.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
### OnFaceDetected
Event raised when one or more faces are detected in a video frame.
```csharp
public event EventHandlertrue if successful, false otherwise.
### CleanUp()
Releases all internal resources and disposes of the fish-eye filter element.
Called during disposal to ensure proper cleanup of native resources.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper for the fish-eye filter.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The FishEyeFilter element that performs the video distortion.
### GetElement()
Gets the underlying GStreamer element for this fish-eye block.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer element that performs the fish-eye distortion.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the pipeline context for this block, providing access to shared resources.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline that owns this block.
## See Also
---
# Class FlipRotateBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.FlipRotateBlock.html
# Class FlipRotateBlock
# Class FlipRotateBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that applies geometric transformations to video including flipping and rotation operations.
This block provides horizontal flip, vertical flip, and rotation capabilities (90°, 180°, 270°)
commonly used for correcting camera orientation, creating mirror effects, or adjusting video
captured from mobile devices. The transformations are performed efficiently without quality loss.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this flip/rotate transformation block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer flip/rotate filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer flip/rotate filter.
### GetElement()
Gets the underlying GStreamer element that performs the flip/rotate transformations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the flip/rotate filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this flip/rotate transformation block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GammaBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.GammaBlock.html
# Class GammaBlock
# Class GammaBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that applies gamma correction to video, adjusting the luminance and overall brightness.
Gamma correction is essential for color management and display calibration, compensating for
the non-linear response of display devices. Values less than 1.0 brighten the image, while
values greater than 1.0 darken it. This effect is commonly used for HDR processing, color
grading, and ensuring consistent appearance across different displays and devices.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this gamma correction block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer gamma filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer gamma filter.
### GetElement()
Gets the underlying GStreamer element that performs the gamma correction.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the gamma filter.
### IsAvailable()
Determines whether the gamma correction filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the gamma correction filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this gamma correction block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GaussianBlurBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.GaussianBlurBlock.html
# Class GaussianBlurBlock
# Class GaussianBlurBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that applies Gaussian blur or sharpening effects to video.
Gaussian blur is a widely used image processing technique that reduces noise and detail
by averaging neighboring pixels using a Gaussian distribution. Positive sigma values
create blur effects, while negative values create sharpening effects. This filter is
commonly used for creating artistic blur effects, privacy masking, or image enhancement.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Gaussian blur block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer Gaussian blur filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer Gaussian blur filter.
### GetElement()
Gets the underlying GStreamer element that performs the Gaussian blur or sharpening processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Gaussian blur filter.
### IsAvailable()
Determines whether the Gaussian blur filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the Gaussian blur filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Gaussian blur block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class GrayscaleBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.GrayscaleBlock.html
# Class GrayscaleBlock
# Class GrayscaleBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that converts color video to grayscale (black and white) output.
This effect removes color information while preserving luminance values, creating
a monochrome representation of the input video. Commonly used for artistic effects,
reducing bandwidth requirements, or creating vintage-style video content.
The conversion maintains proper brightness levels by using luminance weighting.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this grayscale block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer grayscale filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer grayscale filter.
### GetElement()
Gets the underlying GStreamer element that performs the grayscale conversion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the grayscale filter.
### IsAvailable()
Determines whether the grayscale filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the grayscale filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this grayscale block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ImageOverlayBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.ImageOverlayBlock.html
# Class ImageOverlayBlock
# Class ImageOverlayBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that overlays static images onto video streams with positioning, scaling, and transparency control.
This block composites image files (PNG, JPEG, BMP, etc.) over video content, supporting features like
alpha blending, custom positioning, rotation, scaling, and fade effects. Commonly used for watermarks,
logos, brand overlays, lower thirds, and creative graphic elements in video production workflows.
The overlay supports real-time updates and animation effects including fade-in and fade-out transitions.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this image overlay block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer image overlay filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer image overlay filter.
### GetElement()
Gets the underlying GStreamer element that performs the image overlay processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the image overlay filter.
### IsAvailable()
Determines whether the image overlay filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the image overlay filter is available and can be used; otherwise, false.
### StartFadeIn(TimeSpan)
Initiates a smooth fade-in transition that gradually increases the overlay opacity from zero to full visibility.
This creates a professional appear effect commonly used for introducing graphics or watermarks.
```csharp
public void StartFadeIn(TimeSpan duration)
```
#### Parameters
Parameters:
- duration (TimeSpan): The duration of the fade-in transition. Must be a positive TimeSpan value.
### StartFadeOut(TimeSpan)
Initiates a smooth fade-out transition that gradually reduces the overlay opacity to zero.
This creates a professional dissolve effect commonly used in broadcast and video production.
```csharp
public void StartFadeOut(TimeSpan duration)
```
#### Parameters
Parameters:
- duration (TimeSpan): The duration of the fade-out transition. Must be a positive TimeSpan value.
### Update()
Updates the overlay settings in real-time while the pipeline is running.
Call this method after modifying the Settings property to apply changes immediately.
This allows dynamic repositioning, scaling, or changing overlay properties during playback.
```csharp
public void Update()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this image overlay block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class ImageOverlayCairoBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.ImageOverlayCairoBlock.html
# Class ImageOverlayCairoBlock
# Class ImageOverlayCairoBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that overlays static images onto video streams using Cairo rendering with positioning, scaling, and transparency control.
This block composites image files (PNG, JPEG, BMP, etc.) over video content using the Cairo graphics library,
supporting features like alpha blending, custom positioning, rotation, scaling, and fade effects.
Commonly used for watermarks, logos, brand overlays, lower thirds, and creative graphic elements in video production workflows.
The overlay supports real-time updates and animation effects including fade-in and fade-out transitions.
This Cairo-based implementation provides high-quality rendering and better cross-platform compatibility.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this Cairo image overlay block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the Cairo-based image overlay filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the Cairo image overlay filter.
### GetElement()
Gets the underlying GStreamer element that performs the Cairo-based image overlay processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the Cairo overlay filter.
### IsAvailable()
Determines whether the Cairo-based image overlay filter is available on the current system.
This checks if the required GStreamer Cairo overlay plugin is installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the Cairo image overlay filter is available and can be used; otherwise, false.
### SetAlpha(double)
Sets the alpha (transparency) value of the overlay directly.
This provides immediate control over the overlay opacity without animation.
```csharp
public void SetAlpha(double alpha)
```
#### Parameters
Parameters:
- alpha (double): The alpha value between 0.0 (fully transparent) and 1.0 (fully opaque).
### StartFadeIn(TimeSpan)
Initiates a smooth fade-in transition that gradually increases the overlay opacity from zero to full visibility.
This creates a professional appear effect commonly used for introducing graphics or watermarks.
```csharp
public void StartFadeIn(TimeSpan duration)
```
#### Parameters
Parameters:
- duration (TimeSpan): The duration of the fade-in transition. Must be a positive TimeSpan value.
### StartFadeOut(TimeSpan)
Initiates a smooth fade-out transition that gradually reduces the overlay opacity to zero.
This creates a professional dissolve effect commonly used in broadcast and video production.
```csharp
public void StartFadeOut(TimeSpan duration)
```
#### Parameters
Parameters:
- duration (TimeSpan): The duration of the fade-out transition. Must be a positive TimeSpan value.
### Update()
Updates the overlay settings in real-time while the pipeline is running.
Call this method after modifying the Settings property to apply changes immediately.
This allows dynamic repositioning, scaling, or changing overlay properties during playback.
```csharp
public void Update()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this Cairo image overlay block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class InterlaceBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.InterlaceBlock.html
# Class InterlaceBlock
# Class InterlaceBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Interlace block for converting progressive video content to interlaced format.
This block applies interlacing effects to progressive video content by combining alternating
scan lines to create traditional broadcast-compatible interlaced video. Features configurable
field order, pattern selection, and temporal processing for creating authentic interlaced output.
Essential for broadcast delivery, legacy system compatibility, and creating specific visual effects
that require interlaced video characteristics for technical or artistic purposes.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this interlace block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer interlace filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer interlace filter.
### GetElement()
Gets the underlying GStreamer element that performs the interlacing processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the interlace filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this interlace block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class KeyFrameDetectorBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.KeyFrameDetectorBlock.html
# Class KeyFrameDetectorBlock
# Class KeyFrameDetectorBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Key frame detector block for automatic identification and analysis of significant video frames.
This block analyzes video content to detect key frames (I-frames) and scene changes using
advanced computer vision algorithms. Features real-time detection, configurable sensitivity,
JSON export functionality, and event-driven notifications for each detected key frame.
Essential for video indexing, thumbnail generation, scene analysis, content summarization,
and automated video editing applications requiring frame-level precision.
Implements the true if the detector was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this key frame detector block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper. Note: This detector returns null as it
operates differently from standard filter elements.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): Always returns null for this detector type.
### GetElement()
Gets the underlying GStreamer element that performs the key frame detection.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the key frame detector.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this key frame detector block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### OnKeyFrameDetected
This event occurs whenever a new key frame is detected in the video stream.
Provides real-time notification with precise timestamp information for immediate
processing or UI updates during key frame analysis.
```csharp
public event EventHandlertrue if the processor was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this LUT processor block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the LUT processor element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the LUT processor.
### GetElement()
Gets the underlying GStreamer element that performs the LUT color transformation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the LUT processor.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this LUT processor block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MirrorBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.MirrorBlock.html
# Class MirrorBlock
# Class MirrorBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video mirror effect block that creates reflective and symmetrical visual effects.
This block applies various mirroring transformations to video content including horizontal flipping,
vertical flipping, and combinations for creating symmetrical patterns and kaleidoscope-like effects.
Features multiple mirror modes for different artistic and practical applications including left-right
mirroring, top-bottom mirroring, and quad-mirroring. Essential for creative video production,
artistic filters, webcam applications, and visual effects requiring symmetrical transformations.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this mirror effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer mirror filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer mirror filter.
### GetElement()
Gets the underlying GStreamer element that performs the mirror effect processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the mirror filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this mirror effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MovingBlurBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.MovingBlurBlock.html
# Class MovingBlurBlock
# Class MovingBlurBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Moving blur effect block that creates motion-sensitive blur based on frame differences.
This block analyzes temporal changes between consecutive frames to detect motion areas
and applies selective blur effects to moving objects while preserving static elements.
Features configurable motion sensitivity, blur intensity, and temporal filtering for
creating dynamic visual effects. Essential for artistic video production, motion emphasis,
background isolation, and creative effects requiring motion-aware processing.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this moving blur effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer moving blur filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer moving blur filter.
### GetElement()
Gets the underlying GStreamer element that performs the motion-sensitive blur processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the moving blur filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this moving blur effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MovingEchoBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.MovingEchoBlock.html
# Class MovingEchoBlock
# Class MovingEchoBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Moving echo effect block that creates ghosting trails and echo images of moving objects.
This block analyzes motion between frames to detect moving elements and generates visual echo trails
that follow the movement path. Features configurable echo intensity, trail length, and fade parameters
for creating dynamic motion-tracking visual effects. Essential for artistic video production,
motion visualization, sports analysis, and creative effects requiring motion trail emphasis.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this moving echo effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer moving echo filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer moving echo filter.
### GetElement()
Gets the underlying GStreamer element that performs the motion echo trail processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the moving echo filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this moving echo effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class MovingZoomEchoBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.MovingZoomEchoBlock.html
# Class MovingZoomEchoBlock
# Class MovingZoomEchoBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Moving-zoom echo effect block that creates dynamic echo trails with animated transformations.
This block generates multiple echo images with configurable scaling, rotation, and movement patterns,
creating psychedelic and motion-based visual effects. Features include adjustable echo count,
zoom factors, rotation speeds, and movement trajectories for creating complex visual feedback loops.
Essential for music videos, creative transitions, artistic effects, and experimental video production
requiring dynamic multi-layered echo patterns with animated transformations.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this moving-zoom echo block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer moving-zoom echo filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer moving-zoom echo filter.
### GetElement()
Gets the underlying GStreamer element that performs the moving-zoom echo effect.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the moving-zoom echo filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this moving-zoom echo block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class OpticalAnimationBWBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.OpticalAnimationBWBlock.html
# Class OpticalAnimationBWBlock
# Class OpticalAnimationBWBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Black and white optical animation effect block that creates retro optical art patterns.
This block generates animated black and white optical illusion effects reminiscent of classic
op-art and psychedelic animations. Features include pattern generation, motion dynamics,
contrast controls, and temporal variations for creating hypnotic visual effects.
Essential for artistic video production, retro-style animations, music visualizations,
and experimental content requiring animated optical illusion patterns.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this optical animation block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer optical animation filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer optical animation filter.
### GetElement()
Gets the underlying GStreamer element that performs the optical animation effect.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the optical animation filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this optical animation block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class OverlayManagerBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.OverlayManagerBlock.html
# Class OverlayManagerBlock
# Class OverlayManagerBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Overlay manager block for dynamic multi-layer video overlay composition and management.
This block provides a centralized system for managing multiple overlay elements on video content,
supporting various overlay types including images, text, shapes, and animated graphics.
Features include layer ordering, opacity control, positioning, blending modes, and real-time
overlay updates. Essential for broadcast graphics, live production, watermarking, subtitles,
and any application requiring dynamic overlay composition with runtime management capabilities.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this overlay manager block.
This method resets the build state but does not dispose of the GStreamer elements.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer overlay manager filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer overlay manager filter.
### GetElement()
Gets the underlying GStreamer element that performs the overlay management.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the overlay manager filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### Video_Overlay_Add(IOverlayManagerElement)
Adds a new overlay element to the video composition.
The overlay will be rendered on top of the video content according to its properties.
```csharp
public void Video_Overlay_Add(IOverlayManagerElement overlay)
```
#### Parameters
Parameters:
- overlay (IOverlayManagerElement): The overlay element to add to the composition.
### Video_Overlay_AddBackground(string, string)
Adds a background image that fills the entire frame.
The image is drawn behind all other overlays (ZIndex = -1000).
```csharp
public OverlayManagerImage Video_Overlay_AddBackground(string filename, string name = "Background")
```
#### Parameters
Parameters:
- filename (string): The image filename (full path).
- name (string): Optional name for the background image.
#### Returns
Parameters:
- (OverlayManagerImage): The created image element for later modification or removal.
### Video_Overlay_AddFade(OverlayManagerFadeType, TimeSpan, TimeSpan, (byte R, byte G, byte B)?, OverlayManagerPanEasing, string)
Adds a custom fade effect with full control over parameters.
```csharp
public OverlayManagerFade Video_Overlay_AddFade(OverlayManagerFadeType fadeType, TimeSpan startTime, TimeSpan endTime, (byte R, byte G, byte B)? fadeColor = null, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear, string name = "Fade")
```
#### Parameters
Parameters:
- fadeType (OverlayManagerFadeType): The type of fade (FadeIn or FadeOut).
- startTime (TimeSpan): The fade start time.
- endTime (TimeSpan): The fade end time.
- fadeColor (( byte R , byte G , byte B ) ?): Optional fade color (default is black).
- easing (OverlayManagerPanEasing): The easing function for smooth animation.
- name (string): Optional name for the fade effect.
#### Returns
Parameters:
- (OverlayManagerFade): The created fade element for later modification or removal.
### Video_Overlay_AddFadeIn(TimeSpan, TimeSpan?, OverlayManagerPanEasing, string)
Adds a fade-in effect from black (or specified color) to video.
```csharp
public OverlayManagerFade Video_Overlay_AddFadeIn(TimeSpan duration, TimeSpan? startTime = null, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear, string name = "FadeIn")
```
#### Parameters
Parameters:
- duration (TimeSpan): The duration of the fade-in effect.
- startTime (TimeSpan ?): Optional start time (default is TimeSpan.Zero for immediate start).
- easing (OverlayManagerPanEasing): The easing function for smooth animation.
- name (string): Optional name for the fade effect.
#### Returns
Parameters:
- (OverlayManagerFade): The created fade element for later modification or removal.
### Video_Overlay_AddFadeOut(TimeSpan, TimeSpan, OverlayManagerPanEasing, string)
Adds a fade-out effect from video to black (or specified color).
```csharp
public OverlayManagerFade Video_Overlay_AddFadeOut(TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear, string name = "FadeOut")
```
#### Parameters
Parameters:
- startTime (TimeSpan): The start time of the fade-out effect.
- duration (TimeSpan): The duration of the fade-out effect.
- easing (OverlayManagerPanEasing): The easing function for smooth animation.
- name (string): Optional name for the fade effect.
#### Returns
Parameters:
- (OverlayManagerFade): The created fade element for later modification or removal.
### Video_Overlay_AddImage(string, int, int, int, int, string)
Adds an image overlay at the specified position.
```csharp
public OverlayManagerImage Video_Overlay_AddImage(string filename, int x, int y, int width = 0, int height = 0, string name = "Image")
```
#### Parameters
Parameters:
- filename (string): The image filename (full path).
- x (int): The X position.
- y (int): The Y position.
- width (int): The width (0 for original size).
- height (int): The height (0 for original size).
- name (string): Optional name for the image overlay.
#### Returns
Parameters:
- (OverlayManagerImage): The created image element for later modification or removal.
### Video_Overlay_AddPan(int, int, int, int, int, int, int, int, TimeSpan, TimeSpan, string)
```csharp
public OverlayManagerPan Video_Overlay_AddPan(int startX, int startY, int startWidth, int startHeight, int stopX, int stopY, int stopWidth, int stopHeight, TimeSpan startTime, TimeSpan endTime, string name = "Pan")
```
#### Parameters
Parameters:
- startX (int):
- startY (int):
- startWidth (int):
- startHeight (int):
- stopX (int):
- stopY (int):
- stopWidth (int): The stop rectangle width (0 for full width).
- stopHeight (int): The stop rectangle height (0 for full height).
- startTime (TimeSpan): The animation start time.
- endTime (TimeSpan): The animation end time.
- name (string): Optional name for the pan effect.
#### Returns
Parameters:
- (OverlayManagerPan): The created pan element for later modification or removal.
### Video_Overlay_AddPan((int X, int Y, int Width, int Height), (int X, int Y, int Width, int Height), TimeSpan, TimeSpan, OverlayManagerPanEasing, string)
Adds a simple pan effect from one rectangle to another using the element's start/end time.
```csharp
public OverlayManagerPan Video_Overlay_AddPan((int X, int Y, int Width, int Height) startRect, (int X, int Y, int Width, int Height) stopRect, TimeSpan startTime, TimeSpan endTime, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear, string name = "Pan")
```
#### Parameters
Parameters:
- startRect (( int X , int Y , int Width , int Height )): The start rectangle (X, Y, Width, Height). Use 0 for width/height to use full video dimensions.
- stopRect (( int X , int Y , int Width , int Height )): The stop rectangle (X, Y, Width, Height). Use 0 for width/height to use full video dimensions.
- startTime (TimeSpan): The animation start time.
- endTime (TimeSpan): The animation end time.
- easing (OverlayManagerPanEasing): The easing function for smooth animation.
- name (string): Optional name for the pan effect.
#### Returns
Parameters:
- (OverlayManagerPan): The created pan element for later modification or removal.
### Video_Overlay_AddSqueezeback(string, Rect, Rect, string)
Adds a squeezeback effect that scales the video to a custom rectangle and draws
an overlay image on top with alpha transparency support. This creates the classic
"squeezeback" effect used in broadcast where video is shown in a smaller area
with graphics/branding surrounding it.
```csharp
public OverlayManagerSqueezeback Video_Overlay_AddSqueezeback(string backgroundImageFilename, Rect videoRect, Rect backgroundRect = null, string name = "Squeezeback")
```
#### Parameters
Parameters:
- backgroundImageFilename (string): The overlay image filename (PNG with alpha recommended).
- videoRect (Rect): The video rectangle (position and size where video is scaled).
- backgroundRect (Rect): The overlay image rectangle (null for full frame).
- name (string): Optional name for the squeezeback element.
#### Returns
Parameters:
- (OverlayManagerSqueezeback): The created squeezeback element for later modification or removal.
#### Remarks
By default, the video is drawn first at the specified videoRect, then the overlay
image is drawn on top. Use a PNG image with transparent areas where you want the
scaled video to show through.
### Video_Overlay_AddZoom(double, double, int, int, string)
Adds a zoom effect to the overlay manager.
The zoom effect will scale and shift the video content.
```csharp
public OverlayManagerZoom Video_Overlay_AddZoom(double zoomX, double zoomY, int shiftX = 0, int shiftY = 0, string name = "Zoom")
```
#### Parameters
Parameters:
- zoomX (double): The horizontal zoom ratio (1.0 = 100%).
- zoomY (double): The vertical zoom ratio (1.0 = 100%).
- shiftX (int): The horizontal shift in pixels.
- shiftY (int): The vertical shift in pixels.
- name (string): Optional name for the zoom effect.
#### Returns
Parameters:
- (OverlayManagerZoom): The created zoom element for later modification or removal.
### Video_Overlay_AnimateImage(string, int, int, int, int, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts an animation on an image overlay to move/resize it to a target rectangle.
```csharp
public bool Video_Overlay_AnimateImage(string name, int targetX, int targetY, int targetWidth, int targetHeight, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the image overlay.
- targetX (int): The target X position.
- targetY (int): The target Y position.
- targetWidth (int): The target width (0 to keep current).
- targetHeight (int): The target height (0 to keep current).
- startTime (TimeSpan): The animation start time.
- duration (TimeSpan): The animation duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the image was found and animation started; otherwise, false.
### Video_Overlay_BringToFront(string)
Brings an overlay element to the front (highest Z-Index).
```csharp
public bool Video_Overlay_BringToFront(string name)
```
#### Parameters
Parameters:
- name (string): The name of the overlay.
#### Returns
Parameters:
- (bool): true if the overlay was found and updated; otherwise, false.
### Video_Overlay_Clear()
Removes all overlay elements from the video composition.
```csharp
public void Video_Overlay_Clear()
```
### Video_Overlay_Count()
Gets the total number of overlays currently in the composition.
```csharp
public int Video_Overlay_Count()
```
#### Returns
Parameters:
- (int): The number of overlay elements in the composition.
### Video_Overlay_Get(int)
Gets the overlay element at the specified index in the overlay list.
```csharp
public IOverlayManagerElement Video_Overlay_Get(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the overlay to retrieve.
#### Returns
Parameters:
- (IOverlayManagerElement): The overlay element at the specified index.
#### Exceptions
Parameters:
- (ArgumentOutOfRangeException): Thrown when index is out of range.
### Video_Overlay_GetByName(string)
Gets an overlay element by its name.
```csharp
public IOverlayManagerElement Video_Overlay_GetByName(string name)
```
#### Parameters
Parameters:
- name (string): The name of the overlay to find.
#### Returns
Parameters:
- (IOverlayManagerElement): The overlay element with the specified name, or null if not found.
### Video_Overlay_ImageFadeIn(string, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts a fade-in animation on an image overlay.
```csharp
public bool Video_Overlay_ImageFadeIn(string name, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the image overlay.
- startTime (TimeSpan): The fade start time.
- duration (TimeSpan): The fade duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the image was found and fade started; otherwise, false.
### Video_Overlay_ImageFadeOut(string, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts a fade-out animation on an image overlay.
```csharp
public bool Video_Overlay_ImageFadeOut(string name, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the image overlay.
- startTime (TimeSpan): The fade start time.
- duration (TimeSpan): The fade duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the image was found and fade started; otherwise, false.
### Video_Overlay_Remove(IOverlayManagerElement)
Removes a specific overlay element from the video composition.
```csharp
public void Video_Overlay_Remove(IOverlayManagerElement overlay)
```
#### Parameters
Parameters:
- overlay (IOverlayManagerElement): The overlay element to remove from the composition.
### Video_Overlay_RemoveAt(int)
Removes an overlay element at the specified index in the overlay list.
```csharp
public void Video_Overlay_RemoveAt(int index)
```
#### Parameters
Parameters:
- index (int): The zero-based index of the overlay to remove.
### Video_Overlay_RemoveByName(string)
Removes an overlay element by its name.
```csharp
public bool Video_Overlay_RemoveByName(string name)
```
#### Parameters
Parameters:
- name (string): The name of the overlay to remove.
#### Returns
Parameters:
- (bool): true if the overlay was found and removed; otherwise, false.
### Video_Overlay_SendToBack(string)
Sends an overlay element to the back (lowest Z-Index).
```csharp
public bool Video_Overlay_SendToBack(string name)
```
#### Parameters
Parameters:
- name (string): The name of the overlay.
#### Returns
Parameters:
- (bool): true if the overlay was found and updated; otherwise, false.
### Video_Overlay_SetZIndex(string, int)
Sets the Z-Index of an overlay element.
```csharp
public bool Video_Overlay_SetZIndex(string name, int zIndex)
```
#### Parameters
Parameters:
- name (string): The name of the overlay.
- zIndex (int): The new Z-Index value.
#### Returns
Parameters:
- (bool): true if the overlay was found and updated; otherwise, false.
### Video_Overlay_Squeezeback_AnimateBackground(string, Rect, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts an animation for the background rectangle of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_AnimateBackground(string name, Rect targetRect, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- targetRect (Rect): The target rectangle.
- startTime (TimeSpan): The animation start time.
- duration (TimeSpan): The animation duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and animation started; otherwise, false.
### Video_Overlay_Squeezeback_AnimateVideo(string, Rect, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts an animation for the video rectangle of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_AnimateVideo(string name, Rect targetRect, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- targetRect (Rect): The target rectangle.
- startTime (TimeSpan): The animation start time.
- duration (TimeSpan): The animation duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and animation started; otherwise, false.
### Video_Overlay_Squeezeback_BackgroundFadeIn(string, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts a fade-in animation for the background of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_BackgroundFadeIn(string name, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- startTime (TimeSpan): The fade start time.
- duration (TimeSpan): The fade duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and fade started; otherwise, false.
### Video_Overlay_Squeezeback_BackgroundFadeOut(string, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts a fade-out animation for the background of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_BackgroundFadeOut(string name, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- startTime (TimeSpan): The fade start time.
- duration (TimeSpan): The fade duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and fade started; otherwise, false.
### Video_Overlay_Squeezeback_SetBackgroundOnTop(string)
Sets the background layer to be on top in a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_SetBackgroundOnTop(string name)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and updated; otherwise, false.
### Video_Overlay_Squeezeback_SetVideoOnTop(string)
Sets the video layer to be on top in a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_SetVideoOnTop(string name)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and updated; otherwise, false.
### Video_Overlay_Squeezeback_SwapLayers(string)
Swaps the layers in a squeezeback element (video on top / background on top).
```csharp
public bool Video_Overlay_Squeezeback_SwapLayers(string name)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and layers swapped; otherwise, false.
### Video_Overlay_Squeezeback_UpdateBackgroundImage(string, string, Rect)
Updates the background image of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_UpdateBackgroundImage(string name, string filename, Rect backgroundRect = null)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- filename (string): The new background image filename.
- backgroundRect (Rect): The new background rectangle (null to keep current).
#### Returns
Parameters:
- (bool): true if the squeezeback was found and updated; otherwise, false.
### Video_Overlay_Squeezeback_UpdateVideoPosition(string, Rect)
Updates the video position of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_UpdateVideoPosition(string name, Rect videoRect)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- videoRect (Rect): The new video rectangle.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and updated; otherwise, false.
### Video_Overlay_Squeezeback_VideoFadeIn(string, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts a fade-in animation for the video of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_VideoFadeIn(string name, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- startTime (TimeSpan): The fade start time.
- duration (TimeSpan): The fade duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and fade started; otherwise, false.
### Video_Overlay_Squeezeback_VideoFadeOut(string, TimeSpan, TimeSpan, OverlayManagerPanEasing)
Starts a fade-out animation for the video of a squeezeback element.
```csharp
public bool Video_Overlay_Squeezeback_VideoFadeOut(string name, TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = OverlayManagerPanEasing.Linear)
```
#### Parameters
Parameters:
- name (string): The name of the squeezeback element.
- startTime (TimeSpan): The fade start time.
- duration (TimeSpan): The fade duration.
- easing (OverlayManagerPanEasing): The easing function.
#### Returns
Parameters:
- (bool): true if the squeezeback was found and fade started; otherwise, false.
### Video_Overlay_Update(IOverlayManagerElement)
Updates an existing overlay element by removing and re-adding it with new properties.
This method is used to refresh an overlay after modifying its properties.
```csharp
public void Video_Overlay_Update(IOverlayManagerElement overlay)
```
#### Parameters
Parameters:
- overlay (IOverlayManagerElement): The overlay element to update with its new properties.
### Video_Overlay_UpdateImageFile(string, string)
Updates the filename of an image overlay.
```csharp
public bool Video_Overlay_UpdateImageFile(string name, string newFilename)
```
#### Parameters
Parameters:
- name (string): The name of the image overlay.
- newFilename (string): The new image filename.
#### Returns
Parameters:
- (bool): true if the image was found and updated; otherwise, false.
### Video_Overlay_UpdateImagePosition(string, int, int, int, int)
Updates the position of an image overlay.
```csharp
public bool Video_Overlay_UpdateImagePosition(string name, int x, int y, int width = 0, int height = 0)
```
#### Parameters
Parameters:
- name (string): The name of the image overlay.
- x (int): The new X position.
- y (int): The new Y position.
- width (int): The new width (0 to keep current).
- height (int): The new height (0 to keep current).
#### Returns
Parameters:
- (bool): true if the image was found and updated; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this overlay manager block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class PanZoomBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.PanZoomBlock.html
# Class PanZoomBlock
# Class PanZoomBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that applies pan and zoom transformations to video frames using Cairo.
This block provides static and dynamic zoom and pan effects for video streams.
Implements the true if successful; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance.
### GetElement()
Gets the underlying GStreamer element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance.
### IsAvailable()
Determines whether the pan zoom filter is available on the current system.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if available; otherwise, false.
### SetDynamicPan(VideoStreamDynamicPanSettings)
Sets the dynamic pan (translation) settings for the video stream.
Dynamic pan interpolates between start and stop values based on the video timestamp.
```csharp
public void SetDynamicPan(VideoStreamDynamicPanSettings settings)
```
#### Parameters
Parameters:
- settings (VideoStreamDynamicPanSettings): The dynamic pan settings to apply, or null to disable dynamic pan.
### SetDynamicZoom(VideoStreamDynamicZoomSettings)
Sets the dynamic zoom settings for the video stream.
Dynamic zoom interpolates between start and stop values based on the video timestamp.
```csharp
public void SetDynamicZoom(VideoStreamDynamicZoomSettings settings)
```
#### Parameters
Parameters:
- settings (VideoStreamDynamicZoomSettings): The dynamic zoom settings to apply, or null to disable dynamic zoom.
### SetPan(VideoStreamPanSettings)
Sets the static pan (translation) settings for the video stream.
```csharp
public void SetPan(VideoStreamPanSettings settings)
```
#### Parameters
Parameters:
- settings (VideoStreamPanSettings): The pan settings to apply, or null to disable pan.
### SetRect(VideoStreamRectSettings)
Sets the target rectangle settings for drawing the video into a specific rectangle.
The video will be resized and positioned to fit within the specified rectangle.
When enabled, this takes precedence over pan and zoom settings.
```csharp
public void SetRect(VideoStreamRectSettings settings)
```
#### Parameters
Parameters:
- settings (VideoStreamRectSettings): The rect settings to apply, or null to disable rect mode.
### SetZoom(VideoStreamZoomSettings)
Sets the static zoom settings for the video stream.
```csharp
public void SetZoom(VideoStreamZoomSettings settings)
```
#### Parameters
Parameters:
- settings (VideoStreamZoomSettings): The zoom settings to apply, or null to disable zoom.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this block with a pipeline and initializes its internal context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class PerspectiveBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.PerspectiveBlock.html
# Class PerspectiveBlock
# Class PerspectiveBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video perspective transformation block for advanced geometric distortion and 3D projection effects.
This block applies perspective transformation using 3x3 transformation matrices to create
sophisticated geometric effects including 3D rotation, keystone correction, and perspective warping.
Features matrix-based transformation control for precise geometric manipulation and correction.
Essential for video correction, artistic effects, architectural visualization, and advanced
geometric transformations requiring mathematical precision.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this perspective transformation block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer perspective filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer perspective filter.
### GetElement()
Gets the underlying GStreamer element that performs the perspective transformation processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the perspective filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this perspective transformation block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class PinchBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.PinchBlock.html
# Class PinchBlock
# Class PinchBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video pinch distortion effect block that creates inward or outward warping from a center point.
This block applies a pinch or bulge distortion to video content, pulling pixels toward or pushing
them away from a central point. Features configurable intensity for both positive (bulge) and
negative (pinch) effects, creating lens-like distortions. Essential for creative effects,
caricature-style distortions, fisheye corrections, and artistic video transformations
requiring radial compression or expansion effects.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this pinch effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer pinch filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer pinch filter.
### GetElement()
Gets the underlying GStreamer element that performs the pinch distortion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the pinch filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this pinch effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class Pseudo3DBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.Pseudo3DBlock.html
# Class Pseudo3DBlock
# Class Pseudo3DBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Pseudo 3D video effect block that creates simulated three-dimensional perspective transformations.
This block applies perspective distortions and transformations to create the illusion of 3D depth
on 2D video content. Features include adjustable perspective angles, depth simulation, rotation
in virtual 3D space, and various projection modes. Essential for creating 3D-like transitions,
perspective corrections, architectural visualizations, and creative effects requiring simulated
three-dimensional transformations without actual 3D rendering.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this pseudo 3D block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer pseudo 3D filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer pseudo 3D filter.
### GetElement()
Gets the underlying GStreamer element that performs the pseudo 3D transformation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the pseudo 3D filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this pseudo 3D block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class QRCodeOverlayBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.QRCodeOverlayBlock.html
# Class QRCodeOverlayBlock
# Class QRCodeOverlayBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
QR code overlay block for embedding scannable QR codes directly onto video content.
This block generates and overlays QR codes containing custom data such as URLs, text,
contact information, or any encoded data. Features include configurable size, position,
error correction levels, and transparency settings. Essential for marketing videos,
educational content, interactive media, ticketing systems, and any application requiring
embedded scannable information within video streams.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this QR code overlay block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer QR code overlay filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer QR code overlay filter.
### GetElement()
Gets the underlying GStreamer element that performs the QR code generation and overlay.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the QR code overlay filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this QR code overlay block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class QuarkBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.QuarkBlock.html
# Class QuarkBlock
# Class QuarkBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Quark video effect block that creates particle dissolution effects on moving objects.
This block applies a unique visual effect that dissolves and disperses moving objects into
particle-like fragments, creating a quantum or disintegration appearance. Features include
motion detection sensitivity, particle density, dissolution speed, and regeneration patterns.
Essential for sci-fi effects, creative transitions, motion-based visual effects, and artistic
video production requiring dynamic object dissolution based on movement detection.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this quark effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer quark filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer quark filter.
### GetElement()
Gets the underlying GStreamer element that performs the quark dissolution effect.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the quark filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this quark effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class RippleBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.RippleBlock.html
# Class RippleBlock
# Class RippleBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Ripple effect block that creates water-like wave distortions and undulating visual patterns.
This block applies dynamic ripple distortion effects that simulate water surface waves,
heat shimmer, or liquid distortions across the video content. Features configurable amplitude,
frequency, wave speed, and center point parameters for creating realistic fluid motion effects.
Essential for artistic video production, liquid simulations, dream sequences, and creative effects
requiring organic wave-based distortions.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this ripple effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer ripple filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer ripple filter.
### GetElement()
Gets the underlying GStreamer element that performs the ripple wave distortion processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the ripple filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this ripple effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class RotateBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.RotateBlock.html
# Class RotateBlock
# Class RotateBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video rotation block for precise angular transformation and orientation correction.
This block provides smooth video rotation capabilities with sub-pixel accuracy using advanced
interpolation algorithms. Features configurable rotation angles, center point adjustment,
and anti-aliasing for high-quality results. Essential for correcting camera orientation,
artistic rotation effects, device orientation handling, and video stabilization workflows
requiring precise angular adjustments.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this rotation block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer rotate filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer rotate filter.
### GetElement()
Gets the underlying GStreamer element that performs the video rotation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the rotate filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this rotation block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class RoundedCornersBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.RoundedCornersBlock.html
# Class RoundedCornersBlock
# Class RoundedCornersBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that applies rounded corners effect to video frames.
This block adds rounded corners to video by creating an alpha mask that makes the corners
transparent with a specified border radius. The effect can be used for aesthetic purposes,
matching UI design patterns, or creating picture-in-picture effects with rounded corners.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this rounded corners block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer rounded corners filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer rounded corners filter.
### GetElement()
Gets the underlying GStreamer element that performs the rounded corners processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the rounded corners filter.
### IsAvailable()
Determines whether the rounded corners filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the rounded corners filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this rounded corners block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SimpleVideoMarkBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SimpleVideoMarkBlock.html
# Class SimpleVideoMarkBlock
# Class SimpleVideoMarkBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that embeds invisible digital watermarks into video streams for identification and tracking purposes.
This block uses GStreamer's simplevideomark element to insert unique patterns into video frames that can be
detected later using SimpleVideoMarkDetectBlock. The watermarks are designed to be imperceptible to viewers
while providing robust identification capabilities for content tracking, copyright protection, and media forensics.
Common use cases include broadcast monitoring, content distribution tracking, and digital rights management.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this simple video mark block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer simple video mark filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer simple video mark filter.
### GetElement()
Gets the underlying GStreamer element that performs the video watermarking.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the simple video mark filter.
### IsAvailable()
Determines whether the simple video mark filter is available on the current system.
This checks if the required GStreamer videosignal plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the simple video mark filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this simple video mark block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SimpleVideoMarkDetectBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SimpleVideoMarkDetectBlock.html
# Class SimpleVideoMarkDetectBlock
# Class SimpleVideoMarkDetectBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that detects and extracts invisible digital watermarks from video streams for identification and verification.
This block uses GStreamer's simplevideomarkdetect element to identify unique patterns embedded by SimpleVideoMarkBlock.
The detection provides real-time notification when watermarks are found, enabling applications to track content,
verify authenticity, and implement copyright protection systems. Essential for broadcast monitoring,
content distribution tracking, digital rights management, and media forensics applications.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this simple video mark detect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer simple video mark detect filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer simple video mark detect filter.
### GetElement()
Gets the underlying GStreamer element that performs the video watermark detection.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the simple video mark detect filter.
### IsAvailable()
Determines whether the simple video mark detect filter is available on the current system.
This checks if the required GStreamer videosignal plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the simple video mark detect filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this simple video mark detect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### VideoMarkDetected
Event that fires when a video watermark is detected in the stream.
Provides the detected pattern value and timestamp information.
```csharp
public event EventHandlertrue if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this smooth filter block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer smooth filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer smooth filter.
### GetElement()
Gets the underlying GStreamer element that performs the smoothing and noise reduction.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the smooth filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this smooth filter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SMPTEAlphaBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SMPTEAlphaBlock.html
# Class SMPTEAlphaBlock
# Class SMPTEAlphaBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
SMPTE alpha transition video effect block that creates wipe transitions with alpha channel support.
This block applies SMPTE standard transition patterns with transparency control, enabling seamless
compositing of video layers with proper alpha blending. Essential for creating professional overlays,
transparent transitions, and advanced compositing effects with full alpha channel support.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this SMPTE alpha effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer SMPTE alpha filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer SMPTE alpha filter.
### GetElement()
Gets the underlying GStreamer element that performs the SMPTE alpha transition processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the SMPTE alpha filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this SMPTE alpha effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SMPTEBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SMPTEBlock.html
# Class SMPTEBlock
# Class SMPTEBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
SMPTE transition video effect block that creates wipe transitions between two video sources.
This block applies SMPTE standard transition patterns including linear wipes, iris effects, and other
geometric transitions commonly used in professional video editing. Essential for creating smooth
transitions between video clips, broadcast-quality effects, and professional video production workflows.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this SMPTE effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer SMPTE filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer SMPTE filter.
### GetElement()
Gets the underlying GStreamer element that performs the SMPTE transition processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the SMPTE filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this SMPTE effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SphereBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SphereBlock.html
# Class SphereBlock
# Class SphereBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video sphere distortion effect block that creates curved spherical lens projection.
This block applies spherical geometric distortion to video content, simulating the effect
of viewing the image through a spherical lens or bubble. Features configurable refraction
index, radius control, and center point positioning for realistic optical effects.
Essential for creative video production, optical simulation, VR content preparation,
and artistic effects requiring curved spatial transformations.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this sphere effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer sphere filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer sphere filter.
### GetElement()
Gets the underlying GStreamer element that performs the spherical distortion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the sphere filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this sphere effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SquareBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SquareBlock.html
# Class SquareBlock
# Class SquareBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Square distortion effect block that warps the center region into a square shape.
This block applies a geometric transformation that distorts a circular area in the center
of the image into a square shape, creating a unique warping effect. Features include
adjustable size, intensity, and center positioning for the square distortion.
Essential for creative visual effects, abstract video art, kaleidoscope-like patterns,
and experimental video production requiring geometric shape transformations.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this square distortion block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer square filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer square filter.
### GetElement()
Gets the underlying GStreamer element that performs the square distortion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the square filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this square distortion block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class StretchBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.StretchBlock.html
# Class StretchBlock
# Class StretchBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Stretch distortion effect block that creates circular radial stretching around a center point.
This block applies a radial stretch transformation that pulls or pushes pixels in a circular
pattern from a center point, creating effects similar to looking through a magnifying glass
or funhouse mirror. Features adjustable intensity for both inward and outward stretching,
center point positioning, and radius control. Essential for creative distortions, lens
simulation effects, artistic transformations, and visual effects requiring radial warping.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this stretch effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer stretch filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer stretch filter.
### GetElement()
Gets the underlying GStreamer element that performs the stretch distortion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the stretch filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this stretch effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class SVGOverlayBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.SVGOverlayBlock.html
# Class SVGOverlayBlock
# Class SVGOverlayBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
SVG overlay block for rendering scalable vector graphics on video content.
This block overlays SVG (Scalable Vector Graphics) images or animations onto video streams,
providing resolution-independent graphics perfect for logos, animated graphics, diagrams,
and dynamic visual elements. Features include positioning, scaling, opacity control,
and support for animated SVG content. Essential for broadcast graphics, watermarking,
infographics, animated overlays, and any application requiring high-quality vector
graphics overlaid on video content.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this SVG overlay block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer SVG overlay filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer SVG overlay filter.
### GetElement()
Gets the underlying GStreamer element that performs the SVG rendering and overlay.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the SVG overlay filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this SVG overlay block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class TextOverlayBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.TextOverlayBlock.html
# Class TextOverlayBlock
# Class TextOverlayBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that renders dynamic text overlays onto video streams with full typography control.
This block provides comprehensive text rendering capabilities including custom fonts, colors,
sizing, positioning, shadows, outlines, and background effects. Supports real-time text updates,
multiple text elements, and professional typography features commonly used for titles, subtitles,
lower thirds, captions, timestamps, and branding. The text rendering engine supports Unicode,
anti-aliasing, and advanced text layout with precise positioning control.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this text overlay block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer text overlay filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer text overlay filter.
### GetElement()
Gets the underlying GStreamer element that performs the text rendering and overlay processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the text overlay filter.
### IsAvailable()
Determines whether the text overlay filter is available on the current system.
This checks if the required GStreamer text rendering plugins and font subsystem are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the text overlay filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this text overlay block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class TunnelBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.TunnelBlock.html
# Class TunnelBlock
# Class TunnelBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video tunnel effect block that creates a perspective tunnel or vortex visual effect.
This block applies a tunnel transformation that warps the video into a perspective tunnel,
creating the illusion of depth and movement through a cylindrical or spiral passageway.
Features include depth control, rotation effects, center positioning, and perspective
adjustments. Essential for music videos, sci-fi transitions, hypnotic visual effects,
and creative content requiring tunnel vision or vortex-like transformations.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this tunnel effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer tunnel filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer tunnel filter.
### GetElement()
Gets the underlying GStreamer element that performs the tunnel transformation.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the tunnel filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this tunnel effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class TwirlBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.TwirlBlock.html
# Class TwirlBlock
# Class TwirlBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video twirl distortion effect block that creates spiral rotating warping patterns.
This block applies twirl distortion to video content by rotating pixels around a center point
with intensity that decreases based on distance from the center. Features configurable
twist angle, center point positioning, and radius control for creating various spiral effects.
Essential for creative video production, artistic transitions, hypnotic effects, and abstract
visual transformations requiring spiral-based geometric distortion.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this twirl effect block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer twirl filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer twirl filter.
### GetElement()
Gets the underlying GStreamer element that performs the twirl distortion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the twirl filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this twirl effect block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoAspectRatioCropBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoAspectRatioCropBlock.html
# Class VideoAspectRatioCropBlock
# Class VideoAspectRatioCropBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video aspect ratio crop block for intelligent content-aware aspect ratio conversion.
This block automatically crops video to match a target aspect ratio while preserving
the most important visual content. Features intelligent cropping algorithms that detect
and preserve key areas of interest, configurable crop positioning, and smooth transitions.
Essential for format conversion between different display standards (16:9, 4:3, 21:9),
social media format adaptation, and professional video production requiring automated
aspect ratio adjustments without manual intervention.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this aspect ratio crop block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer aspect ratio crop filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer aspect ratio crop filter.
### GetElement()
Gets the underlying GStreamer element that performs the aspect ratio cropping.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the aspect ratio crop filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this aspect ratio crop block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoBalanceBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoBalanceBlock.html
# Class VideoBalanceBlock
# Class VideoBalanceBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video balance block for professional color correction and image enhancement.
This block provides comprehensive video color adjustment capabilities including brightness,
contrast, saturation, hue, and gamma correction. Features real-time parameter adjustment,
automatic white balance, and precise color space manipulation for broadcast-quality results.
Essential for color grading, exposure correction, camera calibration, and professional
video post-production workflows requiring accurate color representation.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video balance block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video balance filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video balance filter.
### GetElement()
Gets the underlying GStreamer element that performs the color balance adjustments.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video balance filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video balance block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoBoxBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoBoxBlock.html
# Class VideoBoxBlock
# Class VideoBoxBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video box effect block for adding borders, letterboxing, and pillarboxing to video content.
This block adds configurable borders around video content, enabling letterboxing (horizontal bars),
pillarboxing (vertical bars), or custom border layouts. Features include adjustable border
thickness on all sides, custom border colors, and automatic aspect ratio preservation.
Essential for format adaptation, cinema-style letterboxing, broadcast safe areas,
video composition layouts, and professional presentations requiring precise video framing.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video box block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video box filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video box filter.
### GetElement()
Gets the underlying GStreamer element that performs the box border addition.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video box filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video box block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoConverterBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoConverterBlock.html
# Class VideoConverterBlock
# Class VideoConverterBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video format conversion block that transforms video frames between different colorspaces, pixel formats, and resolutions.
This essential pipeline component handles conversions between formats like RGB, YUV, NV12, RGBA, and other pixel formats,
ensuring compatibility between different blocks in the pipeline. It performs automatic format negotiation and can handle
colorspace conversions, bit depth changes, and chroma subsampling adjustments as needed by connected pipeline elements.
Commonly used when connecting blocks that require different input/output formats or when preparing video for specific encoders or renderers.
Implements the true if the converter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video converter block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video converter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video converter.
### GetElement()
Gets the underlying GStreamer element that performs the video format conversion processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video converter.
### IsAvailable()
Determines whether video conversion functionality is available on the current system.
This checks for the presence of required GStreamer video conversion plugins and libraries.
Video conversion is typically available on all platforms with a complete GStreamer installation.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if video conversion is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video converter block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoCropBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoCropBlock.html
# Class VideoCropBlock
# Class VideoCropBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that crops video frames by removing specified regions from the edges or center.
Video cropping allows precise trimming of unwanted areas from video content, supporting
pixel-accurate region selection with top, bottom, left, and right margins. This is essential
for removing black bars, focusing on specific areas of interest, changing aspect ratios,
or preparing content for different display formats. The cropping operation is lossless
and preserves the original video quality while reducing the frame dimensions.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video crop block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video crop filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video crop filter.
### GetElement()
Gets the underlying GStreamer element that performs the video cropping operations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video crop filter.
### IsAvailable()
Determines whether the video crop filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the video crop filter is available and can be used; otherwise, false.
### Update()
Updates the crop settings in real-time while the pipeline is running.
Call this method after modifying the Settings property to apply new crop margins immediately.
This allows dynamic adjustment of the crop area during video processing.
```csharp
public void Update()
```
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video crop block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoEffectsBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoEffectsBlock.html
# Class VideoEffectsBlock
# Class VideoEffectsBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video effects block for dynamic effect chain management and real-time effect processing.
This block provides a flexible framework for applying multiple video effects in sequence,
with support for dynamic addition, removal, and modification of effects during playback.
Features include automatic effect chaining, runtime parameter updates, intelligent pipeline
management, and support for all major effect types (color correction, geometric transforms,
overlays, filters). Essential for video editing applications, live streaming with effects,
post-production workflows, and any scenario requiring complex, dynamic video effect chains.
Implements the true if the effects chain was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video effects block.
This method disposes of the effects processor and video converter elements.
```csharp
public void CleanUp()
```
### Clear()
Removes all video effects from the processing chain.
Restores the pipeline to pass-through mode.
```csharp
public void Clear()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Get(string)
Gets a video effect interface by its unique name.
Enables direct access to specific effects for parameter updates.
```csharp
public IBaseVideoEffect Get(string name)
```
#### Parameters
Parameters:
- name (string): The unique effect name used during creation.
#### Returns
Parameters:
- (IBaseVideoEffect): The true if this media block is available; otherwise, false.
### Remove(IBaseVideoEffect)
Removes a video effect from the processing chain.
Automatically reconfigures the pipeline to maintain continuity.
```csharp
public void Remove(IBaseVideoEffect effect)
```
#### Parameters
Parameters:
- effect (IBaseVideoEffect): The video effect to remove.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video effects block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoMixerBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoMixerBlock.html
# Class VideoMixerBlock
# Class VideoMixerBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that combines multiple video inputs into a single output with advanced compositing features.
The video mixer provides professional broadcast-quality mixing capabilities including multi-layer compositing,
real-time positioning, scaling, transparency control, chroma key effects, and transition animations.
Supports hardware acceleration through Direct3D11 and OpenGL backends for optimal performance.
Essential for live streaming, broadcast production, video conferencing, and any application requiring
multiple video source composition with professional-grade features like picture-in-picture, overlays,
and dynamic layer management with smooth transitions and effects.
Implements the true if successful, false otherwise.
### CleanUp()
Releases all resources and performs cleanup operations for this video mixer block.
This method disposes of the mixer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets core.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): VisioForge.Core.GStreamer.Base.BaseElement.
### GetElement()
Gets the element.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): Gst.Element.
### Input_Get(Guid)
Retrieves a specific video input stream configuration by its unique identifier.
This allows access to individual layer properties within the video composition.
```csharp
public VideoMixerStream Input_Get(Guid id)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream.
#### Returns
Parameters:
- (VideoMixerStream): The VideoMixerStream configuration for the specified input, or null if not found.
### Input_List()
Retrieves all active input stream configurations currently being mixed.
Provides access to the complete list of video layers and their properties.
```csharp
public VideoMixerStream[] Input_List()
```
#### Returns
Parameters:
- (VideoMixerStream [ ]): An array of VideoMixerStream objects representing all active input streams.
### Input_Move(Guid, Rect, TimeSpan, double?, double?)
Animates an input stream from its current position and transparency to new values over a specified duration.
Creates smooth transitions for professional video production effects like slides and cross-fades.
```csharp
public void Input_Move(Guid id, Rect rect, TimeSpan duration, double? startAlpha, double? endAlpha)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to animate.
- rect (Rect): The target position and size rectangle for the animation endpoint.
- duration (TimeSpan): The duration of the animation transition.
- startAlpha (double ?): Optional starting transparency value (0.0 = transparent, 1.0 = opaque).
- endAlpha (double ?): Optional ending transparency value (0.0 = transparent, 1.0 = opaque).
### Input_SetChromaKeyEnabled(Guid, bool)
Enables or disables chroma key processing for a specific input stream.
When enabled, the configured key color becomes transparent, allowing background replacement
for green screen and blue screen compositing effects.
```csharp
public void Input_SetChromaKeyEnabled(Guid id, bool enabled)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream.
- enabled (bool): True to enable chroma key processing, false to disable and show the original video.
### Input_Update(VideoMixerStream)
Updates the configuration of a specific input stream in real-time.
Changes to position, size, transparency, and other properties take effect immediately.
```csharp
public void Input_Update(VideoMixerStream stream)
```
#### Parameters
Parameters:
- stream (VideoMixerStream): The VideoMixerStream with updated configuration parameters.
### Input_UpdateChromaKeySettings(Guid, ChromaKeySettingsX)
Updates the chroma key (green screen) settings for a specific input stream in real-time.
Allows dynamic adjustment of color keying parameters including key color, tolerance, and edge softness
for professional compositing effects commonly used in broadcast and film production.
```csharp
public void Input_UpdateChromaKeySettings(Guid id, ChromaKeySettingsX settings)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream.
- settings (ChromaKeySettingsX): The ChromaKeySettingsX containing key color, tolerance, and edge processing parameters.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetSettings(VideoMixerBaseSettings)
Updates the video mixer settings in real-time while the pipeline is running.
Changes to stream configurations, layout, and mixing parameters take effect immediately.
```csharp
public void SetSettings(VideoMixerBaseSettings settings)
```
#### Parameters
Parameters:
- settings (VideoMixerBaseSettings): The VideoMixerBaseSettings containing updated configuration parameters.
### StartFadeIn(Guid, TimeSpan)
Initiates a smooth fade-in transition for the specified input stream.
Gradually increases opacity from transparent to opaque over the specified duration.
```csharp
public void StartFadeIn(Guid id, TimeSpan duration)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to fade in.
- duration (TimeSpan): The duration of the fade-in transition.
### StartFadeOut(Guid, TimeSpan)
Initiates a smooth fade-out transition for the specified input stream.
Gradually decreases opacity from opaque to transparent over the specified duration.
```csharp
public void StartFadeOut(Guid id, TimeSpan duration)
```
#### Parameters
Parameters:
- id (Guid): The unique GUID identifier for the input stream to fade out.
- duration (TimeSpan): The duration of the fade-out transition.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Sets the context.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The pipeline.
## See Also
---
# Class VideoRateBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoRateBlock.html
# Class VideoRateBlock
# Class VideoRateBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video frame rate changer block for temporal resampling and frame rate conversion.
This block intelligently adjusts video frame rates by duplicating or dropping frames
while maintaining smooth playback. Features advanced temporal interpolation algorithms
that minimize visual artifacts during rate conversion. Supports conversion between
standard frame rates (24, 25, 30, 50, 60 fps), custom rates, and variable frame rate
handling. Essential for format conversion, broadcast standards compliance, slow motion
effects, time-lapse creation, and ensuring compatibility across different playback systems.
Implements the true if the converter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video rate block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video rate element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video rate converter.
### GetElement()
Gets the underlying GStreamer element that performs the frame rate conversion.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video rate converter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video rate block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoResizeBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoResizeBlock.html
# Class VideoResizeBlock
# Class VideoResizeBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
MediaBlock that resizes video frames to specified dimensions with configurable scaling algorithms.
Video resizing is fundamental for format conversion, quality optimization, and display adaptation.
The block supports various interpolation methods including bilinear, bicubic, and lanczos algorithms
to maintain visual quality during scaling operations. Essential for adapting content to different
resolutions, aspect ratios, and delivery formats while preserving image quality through advanced
resampling techniques. Commonly used for streaming optimization, device compatibility, and broadcast standards.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video resize block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video resize filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video resize filter.
### GetElement()
Gets the underlying GStreamer element that performs the video scaling operations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video resize filter.
### IsAvailable()
Determines whether the video resize filter is available on the current system.
This checks if the required GStreamer video processing plugins are installed and accessible.
The correct NuGet SDK redistribution package should be included in your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if the video resize filter is available and can be used; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video resize block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class VideoSampleGrabberBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.VideoSampleGrabberBlock.html
# Class VideoSampleGrabberBlock
# Class VideoSampleGrabberBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video sample grabber block for frame capture and analysis during playback.
This block provides real-time access to video frames as they pass through the pipeline,
enabling frame extraction, analysis, processing, and snapshot capabilities. Features
multiple output formats (buffer, SKBitmap, System.Drawing.Bitmap), configurable pixel
formats, frame caching for snapshots, and event-based frame delivery. Essential for
video analysis applications, thumbnail generation, motion detection, computer vision
integration, real-time monitoring, and any scenario requiring access to raw video data.
Implements the true add null renderer for capture-only scenarios.
- nullRendererSync (bool): if set to true null renderer synchronizes to pipeline clock.
## Fields
### TAG
Logging tag used to identify log messages from this video sample grabber block.
```csharp
protected const string TAG = "VideoSampleGrabberBlock"
```
#### Field Value
Parameters:
- (string):
## Properties
### Input
Gets the input.
```csharp
public override MediaBlockPad Input { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Inputs
Gets the inputs.
```csharp
public override MediaBlockPad[] Inputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### Output
Gets the output.
```csharp
public override MediaBlockPad Output { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad):
### Outputs
Gets the outputs.
```csharp
public override MediaBlockPad[] Outputs { get; }
```
#### Property Value
Parameters:
- (MediaBlockPad [ ]):
### SaveLastFrame
Gets or sets a value indicating whether to save the last frame. You can use it to take a snapshot with GetFrame() method.
When enabled, maintains a cache of the most recent frame for on-demand retrieval.
```csharp
public bool SaveLastFrame { get; set; }
```
#### Property Value
Parameters:
- (bool):
### Type
Gets the type.
```csharp
public override MediaBlockType Type { get; }
```
#### Property Value
Parameters:
- (MediaBlockType):
## Methods
### Build()
Constructs and initializes the video sample grabber and its associated elements.
This method creates the grabber with the specified format, establishes event handlers,
configures pads, and prepares the block for frame capture and analysis.
```csharp
public override bool Build()
```
#### Returns
Parameters:
- (bool): true if the grabber was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this sample grabber block.
This method disposes of the grabber elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the video sample grabber element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the sample grabber.
### GetElement()
Gets the underlying GStreamer element that performs the frame capture.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the sample grabber.
### GetLastFrame()
Gets the last captured video frame as raw data.
Requires SaveLastFrame to be enabled before capture.
```csharp
public VideoFrameX GetLastFrame()
```
#### Returns
Parameters:
- (VideoFrameX): The last captured VideoFrameX object, or null if not available.
### GetLastFrameAsSKBitmap()
Gets the last captured frame as a SkiaSharp.SKBitmap.
Requires SaveLastFrame to be enabled and BGRA/RGBA format.
```csharp
public SKBitmap GetLastFrameAsSKBitmap()
```
#### Returns
Parameters:
- (SKBitmap): The last captured frame as SKBitmap, or null if not available.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this sample grabber block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
### OnVideoFrameBuffer
This event occurs whenever each new video frame is received.
Provides raw frame data as a buffer for custom processing.
```csharp
public event EventHandlertrue if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this video scale transformation block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer video scale filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer video scale filter.
### GetElement()
Gets the underlying GStreamer element that performs the video scaling transformations.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video scale filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video scale transformation block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class WarpBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.WarpBlock.html
# Class WarpBlock
# Class WarpBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video warp distortion effect block for advanced geometric transformations and spatial warping.
This block applies sophisticated warping algorithms to video content, creating curved distortions,
perspective corrections, and artistic deformations. Features configurable warping parameters
including intensity, center point, and distortion patterns for precise control over the effect.
Essential for creative video production, lens correction, perspective adjustment, and artistic
visual transformations requiring complex geometric manipulation.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this warp distortion block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer warp filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer warp filter.
### GetElement()
Gets the underlying GStreamer element that performs the warp distortion processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the warp filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this warp distortion block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Class WaterRippleBlock
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.WaterRippleBlock.html
# Class WaterRippleBlock
# Class WaterRippleBlock
**Namespace**: VisioForge.Core.MediaBlocks.VideoProcessing
**Assembly**: VisioForge.Core.dll
Video water ripple distortion effect block that creates fluid wave-like animations.
This block simulates water surface ripples by applying dynamic wave distortions to video content.
Features configurable wave amplitude, frequency, and center point for realistic water effects.
Creates animated concentric ripples emanating from a specified point, perfect for artistic
transitions, fluid simulations, and dynamic visual effects requiring liquid-like distortion.
Essential for creating water drop effects, pond ripples, and animated distortion sequences.
Implements the true if the filter was successfully built and configured; false if initialization failed.
### CleanUp()
Releases all resources and performs cleanup operations for this water ripple distortion block.
This method disposes of the GStreamer elements and resets the build state.
```csharp
public void CleanUp()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the GStreamer water ripple filter element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the GStreamer water ripple filter.
### GetElement()
Gets the underlying GStreamer element that performs the water ripple distortion processing.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the water ripple filter.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this water ripple distortion block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.VideoProcessing
Link: api/VisioForge.Core.MediaBlocks.VideoProcessing.html
# Namespace VisioForge.Core.MediaBlocks.VideoProcessing
# Namespace VisioForge.Core.MediaBlocks.VideoProcessing
### Classes
Parameters:
- (): Aging video effect block that simulates vintage film deterioration and weathering effects.
This block applies realistic aging effects to video content including film scratches, dust particles,
color degradation, sepia toning, and temporal fluctuations to create authentic vintage film appearance.
Features configurable scratch density, dust intensity, color shift parameters, and flickering effects.
Essential for creative video production, historical documentaries, artistic filters, and retro-style
content creation requiring authentic aged film aesthetics.
Implements the Supported features: Combining separate color and alpha streams into RGBA/YUVA
Use cases: Video compositing, merging decoded color and alpha streams, custom alpha processing
Implements theSupported features: VP8/VP9 alpha demuxing from WebM/MKV containers
Use cases: Custom alpha processing, separate color/alpha decoding pipelines
Implements thetrue if successfull, false otherwise.
### CleanUp()
Releases all resources and performs cleanup operations for this video renderer block.
This method disposes of rendering elements, clears frame buffers, and releases display resources.
```csharp
public void CleanUp()
```
### ClearHandle()
Clears the window handle or display surface association.
Call this before changing the rendering target or when the display window is destroyed.
```csharp
public void ClearHandle()
```
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected override void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### FrameStep(int, double)
Advances the video by a specified number of frames.
Useful for frame-accurate seeking and video analysis applications.
```csharp
public bool FrameStep(int framesCount, double rate)
```
#### Parameters
Parameters:
- framesCount (int): The number of frames to advance.
- rate (double): The rate at which to perform the frame step.
#### Returns
Parameters:
- (bool): true if frame stepping was successful; false otherwise.
### GetCore()
Gets the core BaseElement wrapper that provides additional functionality
around the platform-specific video renderer element.
```csharp
public BaseElement GetCore()
```
#### Returns
Parameters:
- (BaseElement): The BaseElement wrapper instance that encapsulates the video renderer.
### GetElement()
Gets the underlying GStreamer element that performs video rendering.
```csharp
public Element GetElement()
```
#### Returns
Parameters:
- (Element): The GStreamer Element instance representing the video renderer.
### GetVideoStreamInfo()
Gets detailed information about the current video stream being rendered.
Includes resolution, frame rate, pixel format, and codec information.
```csharp
public VideoStreamInfo GetVideoStreamInfo()
```
#### Returns
Parameters:
- (VideoStreamInfo): VideoStreamInfo containing stream metadata, or null if no stream is active.
### GetVideoView()
Gets the video view interface associated with this renderer.
```csharp
public IVideoView GetVideoView()
```
#### Returns
Parameters:
- (IVideoView): The IVideoView instance used for rendering, or null if using window handle.
### IsAvailable()
Determines whether this media block is available. Correct NuGet SDK redist should be included into your project.
```csharp
public static bool IsAvailable()
```
#### Returns
Parameters:
- (bool): true if this media block is available; otherwise, false.
### SetRate(double, Pipeline)
Sets the playback rate for the video renderer.
Supports variable speed playback including slow motion and fast forward.
```csharp
public bool SetRate(double rate, Pipeline pipeline)
```
#### Parameters
Parameters:
- rate (double): The playback rate (1.0 = normal, 0.5 = half speed, 2.0 = double speed).
- pipeline (Pipeline): The GStreamer pipeline containing this renderer.
#### Returns
Parameters:
- (bool): true if the rate was successfully set; false otherwise.
### Snapshot_Get()
Gets the snapshot as SKBitmap.
```csharp
public SKBitmap Snapshot_Get()
```
#### Returns
Parameters:
- (SKBitmap): SKBitmap.
### Snapshot_GetAsync()
Gets the snapshot as SKBitmap (async).
```csharp
public Tasktrue if successful, false otherwise.
### Snapshot_SaveAsync(string, SKEncodedImageFormat, int)
Saves snapshot to a file (async).
```csharp
public Tasktrue if successful, false otherwise.
### UpdateSubtitleOverlay(SubtitleOverlaySettings)
Updates the subtitle overlay settings in real-time.
Changes take effect immediately without interrupting video playback.
```csharp
public void UpdateSubtitleOverlay(SubtitleOverlaySettings settings)
```
#### Parameters
Parameters:
- settings (SubtitleOverlaySettings): The new subtitle overlay settings to apply.
### IMediaBlockInternals.SetContext(MediaBlocksPipeline)
Associates this video renderer block with a pipeline and initializes its internal context.
This method is called internally when the block is added to a pipeline.
```csharp
void IMediaBlockInternals.SetContext(MediaBlocksPipeline pipeline)
```
#### Parameters
Parameters:
- pipeline (MediaBlocksPipeline): The MediaBlocksPipeline instance that will manage this block.
## See Also
---
# Namespace VisioForge.Core.MediaBlocks.VideoRendering
Link: api/VisioForge.Core.MediaBlocks.VideoRendering.html
# Namespace VisioForge.Core.MediaBlocks.VideoRendering
# Namespace VisioForge.Core.MediaBlocks.VideoRendering
### Classes
Parameters:
- (): Cross-platform video renderer block providing display output for video streams.
This block serves as the final destination for video in a media pipeline, rendering frames
to various display surfaces across different platforms and UI frameworks. Features include
hardware-accelerated rendering using platform-specific APIs (Direct3D 11 on Windows,
OpenGL ES on mobile, Metal on Apple platforms), support for multiple UI frameworks
(WPF, WinForms, MAUI, WinUI, Android Views, iOS/macOS views), subtitle overlay rendering,
snapshot capture functionality, frame stepping, and playback rate control. The renderer
automatically selects the optimal rendering path based on the platform and UI framework,
providing native performance while maintaining a consistent API. Essential for media players,
video editors, streaming clients, video conferencing apps, and any application requiring
high-quality video display with minimal latency.
Implements the This class serves as the primary entry point for reading media file information across different platforms. It automatically selects the appropriate underlying implementation:
The class supports both local files and remote URIs, providing synchronous and asynchronous
methods for opening media sources. After successfully opening a file, access the
null, a default context will be created internally.
#### Remarks
The context allows customization of logging behavior and provides platform-specific
settings. When sharing a context across multiple SDK instances, logging output
will be consolidated for easier debugging.
### MediaInfoReaderX(MediaPlayerCoreX)
Initializes a new instance of the player is null.
## Properties
### DeepDiscovery
Gets or sets a value indicating whether deep discovery mode is enabled.
```csharp
public bool DeepDiscovery { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
When enabled, deep discovery mode uses GStreamer's uridecodebin element directly instead of the GstDiscoverer API. This approach can be more reliable for:
The trade-off is that deep discovery may be slower for standard media files where GstDiscoverer would work efficiently. Consider enabling this option only when the default discovery mode fails to extract complete information.
This property is not available on iOS platforms where AVFoundation is used instead.
### Info Gets the media file information discovered after opening a media source. ```csharp public MediaFileInfo Info { get; } ``` #### Property Value Parameters: - (MediaFileInfo): ## Methods ### GetFileSnapshotRGB(Stream, TimeSpan?, ContextX, CancellationToken, TimeSpan?) Captures a snapshot from a media stream and returns 24-bit RGB pixel data. ```csharp public static Tuplenull, the first frame (0 seconds) is used.
- context (ContextX): Optional SDK context for logging. If null, a default context is created.
- cancellationToken (CancellationToken): Token used to cancel snapshot capture.
- timeout (TimeSpan ?): Optional timeout for receiving a frame. If null, defaults to 10 seconds.
#### Returns
Parameters:
- (Tuple < byte [ ] , int , int >): A tuple containing: (RGB byte array, width, height). The byte array is interleaved RGB (3 bytes per pixel),
row-major order. The byte array can be null if no frame could be captured.
#### Remarks
This overload writes the stream to a temporary file on disk, then delegates to
stream is null.
### GetFileSnapshotRGB(string, TimeSpan?, ContextX, CancellationToken, TimeSpan?)
Captures a snapshot from a media file and returns 24-bit RGB pixel data.
```csharp
public static Tuplenull, the first frame (0 seconds) is used.
- context (ContextX): Optional SDK context for logging. If null, a default context is created.
- cancellationToken (CancellationToken): Token used to cancel snapshot capture.
- timeout (TimeSpan ?): Optional timeout for receiving a frame. If null, defaults to 10 seconds.
#### Returns
Parameters:
- (Tuple < byte [ ] , int , int >): A tuple containing: (RGB byte array, width, height). The byte array is interleaved RGB (3 bytes per pixel),
row-major order. The byte array can be null if no frame could be captured.
#### Remarks
The implementation builds a small GStreamer pipeline based on uridecodebin and performs an accurate seek
where possible. Some formats/containers may return the nearest decodable frame rather than an exact timestamp.
#### Exceptions
Parameters:
- (ArgumentException): Thrown when filename is null or empty.
### GetFileSnapshotSKBitmap(string, TimeSpan?, ContextX, CancellationToken, TimeSpan?)
Captures a snapshot from a media file and returns it as an null if a frame could not be captured.
#### Exceptions
Parameters:
- (ArgumentException): Thrown when filename is null or empty.
### GetFileSnapshotSKBitmap(Stream, TimeSpan?, ContextX, CancellationToken, TimeSpan?)
Captures a snapshot from a media stream and returns it as an null if a frame could not be captured.
#### Exceptions
Parameters:
- (ArgumentNullException): Thrown when stream is null.
### Open(string)
Opens the specified file synchronously for media information extraction.
```csharp
public bool Open(string filename)
```
#### Parameters
Parameters:
- filename (string): The absolute or relative path to the media file to analyze.
The path will be automatically converted to a file URI internally.
#### Returns
Parameters:
- (bool): true if the file was successfully opened and analyzed; false if the
filename is null or empty, or if the file could not be opened.
#### Remarks
This method blocks the calling thread until the media file analysis is complete.
For UI applications or scenarios where responsiveness is important, prefer the
asynchronous
After successful completion, access the
true
if the media file was successfully opened and analyzed; otherwise, false.
#### Remarks
After successful completion, access the true
if the media file was successfully opened and analyzed; false if the filename
is null or empty, or if the file could not be opened.
#### Remarks
This is the most common method for opening local media files. After successful
completion, access the
Muting is different from setting
This property can be changed during playback for instant mute/unmute control. Changes take effect immediately without interrupting the audio stream. The volume level is preserved when muting and restored when unmuting.
If no audio renderer is active, getting this property returns false, and setting it updates a cached value
that will be applied when playback starts.
This property can be changed during playback for real-time volume adjustment. Changes take effect immediately. The volume setting is applied to the audio renderer in the pipeline before the signal reaches the audio output device.
Setting values above 1.0 amplifies the audio signal, which may result in clipping and distortion if the audio
is already at or near maximum levels. For pure muting without volume adjustment, use
If no audio renderer is active (pipeline not started), getting this property returns the cached volume value, and setting it updates the cached value that will be applied when playback starts.
### Audio_Play Gets or sets a value indicating whether audio playback is enabled in the media player. When set tofalse, the audio stream is muted and no audio processing occurs.
```csharp
public bool Audio_Play { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
This property must be set before calling false.
### Audio_Streams
Gets an observable collection of all audio streams detected in the currently loaded media.
Each stream contains metadata about codec, sample rate, bit depth, channel configuration, and language.
```csharp
public ObservableCollection
This collection is populated after opening a media source and the
Use
Custom audio outputs enable advanced scenarios such as:
Output blocks must be added to this collection before starting playback. When multiple outputs are configured, an audio tee (splitter) is automatically inserted in the pipeline to distribute samples to all outputs. Each output receives a copy of the processed audio after effects have been applied.
Performance note: Each output block processes audio independently. Multiple outputs may increase CPU usage depending on the operations performed by each output, though audio processing is generally less resource-intensive than video processing.
### Custom_Video_Outputs Gets the collection of custom video output blocks that receive processed video frames from the pipeline. These blocks can encode video to files, stream to network, or perform custom processing. ```csharp public ListCustom video outputs enable advanced scenarios such as:
Output blocks must be added to this collection before starting playback. When multiple outputs are configured, a video tee (splitter) is automatically inserted in the pipeline to distribute frames to all outputs.
Performance note: Each output block processes video independently. Multiple outputs may significantly increase CPU/GPU usage depending on the operations performed by each output.
### Debug_Dir Gets or sets the directory path where debug log files and pipeline graphs will be saved. This directory is used for storing debug information including Serilog logs and GStreamer pipeline DOT files. ```csharp public string Debug_Dir { get; set; } ``` #### Property Value Parameters: - (string): #### Remarks Whenmedia_player_log_YYYYMMDD_HHMMSS.txt
Pipeline graph files created by
Changing this property triggers a logger reconfiguration, closing the current log file and creating a new one
in the new directory if
This property controls the default error notification behavior:
false: Error dialogs are shown automatically (Windows only)true: Errors are logged but no dialogs appear
Set to true in production applications to prevent unexpected dialogs from disrupting the user experience.
Always implement
Debug mode affects logging behavior:
Debug log files are created in
Warning: Keep debug mode disabled in production to avoid performance impact and excessive disk usage from detailed logging. Enable only during development or when diagnosing issues.
### Debug_Telemetry Gets or sets a value indicating whether anonymous telemetry data should be sent during development and debugging. Telemetry helps improve SDK quality by providing anonymous crash reports and error diagnostics. ```csharp public bool Debug_Telemetry { get; set; } ``` #### Property Value Parameters: - (bool): #### RemarksPrivacy Notice: Only anonymous diagnostic data is collected. No personally identifiable information, media content, or application-specific data is transmitted. Telemetry only functions when:
trueCollected data includes: exception types, error messages, SDK version, and general usage patterns. This helps VisioForge identify and fix issues more quickly.
Note: Telemetry functionality is currently disabled in the SDK.
### Face_Detector Gets or sets the face detection processor for real-time face detection and tracking in video frames. When configured, the detector analyzes each video frame and raisesFace detection enables applications to:
The face detector must support the video format being processed. Not all pixel formats are supported by all detectors. If the video format is incompatible, an error is logged and face detection is skipped for those frames.
This property must be set before starting playback. Face detection has performance implications; the impact depends on the detector implementation, video resolution, and frame rate.
### Fonts Gets a collection of all available system fonts that can be used for text overlays, subtitles, and other text rendering. This collection is populated by enumerating fonts installed on the system. ```csharp public ObservableCollectionThis property is useful when implementing:
The font collection includes system fonts, custom installed fonts, and application-bundled fonts. Font availability may vary across platforms and system configurations.
### Loop Gets or sets a value indicating whether media playback will automatically restart from the beginning when the end is reached, creating continuous looping playback. ```csharp public bool Loop { get; set; } ``` #### Property Value Parameters: - (bool): #### RemarksWhen enabled, the player automatically seeks back to the start position when reaching the end of the media, creating seamless continuous playback. This is useful for:
This property must be set before calling
This property changes the end-of-playback behavior:
true: Player pauses at the last frame, keeping the video visible and allowing immediate resume or seekingfalse: Player stops completely, releases resources, and may clear the displayThis is useful for:
This property must be set before calling
This property enables segment playback for scenarios such as:
When used with
The start position should be less than the media duration and less than
This property enables limited playback duration for scenarios such as:
When used with
The stop position should be greater than
This property must be enabled before calling
The snapshot grabber maintains a single frame buffer updated with each new frame during playback. This has minimal memory overhead (one frame) and negligible performance impact. The stored frame is always the most recently rendered frame.
Use cases include:
This collection is populated after opening a media source and the
Common subtitle formats detected:
For external subtitle files, use the
This property controls subtitle visibility for:
This property can be toggled during playback to show/hide subtitles in real-time. Subtitle appearance
is controlled by
If the media has no subtitle streams and no external subtitle file is specified, this property has no visible effect.
### Subtitles_ExternalFile Gets or sets the path to an external subtitle file to be displayed along with the video. Supports common subtitle formats including SRT, SSA, ASS, and VTT. ```csharp public string Subtitles_ExternalFile { get; set; } ``` #### Property Value Parameters: - (string): #### RemarksSupported subtitle file formats:
This property should be set before calling
External subtitles are useful when:
Subtitle settings include:
After modifying subtitle settings, call
These settings affect both embedded subtitles and external subtitle files loaded via
Video composition enables:
This property must be set to true before starting playback to activate the composition pipeline.
Once enabled, use
Performance note: Enabling video composition adds processing overhead. The impact depends on the number and complexity of composition elements.
### Video_Play Gets or sets a value indicating whether video playback and rendering is enabled in the media player. When set tofalse, only audio is processed and no video rendering occurs.
```csharp
public bool Video_Play { get; set; }
```
#### Property Value
Parameters:
- (bool):
#### Remarks
This property must be set before calling false.
### Video_Processors
Gets the collection of custom video processors that will be applied to each video frame during playback.
Video processors enable custom frame analysis, computer vision operations, and real-time video modifications.
```csharp
public ListVideo processors enable custom video frame processing for:
Each processor receives every video frame and can analyze or modify it. Processors must be added to this collection before starting playback. Each processor must support the video pixel format being used, or frames will be skipped with error logging.
Performance consideration: Video processors run on the video frame callback thread. Complex processing may impact playback performance and cause frame drops. Consider using async processing or dedicated threads for computationally intensive operations.
### Video_Streams Gets an observable collection of all video streams detected in the currently loaded media. Each stream contains metadata about codec, resolution, frame rate, and other video properties. ```csharp public ObservableCollection
This collection is populated after opening a media source and the
Use
null.
#### Remarks
This method supports dynamic audio effect management during playback. When updating an existing effect,
the audio stream will smoothly transition to the new effect parameters without artifacts.
Effect names are used as unique identifiers, so ensure each effect has a distinct name if you want
to apply multiple effects of the same type simultaneously.
### Audio_Effects_Clear()
Clears all audio effects from the pipeline, returning audio processing to the original unmodified stream.
This method removes all active audio effects and resets the audio processing chain to its default state.
The audio playback continues without interruption using the original, unprocessed audio signal.
```csharp
public void Audio_Effects_Clear()
```
#### Remarks
This method is useful when you want to quickly disable all audio processing and return to the original audio.
All effect update event handlers are disconnected, and both cross-platform effects and platform-specific
DSP effects are cleared from the pipeline. The operation completes smoothly without audio artifacts.
### Audio_Effects_Remove(BaseAudioEffect)
Removes an audio effect from the pipeline by its instance.
Once removed, the effect will no longer be applied to the audio stream.
The audio processing will continue with the remaining active effects in the pipeline.
```csharp
public void Audio_Effects_Remove(BaseAudioEffect effect)
```
#### Parameters
Parameters:
- effect (BaseAudioEffect): The audio effect instance to remove from the pipeline. Must not be null.
#### Remarks
This method disconnects the effect's update event handlers and removes it from the internal effects collection.
If the effect is not found in the pipeline, this method completes without error.
The audio stream will smoothly adapt to the removal without interruption.
### Audio_OutputDevicesAsync(AudioOutputDeviceAPI?)
Gets the output audio devices asynchronous.
```csharp
public Tasktrue if the audio stream was successfully switched; false if the operation failed due to invalid source, null stream, or stream event failure.
#### Remarks
Audio stream switching behavior:
- Maintains current video stream while switching audio
- Sends a SELECT_STREAMS event to the underlying media pipeline
- Works during active playback without interruption
- Requires the media to contain multiple audio streams
- The target stream must be available in the current media content
Use this method for implementing audio track selection in media players with multi-language or multi-channel content.
### Debug_SavePipeline(string)
Saves the current media processing pipeline graph to a DOT file for debugging and visualization.
The DOT file can be converted to an image using Graphviz tools to visualize the complete pipeline structure,
including all MediaBlocks elements, their connections, and their current state. This is invaluable for
debugging complex pipeline configurations and understanding the data flow through the media processing chain.
```csharp
public void Debug_SavePipeline(string name)
```
#### Parameters
Parameters:
- name (string): The base name to use for the saved pipeline graph file (without extension).
The file will be saved in the directory specified by dot -Tpng filename.dot -o output.pngname is null/empty or if no pipeline is currently active.
### Dispose(bool)
Releases unmanaged and - optionally - managed resources.
```csharp
protected virtual void Dispose(bool disposing)
```
#### Parameters
Parameters:
- disposing (bool): true to release both managed and unmanaged resources; false to release only unmanaged resources.
### Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
```csharp
public void Dispose()
```
### DisposeAsync()
Disposes the MediaPlayerCoreX instance asynchronously.
```csharp
public ValueTask DisposeAsync()
```
#### Returns
Parameters:
- (ValueTask): A ValueTask representing the asynchronous dispose operation.
### Duration()
Gets the total duration of the currently loaded media content.
```csharp
public TimeSpan Duration()
```
#### Returns
Parameters:
- (TimeSpan): The media duration as a null if not initialized. The context includes Info, Warning, and Error logging methods
with support for structured logging and exception tracking.
#### Remarks
The context provides a unified logging interface that all MediaBlocks components use for reporting
their status, warnings, and errors. Applications can access this context to understand the internal
state of the pipeline or to add custom logging that integrates with the SDK's logging system.
### GetLogger()
Gets the Serilog logger instance used by the MediaPlayerX for centralized logging across all components.
This logger is used throughout the MediaPlayerX and underlying MediaBlocks pipeline for consistent logging.
Applications can use this logger to integrate their own logging with the SDK's logging infrastructure.
```csharp
public ILogger GetLogger()
```
#### Returns
Parameters:
- (ILogger): The true if the frame step operation was successful; false if it failed due to missing video renderer or unsupported source.
#### Remarks
Frame stepping behavior:
- Automatically pauses playback before stepping to ensure precise control
- Handles negative playback rates by switching to positive rate during the step
- Requires a video renderer to be configured in the player
- Only works with seekable media sources (files), not live streams
- The step size respects the current playback rate for timing calculations
Use this method for precise video analysis, educational content, or debugging purposes.
### OnPropertyChanged(string)
Raises the [CallerMemberName] attribute.
#### Remarks
This method implements the true if the source was successfully opened; false otherwise.
### OpenAsync(string)
Asynchronously opens a media file or network URL for playback.
This convenience method automatically creates appropriate source settings based on the filename or URL.
```csharp
public Tasktrue if the file or URL was successfully opened; false otherwise.
### OpenAsync(Uri)
Asynchronously opens a media source from the specified URI for playback.
This convenience method automatically creates appropriate source settings based on the URI scheme.
```csharp
public Tasktrue if the URI was successfully opened; false otherwise.
### Pause()
Pauses media playback synchronously while preserving the current playback position.
```csharp
public bool Pause()
```
#### Returns
Parameters:
- (bool): true if pause was successful; false otherwise.
### PauseAsync()
Asynchronously pauses media playback while preserving the current playback position.
```csharp
public Tasktrue if pause was successful; false otherwise.
### Play(bool)
Starts media playback synchronously or preloads the media content without starting playback.
```csharp
public bool Play(bool onlyPreload = false)
```
#### Parameters
Parameters:
- onlyPreload (bool): If set to true, only preloads the media pipeline without starting playback; otherwise starts playback immediately.
#### Returns
Parameters:
- (bool): true if playback started or preload completed successfully; false otherwise.
### PlayAsync(bool)
Asynchronously starts media playback or preloads the media content without starting playback.
```csharp
public Tasktrue, only preloads the media pipeline without starting playback; otherwise starts playback immediately.
#### Returns
Parameters:
- (Task < bool >): A task that returns true if playback started or preload completed successfully; false otherwise.
### Position_Get()
Gets the current playback position in the media.
```csharp
public TimeSpan Position_Get()
```
#### Returns
Parameters:
- (TimeSpan): The current position as a TimeSpan, or TimeSpan.Zero if no media is loaded.
### Position_GetAsync()
Asynchronously gets the current playback position in the media.
```csharp
public Tasktrue, seeks to the nearest keyframe.
### Position_SetRangeAsync(TimeSpan, TimeSpan, bool)
Asynchronously sets the playback range with start and stop positions.
```csharp
public Task Position_SetRangeAsync(TimeSpan startPosition, TimeSpan stopPosition, bool seekToKeyframe = false)
```
#### Parameters
Parameters:
- startPosition (TimeSpan): The start position for playback.
- stopPosition (TimeSpan): The stop position where playback will end.
- seekToKeyframe (bool): If set to true, seeks to the nearest keyframe.
#### Returns
Parameters:
- (Task): A task representing the asynchronous operation.
### PrevFrame()
Steps backward by exactly one frame (reverse frame stepping).
This method moves the playback position backward by a single frame using seek operations,
useful for precise video analysis in reverse. The operation requires seekable video content
and may be slower than forward frame stepping due to the need for precise backward seeking.
```csharp
public bool PrevFrame()
```
#### Returns
Parameters:
- (bool): true if the backward frame step was successful; false if it failed due to missing pipeline, no video streams, or seek limitations.
#### Remarks
Backward frame stepping limitations and behavior:
- Requires a valid pipeline and at least one video stream
- Only works with seekable media sources (files), not live streams
- Uses seek operations which may be slower than forward stepping
- Accuracy depends on the underlying codec's ability to seek to exact frames
- May not work reliably with all video formats or codecs
- Performance varies based on video compression and keyframe intervals
This method is primarily intended for video analysis and educational purposes where precise backward navigation is needed.
### Rate_Get()
Gets the current playback rate.
```csharp
public double Rate_Get()
```
#### Returns
Parameters:
- (double): The playback rate (1.0 = normal speed, 2.0 = double speed, etc.).
### Rate_GetAsync()
Asynchronously gets the current playback rate.
```csharp
public Tasktrue if resume was successful; false otherwise.
### ResumeAsync()
Asynchronously resumes media playback from a paused state.
```csharp
public Tasktrue if resume was successful; false otherwise.
### SetCustomErrorHandler(IMediaBlocksPipelineCustomErrorHandler)
Sets a custom error handler for the media blocks pipeline to override default error handling behavior.
This allows applications to implement specialized error handling logic for pipeline errors,
such as automatic retry logic, error logging to external systems, or graceful degradation strategies.
```csharp
public void SetCustomErrorHandler(IMediaBlocksPipelineCustomErrorHandler errorHandler)
```
#### Parameters
Parameters:
- errorHandler (IMediaBlocksPipelineCustomErrorHandler): The custom error handler implementation. Set to null to use default error handling.
#### Remarks
The custom error handler will receive all errors from the MediaBlocks pipeline before they are
processed by the default error handling system. This provides an opportunity to inspect, log,
or handle errors in application-specific ways. The handler can choose to suppress errors or
allow them to propagate to the default handlers.
### SetLicenseKey(string, string, string)
Activates the MediaPlayerX with a commercial license key to remove trial limitations and enable full functionality.
This method must be called before opening any media source to apply the license. Without a valid license,
the player operates in trial mode with evaluation watermarks and time restrictions.
```csharp
public void SetLicenseKey(string licenseKey, string username, string email)
```
#### Parameters
Parameters:
- licenseKey (string): The license key string received after purchase from VisioForge. This key is unique to your license.
- username (string): The username or company name associated with the license purchase (currently not validated but reserved for future use).
- email (string): The email address associated with the license purchase (currently not validated but reserved for future use).
#### Examples
mediaPlayer.SetLicenseKey("your_license_key", "username", "email@example.com");The license key determines which features and edition capabilities are available:
Best practices:
true if settings were loaded and applied successfully; false if the file doesn't exist,
contains invalid JSON, or deserialization fails.
#### Remarks
This method is currently not implemented and will always return false. It is reserved for future functionality
to support saving and loading complete player configurations including effects, source settings, and playback parameters.
When implemented, it will allow users to save player presets and quickly restore them across sessions.
### Settings_Save(string, string)
Saves current player settings to a JSON file with optional SDK information file for version tracking.
The JSON file contains serialized player configuration that can be loaded later using null or empty string to skip creating the info file.
#### Returns
Parameters:
- (bool): Returns true if the settings files were saved successfully; false if file creation or writing fails.
#### Remarks
The method creates two files when infoFilename is provided:
jsonFilename: Contains serialized player configurationinfoFilename: Contains SDK version information for compatibility trackingfalse.
### Snapshot_Get()
Gets a snapshot of the current video frame as a VideoFrameX object.
```csharp
public VideoFrameX Snapshot_Get()
```
#### Returns
Parameters:
- (VideoFrameX): The video frame snapshot, or null if unavailable.
### Snapshot_GetAsync()
Asynchronously gets a snapshot of the current video frame as a VideoFrameX object.
```csharp
public Tasknull otherwise.
### Video_Effects_RemoveAsync(IBaseVideoEffect)
Asynchronously removes a video effect from the pipeline.
Temporarily pauses playback during removal to ensure smooth effect removal without artifacts.
```csharp
public Task Video_Effects_RemoveAsync(IBaseVideoEffect effect)
```
#### Parameters
Parameters:
- effect (IBaseVideoEffect): The video effect instance to remove from the pipeline.
#### Returns
Parameters:
- (Task): A task representing the asynchronous operation.
### Video_Effects_RemoveAsync(string)
Removes a video effect by name asynchronously. Pauses playback during removal.
```csharp
public Task Video_Effects_RemoveAsync(string name)
```
#### Parameters
Parameters:
- name (string): The name of the effect to remove.
#### Returns
Parameters:
- (Task): A Task representing the asynchronous operation.
### Video_Stream_Select(VideoStreamInfo)
Switches to a different video stream in multi-stream media content.
This method allows dynamic switching between video tracks during playback, useful for content
with multiple video angles, resolutions, or different video content tracks. The switch occurs
seamlessly while maintaining audio playback if present.
```csharp
public bool Video_Stream_Select(VideoStreamInfo stream)
```
#### Parameters
Parameters:
- stream (VideoStreamInfo): The target video stream to switch to. Must be a valid true if the video stream was successfully switched; false if the operation failed due to invalid source, null stream, or stream event failure.
#### Remarks
Video stream switching behavior:
- Maintains current audio stream while switching video
- Sends a SELECT_STREAMS event to the underlying media pipeline
- Works during active playback without stopping
- Requires the media to contain multiple video streams
- May cause brief visual interruption during the switch
- The target stream must be available in the current media content
Common use cases include multi-angle video content, adaptive bitrate streaming, or educational content with multiple camera views.
### IMediaPlayerControls.GetFileThumbnail(string)
Gets a thumbnail image from the specified media file.
```csharp
SKBitmap IMediaPlayerControls.GetFileThumbnail(string filename)
```
#### Parameters
Parameters:
- filename (string): The path to the media file.
#### Returns
Parameters:
- (SKBitmap): An SKBitmap containing the thumbnail image.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not yet implemented.
### IMediaPlayerControls.NextFrame()
Advances to and displays the next frame in the video.
```csharp
bool IMediaPlayerControls.NextFrame()
```
#### Returns
Parameters:
- (bool): Returns true if successful, false otherwise.
### IMediaPlayerControls.OpenAsync(string)
Opens the specified file or URL asynchronously.
```csharp
Tasktrue, video is flipped horizontally.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not yet implemented.
### IVideoEffectsControls.VideoEffects_SetFlipY(bool)
Enables or disables vertical video flipping.
```csharp
void IVideoEffectsControls.VideoEffects_SetFlipY(bool value)
```
#### Parameters
Parameters:
- value (bool): If set to true, video is flipped vertically.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not yet implemented.
### IVideoEffectsControls.VideoEffects_SetGrayscale(bool)
Enables or disables the grayscale video effect.
```csharp
void IVideoEffectsControls.VideoEffects_SetGrayscale(bool value)
```
#### Parameters
Parameters:
- value (bool): If set to true, grayscale effect is enabled.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not yet implemented.
### IVideoEffectsControls.VideoEffects_SetInvert(bool)
Enables or disables the color invert video effect.
```csharp
void IVideoEffectsControls.VideoEffects_SetInvert(bool value)
```
#### Parameters
Parameters:
- value (bool): If set to true, color invert effect is enabled.
#### Exceptions
Parameters:
- (NotImplementedException): This method is not yet implemented.
### IVideoEffectsControls.VideoEffects_SetSaturation(double)
Sets the video saturation adjustment level.
```csharp
void IVideoEffectsControls.VideoEffects_SetSaturation(double value)
```
#### Parameters
Parameters:
- value (double): The saturation value (typically -1.0 to 1.0).
#### Exceptions
Parameters:
- (NotImplementedException): This method is not yet implemented.
### OnAudioFrameBuffer
Occurs whenever a new audio frame is received from the pipeline.
Provides access to raw audio data for analysis, processing, or custom rendering.
```csharp
public event EventHandler